Page MenuHomePhabricator
Differential D3770

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

Authored by atul on Apr 18 2022, 3:41 PM.
Tags
None
Referenced Files
F5353136: D3770.diff
Wed, Apr 9, 9:48 AM
Unknown Object (File)
Tue, Apr 8, 6:16 PM
Unknown Object (File)
Tue, Apr 8, 6:14 PM
Unknown Object (File)
Tue, Apr 8, 8:51 AM
Unknown Object (File)
Tue, Apr 8, 7:47 AM
Unknown Object (File)
Tue, Apr 8, 7:01 AM
Unknown Object (File)
Tue, Apr 8, 6:48 AM
Unknown Object (File)
Thu, Apr 3, 6:41 PM
View All Files
Subscribers
• abosh
• adrian
ashoat
• benschac
• karol

Details

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

Move hasPermissionForTab up from ThreadSettingsModal to ConnectedThreadSettingsModal.

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

Depends on D3769

Test Plan
  1. Open ThreadSettingsModal for a few threads
  2. Ensure that the expected tabs are visible based on permission

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:41 PM
Herald added subscribers: • abosh, • benschac, • karol and 2 others. · View Herald TranscriptApr 18 2022, 3:41 PM
Harbormaster completed remote builds in B8283: Diff 11579.Apr 18 2022, 3:46 PM
atul requested review of this revision.Apr 18 2022, 3:46 PM
atul updated this revision to Diff 11651.Apr 19 2022, 3:05 PM

rebase

Harbormaster completed remote builds in B8341: Diff 11651.Apr 19 2022, 3:30 PM
atul added a child revision: D3783: [web] Move `deleteThreadAction` up from `ThreadSettingsModal` to `ConnectedThreadSettingsModal`.Apr 19 2022, 4:02 PM
tomek accepted this revision.Apr 21 2022, 3:12 AM
This revision is now accepted and ready to land.Apr 21 2022, 3:12 AM
atul updated this revision to Diff 11755.Apr 21 2022, 11:30 AM

rebase before landing

Harbormaster completed remote builds in B8424: Diff 11755.Apr 21 2022, 11:35 AM
Closed by commit rCOMM99e225d4681a: [web] Move `hasPermissionForTab` up from `ThreadSettingsModal` to… (authored by atul). · Explain WhyApr 21 2022, 11:35 AM
This revision was automatically updated to reflect the committed changes.
atul added a commit: rCOMM99e225d4681a: [web] Move `hasPermissionForTab` up from `ThreadSettingsModal` to….

Revision Contents
Changeset List

PathSize
web/
modals/
threads/
50 lines

Diff 11579

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