Page MenuHomePhabricator
Differential D3769

[web] Move `onChangeAccountPassword` up from `ThreadSettingsModal` to `ConnectedThreadSettingsModal`
ClosedPublic
Actions

Authored by atul on Apr 18 2022, 3:25 PM.
Tags
None
Referenced Files
F5318852: D3769.id.diff
Tue, Apr 8, 7:08 PM
Unknown Object (File)
Tue, Apr 8, 5:49 PM
Unknown Object (File)
Tue, Apr 8, 4:23 PM
Unknown Object (File)
Tue, Apr 8, 9:01 AM
Unknown Object (File)
Tue, Apr 8, 8:27 AM
Unknown Object (File)
Tue, Apr 8, 8:23 AM
Unknown Object (File)
Sun, Apr 6, 5:21 AM
Unknown Object (File)
Tue, Apr 1, 5:55 AM
View All Files
Subscribers
• abosh
• adrian
ashoat
• benschac
• karol

Details

Reviewers
• jacek
tomek
Commits
rCOMMd287cfc2fe2f: [web] Move `onChangeAccountPassword` up from `ThreadSettingsModal` to…
Summary

Move onChangeAccountPassword out from inner class component to outer "Connected" functional component.

As part of the work to refactor ThreadSettingsModal... specifically to turn it into a functional component.

Depends on D3768

Test Plan
  1. Open ThreadSettingsModal
  2. Change account password under delete tab
  3. Log values in onChangeAccountPassword to ensure that the state continues to change as expected

Diff Detail

Repository
rCOMM Comm
Branch
master
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

atul created this revision.Apr 18 2022, 3:25 PM
Herald added subscribers: • abosh, • benschac, • karol and 2 others. · View Herald TranscriptApr 18 2022, 3:25 PM
Harbormaster completed remote builds in B8282: Diff 11578.Apr 18 2022, 3:30 PM
atul requested review of this revision.Apr 18 2022, 3:30 PM
atul added a child revision: D3770: [web] Move `hasPermissionForTab` up from `ThreadSettingsModal` to `ConnectedThreadSettingsModal`.Apr 18 2022, 3:41 PM
atul updated this revision to Diff 11650.Apr 19 2022, 3:04 PM

rebase

