Page MenuHomePhabricator
Differential D11718

[CommCoreModule] add sequential decrypt to crypto API
ClosedPublic
Actions

Authored by kamil on Apr 22 2024, 3:32 PM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Mar 11, 11:45 AM
Unknown Object (File)
Mar 6 2025, 10:27 PM
Unknown Object (File)
Feb 27 2025, 3:30 PM
Unknown Object (File)
Feb 22 2025, 10:47 AM
Unknown Object (File)
Feb 22 2025, 10:47 AM
Unknown Object (File)
Feb 22 2025, 10:47 AM
Unknown Object (File)
Feb 22 2025, 10:47 AM
Unknown Object (File)
Feb 21 2025, 1:17 AM
View All 67 Files
Subscribers
ashoat

Details

Reviewers
tomek
marcin
Commits
rCOMM5614c6e730ac: [CommCoreModule] add sequential decrypt to crypto API
Summary

Binding to olm method to sequential decrypt. Implementing different because this method will also be responsible for persisting message in SQLite (added later in the stack).

Depends on D11717

Test Plan

Created session between two native clients:

  1. Sending couple of encrypted messsages
  2. Sending messages with wrong order -> OLM_MESSAGE_OUT_OF_ORDER
  3. Sending the same message multiple times -> OLM_ALREADY_DECRYPTED_OR_KEYS_SKIPPED

Diff Detail

Repository
rCOMM Comm
Branch
publish-receiver
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

kamil created this revision.Apr 22 2024, 3:32 PM
kamil held this revision as a draft.
Herald added a subscriber: ashoat. · View Herald TranscriptApr 22 2024, 3:32 PM
kamil added inline comments.Apr 22 2024, 3:35 PM
native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp
1374

not used yet but this is needed to persist message - added later in the stack

kamil added a child revision: D11719: [web/lib] add sequential decrypt to `olmAPI`.Apr 22 2024, 3:42 PM
Harbormaster completed remote builds in B28375: Diff 39369.Apr 22 2024, 3:51 PM
kamil published this revision for review.Apr 23 2024, 6:37 AM
marcin accepted this revision.Apr 24 2024, 3:09 AM
marcin added inline comments.
web/cpp/SQLiteQueryExecutorBindings.cpp
65

Looks like someone accidentally forgot to run yarn clang-format-all. Ideally we could fix it so that it is automatically run on as a commit hook.

This revision is now accepted and ready to land.Apr 24 2024, 3:09 AM
kamil added inline comments.Apr 29 2024, 12:58 AM
web/cpp/SQLiteQueryExecutorBindings.cpp
65

ENG-8019

Closed by commit rCOMM5614c6e730ac: [CommCoreModule] add sequential decrypt to crypto API (authored by kamil). · Explain WhyApr 29 2024, 1:11 AM
This revision was automatically updated to reflect the committed changes.
kamil added a commit: rCOMM5614c6e730ac: [CommCoreModule] add sequential decrypt to crypto API.

Revision Contents
Changeset List

PathSize
native/
cpp/
CommonCpp/
NativeModules/
5 lines
39 lines
_generated/
schema/
10 lines
web/
cpp/
4 lines

Diff 39369

View Options

native/cpp/CommonCpp/NativeModules/CommCoreModule.h

Show All 18 Linesjsi::Array KeyserverStore::parseDBDataStore(
std::shared_ptr<std::vector<KeyserverInfo>> keyserversVectorPtr) const { std::shared_ptr<std::vector<KeyserverInfo>> keyserversVectorPtr) const {
size_t numKeyservers = keyserversVectorPtr->size(); size_t numKeyservers = keyserversVectorPtr->size();
jsi::Array jsiKeyservers = jsi::Array(rt, numKeyservers); jsi::Array jsiKeyservers = jsi::Array(rt, numKeyservers);
size_t writeIdx = 0; size_t writeIdx = 0;
for (const KeyserverInfo &keyserver : *keyserversVectorPtr) { for (const KeyserverInfo &keyserver : *keyserversVectorPtr) {
jsi::Object jsiKeyserver = jsi::Object(rt); jsi::Object jsiKeyserver = jsi::Object(rt);
jsiKeyserver.setProperty(rt, "id", keyserver.id); jsiKeyserver.setProperty(rt, "id", keyserver.id);
jsiKeyserver.setProperty(rt, "keyserverInfo", keyserver.keyserver_info); jsiKeyserver.setProperty(rt, "keyserverInfo", keyserver.keyserver_info);
jsiKeyserver.setProperty(
rt, "syncedKeyserverInfo", keyserver.synced_keyserver_info);
jsiKeyservers.setValueAtIndex(rt, writeIdx++, jsiKeyserver); jsiKeyservers.setValueAtIndex(rt, writeIdx++, jsiKeyserver);
} }
return jsiKeyservers; return jsiKeyservers;
} }
std::vector<std::unique_ptr<KeyserverStoreOperationBase>> std::vector<std::unique_ptr<KeyserverStoreOperationBase>>
KeyserverStore::createOperations(jsi::Runtime &rt, const jsi::Array &operations) KeyserverStore::createOperations(jsi::Runtime &rt, const jsi::Array &operations)
const { const {
Show All 20 Lines for (size_t idx = 0; idx < operations.size(rt); idx++) {
} else if (opType == REMOVE_ALL_OPERATION) { } else if (opType == REMOVE_ALL_OPERATION) {
keyserverStoreOps.push_back( keyserverStoreOps.push_back(
std::make_unique<RemoveAllKeyserversOperation>()); std::make_unique<RemoveAllKeyserversOperation>());
} else if (opType == REPLACE_OPERATION) { } else if (opType == REPLACE_OPERATION) {
jsi::Object payloadObj = op.getProperty(rt, "payload").asObject(rt); jsi::Object payloadObj = op.getProperty(rt, "payload").asObject(rt);
std::string id = payloadObj.getProperty(rt, "id").asString(rt).utf8(rt); std::string id = payloadObj.getProperty(rt, "id").asString(rt).utf8(rt);
std::string keyserver_info = std::string keyserver_info =
payloadObj.getProperty(rt, "keyserverInfo").asString(rt).utf8(rt); payloadObj.getProperty(rt, "keyserverInfo").asString(rt).utf8(rt);
std::string synced_keyserver_info =
payloadObj.getProperty(rt, "syncedKeyserverInfo")
.asString(rt)
.utf8(rt);
KeyserverInfo keyserver{id, keyserver_info}; KeyserverInfo keyserver{id, keyserver_info, synced_keyserver_info};
keyserverStoreOps.push_back( keyserverStoreOps.push_back(
std::make_unique<ReplaceKeyserverOperation>(std::move(keyserver))); std::make_unique<ReplaceKeyserverOperation>(std::move(keyserver)));
} else { } else {
throw std::runtime_error("unsupported operation: " + opType); throw std::runtime_error("unsupported operation: " + opType);
} }
}; };
return keyserverStoreOps; return keyserverStoreOps;
} }
} // namespace comm } // namespace comm
View Options

native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp

Show All 18 Linesjsi::Array KeyserverStore::parseDBDataStore(
std::shared_ptr<std::vector<KeyserverInfo>> keyserversVectorPtr) const { std::shared_ptr<std::vector<KeyserverInfo>> keyserversVectorPtr) const {
size_t numKeyservers = keyserversVectorPtr->size(); size_t numKeyservers = keyserversVectorPtr->size();
jsi::Array jsiKeyservers = jsi::Array(rt, numKeyservers); jsi::Array jsiKeyservers = jsi::Array(rt, numKeyservers);
size_t writeIdx = 0; size_t writeIdx = 0;
for (const KeyserverInfo &keyserver : *keyserversVectorPtr) { for (const KeyserverInfo &keyserver : *keyserversVectorPtr) {
jsi::Object jsiKeyserver = jsi::Object(rt); jsi::Object jsiKeyserver = jsi::Object(rt);
jsiKeyserver.setProperty(rt, "id", keyserver.id); jsiKeyserver.setProperty(rt, "id", keyserver.id);
jsiKeyserver.setProperty(rt, "keyserverInfo", keyserver.keyserver_info); jsiKeyserver.setProperty(rt, "keyserverInfo", keyserver.keyserver_info);
jsiKeyserver.setProperty(
rt, "syncedKeyserverInfo", keyserver.synced_keyserver_info);
jsiKeyservers.setValueAtIndex(rt, writeIdx++, jsiKeyserver); jsiKeyservers.setValueAtIndex(rt, writeIdx++, jsiKeyserver);
} }
return jsiKeyservers; return jsiKeyservers;
} }
std::vector<std::unique_ptr<KeyserverStoreOperationBase>> std::vector<std::unique_ptr<KeyserverStoreOperationBase>>
KeyserverStore::createOperations(jsi::Runtime &rt, const jsi::Array &operations) KeyserverStore::createOperations(jsi::Runtime &rt, const jsi::Array &operations)
const { const {
Show All 20 Lines for (size_t idx = 0; idx < operations.size(rt); idx++) {
} else if (opType == REMOVE_ALL_OPERATION) { } else if (opType == REMOVE_ALL_OPERATION) {
keyserverStoreOps.push_back( keyserverStoreOps.push_back(
std::make_unique<RemoveAllKeyserversOperation>()); std::make_unique<RemoveAllKeyserversOperation>());
} else if (opType == REPLACE_OPERATION) { } else if (opType == REPLACE_OPERATION) {
jsi::Object payloadObj = op.getProperty(rt, "payload").asObject(rt); jsi::Object payloadObj = op.getProperty(rt, "payload").asObject(rt);
std::string id = payloadObj.getProperty(rt, "id").asString(rt).utf8(rt); std::string id = payloadObj.getProperty(rt, "id").asString(rt).utf8(rt);
std::string keyserver_info = std::string keyserver_info =
payloadObj.getProperty(rt, "keyserverInfo").asString(rt).utf8(rt); payloadObj.getProperty(rt, "keyserverInfo").asString(rt).utf8(rt);
std::string synced_keyserver_info =
payloadObj.getProperty(rt, "syncedKeyserverInfo")
.asString(rt)
.utf8(rt);
KeyserverInfo keyserver{id, keyserver_info}; KeyserverInfo keyserver{id, keyserver_info, synced_keyserver_info};
keyserverStoreOps.push_back( keyserverStoreOps.push_back(
std::make_unique<ReplaceKeyserverOperation>(std::move(keyserver))); std::make_unique<ReplaceKeyserverOperation>(std::move(keyserver)));
} else { } else {
throw std::runtime_error("unsupported operation: " + opType); throw std::runtime_error("unsupported operation: " + opType);
} }
}; };
return keyserverStoreOps; return keyserverStoreOps;
} }
} // namespace comm } // namespace comm
View Options

native/cpp/CommonCpp/_generated/commJSI-generated.cpp

Show All 18 Linesjsi::Array KeyserverStore::parseDBDataStore(
std::shared_ptr<std::vector<KeyserverInfo>> keyserversVectorPtr) const { std::shared_ptr<std::vector<KeyserverInfo>> keyserversVectorPtr) const {
size_t numKeyservers = keyserversVectorPtr->size(); size_t numKeyservers = keyserversVectorPtr->size();
jsi::Array jsiKeyservers = jsi::Array(rt, numKeyservers); jsi::Array jsiKeyservers = jsi::Array(rt, numKeyservers);
size_t writeIdx = 0; size_t writeIdx = 0;
for (const KeyserverInfo &keyserver : *keyserversVectorPtr) { for (const KeyserverInfo &keyserver : *keyserversVectorPtr) {
jsi::Object jsiKeyserver = jsi::Object(rt); jsi::Object jsiKeyserver = jsi::Object(rt);
jsiKeyserver.setProperty(rt, "id", keyserver.id); jsiKeyserver.setProperty(rt, "id", keyserver.id);
jsiKeyserver.setProperty(rt, "keyserverInfo", keyserver.keyserver_info); jsiKeyserver.setProperty(rt, "keyserverInfo", keyserver.keyserver_info);
jsiKeyserver.setProperty(
rt, "syncedKeyserverInfo", keyserver.synced_keyserver_info);
jsiKeyservers.setValueAtIndex(rt, writeIdx++, jsiKeyserver); jsiKeyservers.setValueAtIndex(rt, writeIdx++, jsiKeyserver);
} }
return jsiKeyservers; return jsiKeyservers;
} }
std::vector<std::unique_ptr<KeyserverStoreOperationBase>> std::vector<std::unique_ptr<KeyserverStoreOperationBase>>
KeyserverStore::createOperations(jsi::Runtime &rt, const jsi::Array &operations) KeyserverStore::createOperations(jsi::Runtime &rt, const jsi::Array &operations)
const { const {
Show All 20 Lines for (size_t idx = 0; idx < operations.size(rt); idx++) {
} else if (opType == REMOVE_ALL_OPERATION) { } else if (opType == REMOVE_ALL_OPERATION) {
keyserverStoreOps.push_back( keyserverStoreOps.push_back(
std::make_unique<RemoveAllKeyserversOperation>()); std::make_unique<RemoveAllKeyserversOperation>());
} else if (opType == REPLACE_OPERATION) { } else if (opType == REPLACE_OPERATION) {
jsi::Object payloadObj = op.getProperty(rt, "payload").asObject(rt); jsi::Object payloadObj = op.getProperty(rt, "payload").asObject(rt);
std::string id = payloadObj.getProperty(rt, "id").asString(rt).utf8(rt); std::string id = payloadObj.getProperty(rt, "id").asString(rt).utf8(rt);
std::string keyserver_info = std::string keyserver_info =
payloadObj.getProperty(rt, "keyserverInfo").asString(rt).utf8(rt); payloadObj.getProperty(rt, "keyserverInfo").asString(rt).utf8(rt);
std::string synced_keyserver_info =
payloadObj.getProperty(rt, "syncedKeyserverInfo")
.asString(rt)
.utf8(rt);
KeyserverInfo keyserver{id, keyserver_info}; KeyserverInfo keyserver{id, keyserver_info, synced_keyserver_info};
keyserverStoreOps.push_back( keyserverStoreOps.push_back(
std::make_unique<ReplaceKeyserverOperation>(std::move(keyserver))); std::make_unique<ReplaceKeyserverOperation>(std::move(keyserver)));
} else { } else {
throw std::runtime_error("unsupported operation: " + opType); throw std::runtime_error("unsupported operation: " + opType);
} }
}; };
return keyserverStoreOps; return keyserverStoreOps;
} }
} // namespace comm } // namespace comm
View Options

native/cpp/CommonCpp/_generated/commJSI.h

Show All 18 Linesjsi::Array KeyserverStore::parseDBDataStore(
std::shared_ptr<std::vector<KeyserverInfo>> keyserversVectorPtr) const { std::shared_ptr<std::vector<KeyserverInfo>> keyserversVectorPtr) const {
size_t numKeyservers = keyserversVectorPtr->size(); size_t numKeyservers = keyserversVectorPtr->size();
jsi::Array jsiKeyservers = jsi::Array(rt, numKeyservers); jsi::Array jsiKeyservers = jsi::Array(rt, numKeyservers);
size_t writeIdx = 0; size_t writeIdx = 0;
for (const KeyserverInfo &keyserver : *keyserversVectorPtr) { for (const KeyserverInfo &keyserver : *keyserversVectorPtr) {
jsi::Object jsiKeyserver = jsi::Object(rt); jsi::Object jsiKeyserver = jsi::Object(rt);
jsiKeyserver.setProperty(rt, "id", keyserver.id); jsiKeyserver.setProperty(rt, "id", keyserver.id);
jsiKeyserver.setProperty(rt, "keyserverInfo", keyserver.keyserver_info); jsiKeyserver.setProperty(rt, "keyserverInfo", keyserver.keyserver_info);
jsiKeyserver.setProperty(
rt, "syncedKeyserverInfo", keyserver.synced_keyserver_info);
jsiKeyservers.setValueAtIndex(rt, writeIdx++, jsiKeyserver); jsiKeyservers.setValueAtIndex(rt, writeIdx++, jsiKeyserver);
} }
return jsiKeyservers; return jsiKeyservers;
} }
std::vector<std::unique_ptr<KeyserverStoreOperationBase>> std::vector<std::unique_ptr<KeyserverStoreOperationBase>>
KeyserverStore::createOperations(jsi::Runtime &rt, const jsi::Array &operations) KeyserverStore::createOperations(jsi::Runtime &rt, const jsi::Array &operations)
const { const {
Show All 20 Lines for (size_t idx = 0; idx < operations.size(rt); idx++) {
} else if (opType == REMOVE_ALL_OPERATION) { } else if (opType == REMOVE_ALL_OPERATION) {
keyserverStoreOps.push_back( keyserverStoreOps.push_back(
std::make_unique<RemoveAllKeyserversOperation>()); std::make_unique<RemoveAllKeyserversOperation>());
} else if (opType == REPLACE_OPERATION) { } else if (opType == REPLACE_OPERATION) {
jsi::Object payloadObj = op.getProperty(rt, "payload").asObject(rt); jsi::Object payloadObj = op.getProperty(rt, "payload").asObject(rt);
std::string id = payloadObj.getProperty(rt, "id").asString(rt).utf8(rt); std::string id = payloadObj.getProperty(rt, "id").asString(rt).utf8(rt);
std::string keyserver_info = std::string keyserver_info =
payloadObj.getProperty(rt, "keyserverInfo").asString(rt).utf8(rt); payloadObj.getProperty(rt, "keyserverInfo").asString(rt).utf8(rt);
std::string synced_keyserver_info =
payloadObj.getProperty(rt, "syncedKeyserverInfo")
.asString(rt)
.utf8(rt);
KeyserverInfo keyserver{id, keyserver_info}; KeyserverInfo keyserver{id, keyserver_info, synced_keyserver_info};
keyserverStoreOps.push_back( keyserverStoreOps.push_back(
std::make_unique<ReplaceKeyserverOperation>(std::move(keyserver))); std::make_unique<ReplaceKeyserverOperation>(std::move(keyserver)));
} else { } else {
throw std::runtime_error("unsupported operation: " + opType); throw std::runtime_error("unsupported operation: " + opType);
} }
}; };
return keyserverStoreOps; return keyserverStoreOps;
} }
} // namespace comm } // namespace comm
View Options

native/schema/CommCoreModuleSchema.js

Show All 18 Linesjsi::Array KeyserverStore::parseDBDataStore(
std::shared_ptr<std::vector<KeyserverInfo>> keyserversVectorPtr) const { std::shared_ptr<std::vector<KeyserverInfo>> keyserversVectorPtr) const {
size_t numKeyservers = keyserversVectorPtr->size(); size_t numKeyservers = keyserversVectorPtr->size();
jsi::Array jsiKeyservers = jsi::Array(rt, numKeyservers); jsi::Array jsiKeyservers = jsi::Array(rt, numKeyservers);
size_t writeIdx = 0; size_t writeIdx = 0;
for (const KeyserverInfo &keyserver : *keyserversVectorPtr) { for (const KeyserverInfo &keyserver : *keyserversVectorPtr) {
jsi::Object jsiKeyserver = jsi::Object(rt); jsi::Object jsiKeyserver = jsi::Object(rt);
jsiKeyserver.setProperty(rt, "id", keyserver.id); jsiKeyserver.setProperty(rt, "id", keyserver.id);
jsiKeyserver.setProperty(rt, "keyserverInfo", keyserver.keyserver_info); jsiKeyserver.setProperty(rt, "keyserverInfo", keyserver.keyserver_info);
jsiKeyserver.setProperty(
rt, "syncedKeyserverInfo", keyserver.synced_keyserver_info);
jsiKeyservers.setValueAtIndex(rt, writeIdx++, jsiKeyserver); jsiKeyservers.setValueAtIndex(rt, writeIdx++, jsiKeyserver);
} }
return jsiKeyservers; return jsiKeyservers;
} }
std::vector<std::unique_ptr<KeyserverStoreOperationBase>> std::vector<std::unique_ptr<KeyserverStoreOperationBase>>
KeyserverStore::createOperations(jsi::Runtime &rt, const jsi::Array &operations) KeyserverStore::createOperations(jsi::Runtime &rt, const jsi::Array &operations)
const { const {
Show All 20 Lines for (size_t idx = 0; idx < operations.size(rt); idx++) {
} else if (opType == REMOVE_ALL_OPERATION) { } else if (opType == REMOVE_ALL_OPERATION) {
keyserverStoreOps.push_back( keyserverStoreOps.push_back(
std::make_unique<RemoveAllKeyserversOperation>()); std::make_unique<RemoveAllKeyserversOperation>());
} else if (opType == REPLACE_OPERATION) { } else if (opType == REPLACE_OPERATION) {
jsi::Object payloadObj = op.getProperty(rt, "payload").asObject(rt); jsi::Object payloadObj = op.getProperty(rt, "payload").asObject(rt);
std::string id = payloadObj.getProperty(rt, "id").asString(rt).utf8(rt); std::string id = payloadObj.getProperty(rt, "id").asString(rt).utf8(rt);
std::string keyserver_info = std::string keyserver_info =
payloadObj.getProperty(rt, "keyserverInfo").asString(rt).utf8(rt); payloadObj.getProperty(rt, "keyserverInfo").asString(rt).utf8(rt);
std::string synced_keyserver_info =
payloadObj.getProperty(rt, "syncedKeyserverInfo")
.asString(rt)
.utf8(rt);
KeyserverInfo keyserver{id, keyserver_info}; KeyserverInfo keyserver{id, keyserver_info, synced_keyserver_info};
keyserverStoreOps.push_back( keyserverStoreOps.push_back(
std::make_unique<ReplaceKeyserverOperation>(std::move(keyserver))); std::make_unique<ReplaceKeyserverOperation>(std::move(keyserver)));
} else { } else {
throw std::runtime_error("unsupported operation: " + opType); throw std::runtime_error("unsupported operation: " + opType);
} }
}; };
return keyserverStoreOps; return keyserverStoreOps;
} }
} // namespace comm } // namespace comm
View Options

web/cpp/SQLiteQueryExecutorBindings.cpp

Loading...