Harbormaster failed remote builds in B8340: Diff 11650!Apr 19 2022, 3:24 PM
Harbormaster completed remote builds in B8340: Diff 11650.Apr 19 2022, 3:41 PM
tomek accepted this revision.Apr 21 2022, 3:11 AM
tomek added inline comments.
web/modals/threads/thread-settings-modal.react.js
457–463 ↗(On Diff #11650)

When a callback doesn't depend on anything, we can define the function outside the component. But on the other hand, it will break the flow of the code, so it's not necessarily worth it.

This revision is now accepted and ready to land.Apr 21 2022, 3:11 AM
atul added inline comments.Apr 21 2022, 11:18 AM
web/modals/threads/thread-settings-modal.react.js
457–463 ↗(On Diff #11650)

Even though there aren't any dependencies, doesn't using React.useCallback provide referential equality when passed to the inner ThreadSettingsModal class component?

atul updated this revision to Diff 11752.Apr 21 2022, 11:19 AM

rebase before landing

Harbormaster completed remote builds in B8423: Diff 11752.Apr 21 2022, 11:25 AM
Closed by commit rCOMMd287cfc2fe2f: [web] Move `onChangeAccountPassword` up from `ThreadSettingsModal` to… (authored by atul). · Explain WhyApr 21 2022, 11:25 AM
This revision was automatically updated to reflect the committed changes.
atul added a commit: rCOMMd287cfc2fe2f: [web] Move `onChangeAccountPassword` up from `ThreadSettingsModal` to….
tomek added inline comments.Apr 25 2022, 2:09 AM
web/modals/threads/thread-settings-modal.react.js
457–463 ↗(On Diff #11650)

When a function is defined in global scope, it never changes and is always equal to itself. It's true that callback provide the equality, but it is only needed when a function is redefined, e.g. in render function.

Revision Contents
Changeset List

PathSize
web/
modals/
threads/
17 lines

Diff 11578

View Options

web/modals/threads/thread-settings-modal.react.js

Show First 20 Lines • Show All 555 Lines • ▼ Show 20 Lines if (!storedSecretKey.hasValue()) {
storedSecretKey = crypto::Tools::generateRandomString(64); storedSecretKey = crypto::Tools::generateRandomString(64);
CommSecureStore::set(secureStoreAccountDataKey, storedSecretKey.value()); CommSecureStore::set(secureStoreAccountDataKey, storedSecretKey.value());
} }
return storedSecretKey.value(); return storedSecretKey.value();
} }
void CommCoreModule::persistCryptoModules( void CommCoreModule::persistCryptoModules(
bool persistContentModule, bool persistContentModule,
bool persistNotifsModule) { std::optional<std::pair<std::shared_ptr<crypto::CryptoModule>, std::string>>
maybeUpdatedNotifsCryptoModule) {
std::string storedSecretKey = getAccountDataKey(secureStoreAccountDataKey); std::string storedSecretKey = getAccountDataKey(secureStoreAccountDataKey);
if (!persistContentModule && !persistNotifsModule) { if (!persistContentModule && !maybeUpdatedNotifsCryptoModule.has_value()) {
return; return;
} }
crypto::Persist newContentPersist; crypto::Persist newContentPersist;
if (persistContentModule) { if (persistContentModule) {
newContentPersist = this->contentCryptoModule->storeAsB64(storedSecretKey); newContentPersist = this->contentCryptoModule->storeAsB64(storedSecretKey);
} }
crypto::Persist newNotifsPersist;
if (persistNotifsModule) {
newNotifsPersist = this->notifsCryptoModule->storeAsB64(storedSecretKey);
}
std::promise<void> persistencePromise; std::promise<void> persistencePromise;
std::future<void> persistenceFuture = persistencePromise.get_future(); std::future<void> persistenceFuture = persistencePromise.get_future();
GlobalDBSingleton::instance.scheduleOrRunCancellable( GlobalDBSingleton::instance.scheduleOrRunCancellable(
[=, &persistencePromise]() { [=, &persistencePromise]() {
try { try {
DatabaseManager::getQueryExecutor().beginTransaction(); DatabaseManager::getQueryExecutor().beginTransaction();
if (persistContentModule) { if (persistContentModule) {
DatabaseManager::getQueryExecutor().storeOlmPersistData( DatabaseManager::getQueryExecutor().storeOlmPersistData(
DatabaseManager::getQueryExecutor().getContentAccountID(), DatabaseManager::getQueryExecutor().getContentAccountID(),
newContentPersist); newContentPersist);
} }
if (persistNotifsModule) { if (maybeUpdatedNotifsCryptoModule.has_value()) {
DatabaseManager::getQueryExecutor().storeOlmPersistData( NotificationsCryptoModule::persistNotificationsAccount(
DatabaseManager::getQueryExecutor().getNotifsAccountID(), maybeUpdatedNotifsCryptoModule.value().first,
newNotifsPersist); maybeUpdatedNotifsCryptoModule.value().second);
} }
DatabaseManager::getQueryExecutor().commitTransaction(); DatabaseManager::getQueryExecutor().commitTransaction();
persistencePromise.set_value(); persistencePromise.set_value();
} catch (std::system_error &e) { } catch (std::system_error &e) {
DatabaseManager::getQueryExecutor().rollbackTransaction(); DatabaseManager::getQueryExecutor().rollbackTransaction();
persistencePromise.set_exception(std::make_exception_ptr(e)); persistencePromise.set_exception(std::make_exception_ptr(e));
} }
}); });
Show All 35 Lines return createPromiseAsJSIValue(
contentPersist.sessions.insert(std::make_pair( contentPersist.sessions.insert(std::make_pair(
sessionsDataItem.target_device_id, sessionPersist)); sessionsDataItem.target_device_id, sessionPersist));
} }
} }
std::optional<std::string> notifsAccountData = std::optional<std::string> notifsAccountData =
DatabaseManager::getQueryExecutor().getOlmPersistAccountData( DatabaseManager::getQueryExecutor().getOlmPersistAccountData(
DatabaseManager::getQueryExecutor().getNotifsAccountID()); DatabaseManager::getQueryExecutor().getNotifsAccountID());
if (notifsAccountData.has_value()) { if (notifsAccountData.has_value()) {
notifsPersist.account = crypto::OlmBuffer( notifsPersist.account = crypto::OlmBuffer(
notifsAccountData->begin(), notifsAccountData->end()); notifsAccountData->begin(), notifsAccountData->end());
} }
} catch (std::system_error &e) { } catch (std::system_error &e) {
error = e.what(); error = e.what();
} }
this->cryptoThread->scheduleTask([=]() { this->cryptoThread->scheduleTask([=]() {
std::string error; std::string error;
this->contentCryptoModule.reset(new crypto::CryptoModule( this->contentCryptoModule.reset(new crypto::CryptoModule(
this->publicCryptoAccountID, this->publicCryptoAccountID,
storedSecretKey.value(), storedSecretKey.value(),
contentPersist)); contentPersist));
this->notifsCryptoModule.reset(new crypto::CryptoModule( std::optional<
std::pair<std::shared_ptr<crypto::CryptoModule>, std::string>>
maybeNotifsCryptoAccountToPersist;
if (!NotificationsCryptoModule::
isNotificationsAccountInitialized()) {
maybeNotifsCryptoAccountToPersist = {
std::make_shared<crypto::CryptoModule>(
this->notifsCryptoAccountID, this->notifsCryptoAccountID,
storedSecretKey.value(), storedSecretKey.value(),
notifsPersist)); notifsPersist),
storedSecretKey.value()};
}
try { try {
this->persistCryptoModules( this->persistCryptoModules(
contentPersist.isEmpty(), notifsPersist.isEmpty()); contentPersist.isEmpty(), maybeNotifsCryptoAccountToPersist);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
} }
this->jsInvoker_->invokeAsync([=]() { this->jsInvoker_->invokeAsync([=]() {
if (error.size()) { if (error.size()) {
promise->reject(error); promise->reject(error);
return; return;
Show All 12 Lines
jsi::Value CommCoreModule::getUserPublicKey(jsi::Runtime &rt) { jsi::Value CommCoreModule::getUserPublicKey(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [=, &innerRt]() { taskType job = [=, &innerRt]() {
std::string error; std::string error;
std::string primaryKeysResult; std::string primaryKeysResult;
std::string notificationsKeysResult; std::string notificationsKeysResult;
if (this->contentCryptoModule == nullptr || if (this->contentCryptoModule == nullptr ||
this->notifsCryptoModule == nullptr) { !NotificationsCryptoModule::isNotificationsAccountInitialized()) {
error = "user has not been initialized"; error = "user has not been initialized";
} else { } else {
primaryKeysResult = this->contentCryptoModule->getIdentityKeys(); primaryKeysResult = this->contentCryptoModule->getIdentityKeys();
notificationsKeysResult = notificationsKeysResult =
this->notifsCryptoModule->getIdentityKeys(); NotificationsCryptoModule::getIdentityKeys();
} }
std::string notificationsCurve25519Cpp, notificationsEd25519Cpp, std::string notificationsCurve25519Cpp, notificationsEd25519Cpp,
blobPayloadCpp, signatureCpp, primaryCurve25519Cpp, blobPayloadCpp, signatureCpp, primaryCurve25519Cpp,
primaryEd25519Cpp; primaryEd25519Cpp;
if (!error.size()) { if (!error.size()) {
folly::dynamic parsedPrimary; folly::dynamic parsedPrimary;
▲ Show 20 Lines • Show All 155 Lines • ▼ Show 20 Lines
CommCoreModule::getOneTimeKeys(jsi::Runtime &rt, double oneTimeKeysAmount) { CommCoreModule::getOneTimeKeys(jsi::Runtime &rt, double oneTimeKeysAmount) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [=, &innerRt]() { taskType job = [=, &innerRt]() {
std::string error; std::string error;
std::string contentResult; std::string contentResult;
std::string notifResult; std::string notifResult;
if (this->contentCryptoModule == nullptr || if (this->contentCryptoModule == nullptr ||
this->notifsCryptoModule == nullptr) { !NotificationsCryptoModule::isNotificationsAccountInitialized()) {
this->jsInvoker_->invokeAsync([=, &innerRt]() { this->jsInvoker_->invokeAsync([=, &innerRt]() {
promise->reject("user has not been initialized"); promise->reject("user has not been initialized");
}); });
return; return;
} }
try { try {
contentResult = contentResult =
this->contentCryptoModule->getOneTimeKeysForPublishing( this->contentCryptoModule->getOneTimeKeysForPublishing(
oneTimeKeysAmount); oneTimeKeysAmount);
notifResult = this->notifsCryptoModule->getOneTimeKeysForPublishing( std::pair<std::shared_ptr<crypto::CryptoModule>, std::string>
oneTimeKeysAmount); notifsCryptoModuleWithPicklingKey =
this->persistCryptoModules(true, true); NotificationsCryptoModule::fetchNotificationsAccount()
.value();
notifResult = notifsCryptoModuleWithPicklingKey.first
->getOneTimeKeysForPublishing(oneTimeKeysAmount);
this->persistCryptoModules(true, notifsCryptoModuleWithPicklingKey);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
} }
this->jsInvoker_->invokeAsync([=, &innerRt]() { this->jsInvoker_->invokeAsync([=, &innerRt]() {
if (error.size()) { if (error.size()) {
promise->reject(error); promise->reject(error);
return; return;
} }
Show All 16 Linesjsi::Value CommCoreModule::validateAndUploadPrekeys(
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [=, &innerRt]() { taskType job = [=, &innerRt]() {
std::string error; std::string error;
std::optional<std::string> maybeContentPrekeyToUpload; std::optional<std::string> maybeContentPrekeyToUpload;
std::optional<std::string> maybeNotifsPrekeyToUpload; std::optional<std::string> maybeNotifsPrekeyToUpload;
if (this->contentCryptoModule == nullptr || if (this->contentCryptoModule == nullptr ||
this->notifsCryptoModule == nullptr) { !NotificationsCryptoModule::isNotificationsAccountInitialized()) {
this->jsInvoker_->invokeAsync([=, &innerRt]() { this->jsInvoker_->invokeAsync([=, &innerRt]() {
promise->reject("user has not been initialized"); promise->reject("user has not been initialized");
}); });
return; return;
} }
std::optional<
std::pair<std::shared_ptr<crypto::CryptoModule>, std::string>>
notifsCryptoModuleWithPicklingKey;
try { try {
notifsCryptoModuleWithPicklingKey =
NotificationsCryptoModule::fetchNotificationsAccount();
maybeContentPrekeyToUpload = maybeContentPrekeyToUpload =
this->contentCryptoModule->validatePrekey(); this->contentCryptoModule->validatePrekey();
maybeNotifsPrekeyToUpload = maybeNotifsPrekeyToUpload =
this->notifsCryptoModule->validatePrekey(); notifsCryptoModuleWithPicklingKey.value()
this->persistCryptoModules(true, true); .first->validatePrekey();
this->persistCryptoModules(true, notifsCryptoModuleWithPicklingKey);
if (!maybeContentPrekeyToUpload.has_value()) { if (!maybeContentPrekeyToUpload.has_value()) {
maybeContentPrekeyToUpload = maybeContentPrekeyToUpload =
this->contentCryptoModule->getUnpublishedPrekey(); this->contentCryptoModule->getUnpublishedPrekey();
} }
if (!maybeNotifsPrekeyToUpload.has_value()) { if (!maybeNotifsPrekeyToUpload.has_value()) {
maybeNotifsPrekeyToUpload = maybeNotifsPrekeyToUpload =
this->notifsCryptoModule->getUnpublishedPrekey(); notifsCryptoModuleWithPicklingKey.value()
.first->getUnpublishedPrekey();
} }
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
} }
if (error.size()) { if (error.size()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[=, &innerRt]() { promise->reject(error); }); [=, &innerRt]() { promise->reject(error); });
Show All 13 Lines return createPromiseAsJSIValue(
} else { } else {
contentPrekeyToUpload = this->contentCryptoModule->getPrekey(); contentPrekeyToUpload = this->contentCryptoModule->getPrekey();
} }
std::string notifsPrekeyToUpload; std::string notifsPrekeyToUpload;
if (maybeNotifsPrekeyToUpload.has_value()) { if (maybeNotifsPrekeyToUpload.has_value()) {
notifsPrekeyToUpload = maybeNotifsPrekeyToUpload.value(); notifsPrekeyToUpload = maybeNotifsPrekeyToUpload.value();
} else { } else {
notifsPrekeyToUpload = this->notifsCryptoModule->getPrekey(); notifsPrekeyToUpload =
notifsCryptoModuleWithPicklingKey.value().first->getPrekey();
} }
std::string prekeyUploadError; std::string prekeyUploadError;
try { try {
std::string contentPrekeySignature = std::string contentPrekeySignature =
this->contentCryptoModule->getPrekeySignature(); this->contentCryptoModule->getPrekeySignature();
std::string notifsPrekeySignature = std::string notifsPrekeySignature =
this->notifsCryptoModule->getPrekeySignature(); notifsCryptoModuleWithPicklingKey.value()
.first->getPrekeySignature();
try { try {
std::promise<folly::dynamic> prekeyPromise; std::promise<folly::dynamic> prekeyPromise;
std::future<folly::dynamic> prekeyFuture = std::future<folly::dynamic> prekeyFuture =
prekeyPromise.get_future(); prekeyPromise.get_future();
RustPromiseManager::CPPPromiseInfo promiseInfo = { RustPromiseManager::CPPPromiseInfo promiseInfo = {
std::move(prekeyPromise)}; std::move(prekeyPromise)};
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
Show All 16 Lines return createPromiseAsJSIValue(
currentID); currentID);
prekeyFuture.get(); prekeyFuture.get();
} catch (const std::exception &e) { } catch (const std::exception &e) {
prekeyUploadError = e.what(); prekeyUploadError = e.what();
} }
if (!prekeyUploadError.size()) { if (!prekeyUploadError.size()) {
this->contentCryptoModule->markPrekeyAsPublished(); this->contentCryptoModule->markPrekeyAsPublished();
this->notifsCryptoModule->markPrekeyAsPublished(); notifsCryptoModuleWithPicklingKey.value()
this->persistCryptoModules(true, true); .first->markPrekeyAsPublished();
this->persistCryptoModules(
true, notifsCryptoModuleWithPicklingKey);
} }
} catch (std::exception &e) { } catch (std::exception &e) {
error = e.what(); error = e.what();
} }
this->jsInvoker_->invokeAsync([=]() { this->jsInvoker_->invokeAsync([=]() {
if (error.size()) { if (error.size()) {
promise->reject(error); promise->reject(error);
Show All 16 Lines return createPromiseAsJSIValue(
taskType job = [=, &innerRt]() { taskType job = [=, &innerRt]() {
std::string error; std::string error;
std::string contentPrekey, notifPrekey, contentPrekeySignature, std::string contentPrekey, notifPrekey, contentPrekeySignature,
notifPrekeySignature; notifPrekeySignature;
std::optional<std::string> contentPrekeyBlob; std::optional<std::string> contentPrekeyBlob;
std::optional<std::string> notifPrekeyBlob; std::optional<std::string> notifPrekeyBlob;
if (this->contentCryptoModule == nullptr || if (this->contentCryptoModule == nullptr ||
this->notifsCryptoModule == nullptr) { !NotificationsCryptoModule::isNotificationsAccountInitialized()) {
this->jsInvoker_->invokeAsync([=, &innerRt]() { this->jsInvoker_->invokeAsync([=, &innerRt]() {
promise->reject("user has not been initialized"); promise->reject("user has not been initialized");
}); });
return; return;
} }
std::optional<
std::pair<std::shared_ptr<crypto::CryptoModule>, std::string>>
notifsCryptoModuleWithPicklingKey;
try { try {
notifsCryptoModuleWithPicklingKey =
NotificationsCryptoModule::fetchNotificationsAccount();
contentPrekeyBlob = this->contentCryptoModule->validatePrekey(); contentPrekeyBlob = this->contentCryptoModule->validatePrekey();
if (!contentPrekeyBlob) { if (!contentPrekeyBlob) {
contentPrekeyBlob = contentPrekeyBlob =
this->contentCryptoModule->getUnpublishedPrekey(); this->contentCryptoModule->getUnpublishedPrekey();
} }
if (!contentPrekeyBlob) { if (!contentPrekeyBlob) {
contentPrekeyBlob = this->contentCryptoModule->getPrekey(); contentPrekeyBlob = this->contentCryptoModule->getPrekey();
} }
notifPrekeyBlob = this->notifsCryptoModule->validatePrekey(); notifPrekeyBlob = notifsCryptoModuleWithPicklingKey.value()
.first->validatePrekey();
if (!notifPrekeyBlob) { if (!notifPrekeyBlob) {
notifPrekeyBlob = notifPrekeyBlob = notifsCryptoModuleWithPicklingKey.value()
this->notifsCryptoModule->getUnpublishedPrekey(); .first->getUnpublishedPrekey();
} }
if (!notifPrekeyBlob) { if (!notifPrekeyBlob) {
notifPrekeyBlob = this->notifsCryptoModule->getPrekey(); notifPrekeyBlob =
notifsCryptoModuleWithPicklingKey.value().first->getPrekey();
} }
this->persistCryptoModules(true, true); this->persistCryptoModules(true, notifsCryptoModuleWithPicklingKey);
contentPrekeySignature = contentPrekeySignature =
this->contentCryptoModule->getPrekeySignature(); this->contentCryptoModule->getPrekeySignature();
notifPrekeySignature = notifPrekeySignature = notifsCryptoModuleWithPicklingKey.value()
this->notifsCryptoModule->getPrekeySignature(); .first->getPrekeySignature();
contentPrekey = parseOLMPrekey(contentPrekeyBlob.value()); contentPrekey = parseOLMPrekey(contentPrekeyBlob.value());
notifPrekey = parseOLMPrekey(notifPrekeyBlob.value()); notifPrekey = parseOLMPrekey(notifPrekeyBlob.value());
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
} }
this->jsInvoker_->invokeAsync([=, &innerRt]() { this->jsInvoker_->invokeAsync([=, &innerRt]() {
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines if (oneTimeKey) {
oneTimeKeyCpp = oneTimeKey->utf8(rt); oneTimeKeyCpp = oneTimeKey->utf8(rt);
} }
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [=, &innerRt]() { taskType job = [=, &innerRt]() {
std::string error; std::string error;
crypto::EncryptedData result; crypto::EncryptedData result;
std::optional<
std::pair<std::shared_ptr<crypto::CryptoModule>, std::string>>
notifsCryptoModuleWithPicklingKey;
try { try {
notifsCryptoModuleWithPicklingKey =
NotificationsCryptoModule::fetchNotificationsAccount();
std::optional<crypto::OlmBuffer> oneTimeKeyBuffer; std::optional<crypto::OlmBuffer> oneTimeKeyBuffer;
if (oneTimeKeyCpp) { if (oneTimeKeyCpp) {
oneTimeKeyBuffer = crypto::OlmBuffer( oneTimeKeyBuffer = crypto::OlmBuffer(
oneTimeKeyCpp->begin(), oneTimeKeyCpp->end()); oneTimeKeyCpp->begin(), oneTimeKeyCpp->end());
} }
this->notifsCryptoModule->initializeOutboundForSendingSession( notifsCryptoModuleWithPicklingKey.value()
.first->initializeOutboundForSendingSession(
keyserverIDCpp, keyserverIDCpp,
std::vector<uint8_t>( std::vector<uint8_t>(
identityKeysCpp.begin(), identityKeysCpp.end()), identityKeysCpp.begin(), identityKeysCpp.end()),
std::vector<uint8_t>(prekeyCpp.begin(), prekeyCpp.end()), std::vector<uint8_t>(prekeyCpp.begin(), prekeyCpp.end()),
std::vector<uint8_t>( std::vector<uint8_t>(
prekeySignatureCpp.begin(), prekeySignatureCpp.end()), prekeySignatureCpp.begin(), prekeySignatureCpp.end()),
oneTimeKeyBuffer); oneTimeKeyBuffer);
result = this->notifsCryptoModule->encrypt( result = notifsCryptoModuleWithPicklingKey.value().first->encrypt(
keyserverIDCpp, keyserverIDCpp,
NotificationsCryptoModule::initialEncryptedMessageContent); NotificationsCryptoModule::initialEncryptedMessageContent);
std::shared_ptr<crypto::Session> keyserverNotificationsSession = std::shared_ptr<crypto::Session> keyserverNotificationsSession =
this->notifsCryptoModule->getSessionByDeviceId(keyserverIDCpp); notifsCryptoModuleWithPicklingKey.value()
.first->getSessionByDeviceId(keyserverIDCpp);
NotificationsCryptoModule::persistNotificationsSession( NotificationsCryptoModule::persistNotificationsSession(
keyserverIDCpp, keyserverNotificationsSession); keyserverIDCpp, keyserverNotificationsSession);
// Session is removed from the account since it is persisted // Session is removed from the account since it is persisted
// at different location that the account after serialization // at different location that the account after serialization
this->notifsCryptoModule->removeSessionByDeviceId(keyserverIDCpp); notifsCryptoModuleWithPicklingKey.value()
this->persistCryptoModules(false, true); .first->removeSessionByDeviceId(keyserverIDCpp);
this->persistCryptoModules(
false, notifsCryptoModuleWithPicklingKey);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
} }
this->jsInvoker_->invokeAsync([=, &innerRt]() { this->jsInvoker_->invokeAsync([=, &innerRt]() {
if (error.size()) { if (error.size()) {
promise->reject(error); promise->reject(error);
return; return;
} }
▲ Show 20 Lines • Show All 225 Lines • ▼ Show 20 Lines return createPromiseAsJSIValue(
std::vector<uint8_t>( std::vector<uint8_t>(
prekeySignatureCpp.begin(), prekeySignatureCpp.end()), prekeySignatureCpp.begin(), prekeySignatureCpp.end()),
oneTimeKeyBuffer); oneTimeKeyBuffer);
const std::string initMessage = "{\"type\": \"init\"}"; const std::string initMessage = "{\"type\": \"init\"}";
initialEncryptedData = initialEncryptedData =
contentCryptoModule->encrypt(deviceIDCpp, initMessage); contentCryptoModule->encrypt(deviceIDCpp, initMessage);
this->persistCryptoModules(true, false); this->persistCryptoModules(true, std::nullopt);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
} }
this->jsInvoker_->invokeAsync([=, &innerRt]() { this->jsInvoker_->invokeAsync([=, &innerRt]() {
if (error.size()) { if (error.size()) {
promise->reject(error); promise->reject(error);
return; return;
} }
Show All 40 Lines return createPromiseAsJSIValue(
static_cast<int>(sessionVersion), static_cast<int>(sessionVersion),
overwrite); overwrite);
crypto::EncryptedData encryptedData{ crypto::EncryptedData encryptedData{
std::vector<uint8_t>( std::vector<uint8_t>(
encryptedMessageCpp.begin(), encryptedMessageCpp.end()), encryptedMessageCpp.begin(), encryptedMessageCpp.end()),
messageType}; messageType};
decryptedMessage = decryptedMessage =
this->contentCryptoModule->decrypt(deviceIDCpp, encryptedData); this->contentCryptoModule->decrypt(deviceIDCpp, encryptedData);
this->persistCryptoModules(true, false); this->persistCryptoModules(true, std::nullopt);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
} }
this->jsInvoker_->invokeAsync([=, &innerRt]() { this->jsInvoker_->invokeAsync([=, &innerRt]() {
if (error.size()) { if (error.size()) {
promise->reject(error); promise->reject(error);
return; return;
} }
Show All 11 Linesjsi::Value CommCoreModule::isContentSessionInitialized(
auto deviceIDCpp{deviceID.utf8(rt)}; auto deviceIDCpp{deviceID.utf8(rt)};
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [=, &innerRt]() { taskType job = [=, &innerRt]() {
std::string error; std::string error;
bool result; bool result;
if (this->contentCryptoModule == nullptr || if (this->contentCryptoModule == nullptr ||
this->notifsCryptoModule == nullptr) { !NotificationsCryptoModule::isNotificationsAccountInitialized()) {
this->jsInvoker_->invokeAsync([=, &innerRt]() { this->jsInvoker_->invokeAsync([=, &innerRt]() {
promise->reject("user has not been initialized"); promise->reject("user has not been initialized");
}); });
return; return;
} }
try { try {
result = this->contentCryptoModule->hasSessionFor(deviceIDCpp); result = this->contentCryptoModule->hasSessionFor(deviceIDCpp);
Show All 30 Lines if (oneTimeKey) {
oneTimeKeyCpp = oneTimeKey->utf8(rt); oneTimeKeyCpp = oneTimeKey->utf8(rt);
} }
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [=, &innerRt]() { taskType job = [=, &innerRt]() {
std::string error; std::string error;
crypto::EncryptedData result; crypto::EncryptedData result;
std::optional<
std::pair<std::shared_ptr<crypto::CryptoModule>, std::string>>
notifsCryptoModuleWithPicklingKey;
try { try {
notifsCryptoModuleWithPicklingKey =
NotificationsCryptoModule::fetchNotificationsAccount();
std::optional<crypto::OlmBuffer> oneTimeKeyBuffer; std::optional<crypto::OlmBuffer> oneTimeKeyBuffer;
if (oneTimeKeyCpp) { if (oneTimeKeyCpp) {
oneTimeKeyBuffer = crypto::OlmBuffer( oneTimeKeyBuffer = crypto::OlmBuffer(
oneTimeKeyCpp->begin(), oneTimeKeyCpp->end()); oneTimeKeyCpp->begin(), oneTimeKeyCpp->end());
} }
this->notifsCryptoModule->initializeOutboundForSendingSession( notifsCryptoModuleWithPicklingKey.value()
.first->initializeOutboundForSendingSession(
deviceIDCpp, deviceIDCpp,
std::vector<uint8_t>( std::vector<uint8_t>(
identityKeysCpp.begin(), identityKeysCpp.end()), identityKeysCpp.begin(), identityKeysCpp.end()),
std::vector<uint8_t>(prekeyCpp.begin(), prekeyCpp.end()), std::vector<uint8_t>(prekeyCpp.begin(), prekeyCpp.end()),
std::vector<uint8_t>( std::vector<uint8_t>(
prekeySignatureCpp.begin(), prekeySignatureCpp.end()), prekeySignatureCpp.begin(), prekeySignatureCpp.end()),
oneTimeKeyBuffer); oneTimeKeyBuffer);
result = this->notifsCryptoModule->encrypt( result = notifsCryptoModuleWithPicklingKey.value().first->encrypt(
deviceIDCpp, deviceIDCpp,
NotificationsCryptoModule::initialEncryptedMessageContent); NotificationsCryptoModule::initialEncryptedMessageContent);
std::shared_ptr<crypto::Session> peerNotificationsSession = std::shared_ptr<crypto::Session> peerNotificationsSession =
this->notifsCryptoModule->getSessionByDeviceId(deviceIDCpp); notifsCryptoModuleWithPicklingKey.value()
.first->getSessionByDeviceId(deviceIDCpp);
NotificationsCryptoModule::persistDeviceNotificationsSession( NotificationsCryptoModule::persistDeviceNotificationsSession(
deviceIDCpp, peerNotificationsSession); deviceIDCpp, peerNotificationsSession);
// Session is removed from the account since it is persisted // Session is removed from the account since it is persisted
// at different location that the account after serialization // at different location that the account after serialization
this->notifsCryptoModule->removeSessionByDeviceId(deviceIDCpp); notifsCryptoModuleWithPicklingKey.value()
this->persistCryptoModules(false, true); .first->removeSessionByDeviceId(deviceIDCpp);
this->persistCryptoModules(
false, notifsCryptoModuleWithPicklingKey);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
} }
this->jsInvoker_->invokeAsync([=, &innerRt]() { this->jsInvoker_->invokeAsync([=, &innerRt]() {
if (error.size()) { if (error.size()) {
promise->reject(error); promise->reject(error);
return; return;
} }
Show All 14 Linesjsi::Value CommCoreModule::encrypt(
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [=, &innerRt]() { taskType job = [=, &innerRt]() {
std::string error; std::string error;
crypto::EncryptedData encryptedMessage; crypto::EncryptedData encryptedMessage;
try { try {
encryptedMessage = encryptedMessage =
contentCryptoModule->encrypt(deviceIDCpp, messageCpp); contentCryptoModule->encrypt(deviceIDCpp, messageCpp);
this->persistCryptoModules(true, false); this->persistCryptoModules(true, std::nullopt);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
} }
this->jsInvoker_->invokeAsync([=, &innerRt]() { this->jsInvoker_->invokeAsync([=, &innerRt]() {
if (error.size()) { if (error.size()) {
promise->reject(error); promise->reject(error);
return; return;
} }
▲ Show 20 Lines • Show All 125 Lines • ▼ Show 20 Lines return createPromiseAsJSIValue(
std::string error; std::string error;
std::string decryptedMessage; std::string decryptedMessage;
try { try {
crypto::EncryptedData encryptedData{ crypto::EncryptedData encryptedData{
std::vector<uint8_t>(message.begin(), message.end()), std::vector<uint8_t>(message.begin(), message.end()),
messageType}; messageType};
decryptedMessage = decryptedMessage =
this->contentCryptoModule->decrypt(deviceIDCpp, encryptedData); this->contentCryptoModule->decrypt(deviceIDCpp, encryptedData);
this->persistCryptoModules(true, false); this->persistCryptoModules(true, std::nullopt);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
} }
this->jsInvoker_->invokeAsync([=, &innerRt]() { this->jsInvoker_->invokeAsync([=, &innerRt]() {
if (error.size()) { if (error.size()) {
promise->reject(error); promise->reject(error);
return; return;
} }
▲ Show 20 Lines • Show All 1,030 Lines • ▼ Show 20 Lines
jsi::Value CommCoreModule::markPrekeysAsPublished(jsi::Runtime &rt) { jsi::Value CommCoreModule::markPrekeysAsPublished(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [=, &innerRt]() { taskType job = [=, &innerRt]() {
std::string error; std::string error;
if (this->contentCryptoModule == nullptr || if (this->contentCryptoModule == nullptr ||
this->notifsCryptoModule == nullptr) { !NotificationsCryptoModule::isNotificationsAccountInitialized()) {
this->jsInvoker_->invokeAsync([=, &innerRt]() { this->jsInvoker_->invokeAsync([=, &innerRt]() {
promise->reject("user has not been initialized"); promise->reject("user has not been initialized");
}); });
return; return;
} }
std::optional<
std::pair<std::shared_ptr<crypto::CryptoModule>, std::string>>
notifsCryptoModuleWithPicklingKey;
try { try {
notifsCryptoModuleWithPicklingKey =
NotificationsCryptoModule::fetchNotificationsAccount();
this->contentCryptoModule->markPrekeyAsPublished(); this->contentCryptoModule->markPrekeyAsPublished();
this->notifsCryptoModule->markPrekeyAsPublished(); notifsCryptoModuleWithPicklingKey.value()
this->persistCryptoModules(true, true); .first->markPrekeyAsPublished();
this->persistCryptoModules(true, notifsCryptoModuleWithPicklingKey);
} catch (std::exception &e) { } catch (std::exception &e) {
error = e.what(); error = e.what();
} }
this->jsInvoker_->invokeAsync([=]() { this->jsInvoker_->invokeAsync([=]() {
if (error.size()) { if (error.size()) {
promise->reject(error); promise->reject(error);
return; return;
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines