Paths

Table of Contentst

-
services/terraform/
-
terraform/
-
modules/keyserver_node_service/
-
keyserver_node_service/
-
main.tf
-
outputs.tf
-
variables.tf
-
self-host/
-
outputs.tf
-
variables.tf
-
webapp.tf

[terraform] Create module for webapp/landing and convert webapp to module
ClosedPublic
Actions

Authored by will on Jul 28 2024, 5:52 PM.

Details

Reviewers

varun
bartek

Commits

rCOMM373d6c75fa93: [terraform] Create module for webapp/landing and convert webapp to module

Summary

This implements a module for the webapp and replaces the self-host webapp to use it

Depends on D12927

Test Plan

terraform apply. Webapp was accessible as prior to module implementation

Diff Detail

Repository

rCOMM Comm

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

will created this revision.Jul 28 2024, 5:52 PM

Herald added subscribers: tomek, ashoat. · View Herald TranscriptJul 28 2024, 5:52 PM

Harbormaster completed remote builds in B30730: Diff 42856.Jul 28 2024, 6:08 PM

will requested review of this revision.Jul 28 2024, 6:08 PM

Nice! The code structure looks neat!
In the future we can do a similar thing to our ECS services - modules can help avoid lots of duplication.

The only thing I have mixed feelings is the name node_service - I think of it as a Node.js service (in fact it is) 😅 Could it be sth like keyserver_node_service? IDK

P.S. Have you tried terraform state mv or just killed old resources and restarted? :D Just curious, I'd do the latter

This revision is now accepted and ready to land.Jul 28 2024, 11:55 PM

will added a child revision: D12927: [keyserver] Do not verify identity logged for webapp and landing.Jul 29 2024, 8:39 PM

In D12906#365084, @bartek wrote:

Nice! The code structure looks neat!
In the future we can do a similar thing to our ECS services - modules can help avoid lots of duplication.

The only thing I have mixed feelings is the name node_service - I think of it as a Node.js service (in fact it is) 😅 Could it be sth like keyserver_node_service? IDK

P.S. Have you tried terraform state mv or just killed old resources and restarted? :D Just curious, I'd do the latter

I just killed the old resources and restarted. In this specific scenario, I think we're fine as we plan on moving landing and webapp to comm services instead Ashoat's self hosted setup.

I think a rename makes sense here, it's just that I wanted to separate the concept of a webapp and landing node from a keyserver node although they technically all run off the keyserver. I'll change it to keyserver_node_service for now

will removed a child revision: D12927: [keyserver] Do not verify identity logged for webapp and landing.Aug 5 2024, 11:54 AM

review feedback

will edited the summary of this revision. (Show Details)Aug 5 2024, 11:56 AM

will added a parent revision: D12927: [keyserver] Do not verify identity logged for webapp and landing.

will added a child revision: D12928: [keyserver] Run webapp through comm services cluster.Aug 5 2024, 11:58 AM

Harbormaster failed remote builds in B30941: Diff 43156!Aug 5 2024, 12:19 PM

rebase before landing

Harbormaster completed remote builds in B30967: Diff 43196.Aug 6 2024, 6:56 PM

Closed by commit rCOMM373d6c75fa93: [terraform] Create module for webapp/landing and convert webapp to module (authored by will). · Explain WhyAug 6 2024, 7:43 PM

This revision was automatically updated to reflect the committed changes.

will added a commit: rCOMM373d6c75fa93: [terraform] Create module for webapp/landing and convert webapp to module.

Revision Contents
Changeset List

Path

Size

services/

terraform/

modules/

keyserver_node_service/

main.tf

199 lines

outputs.tf

3 lines

variables.tf

85 lines

self-host/

outputs.tf

4 lines

variables.tf

19 lines

webapp.tf

187 lines

Diff 43196

View Options

services/terraform/modules/keyserver_node_service/main.tf

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 Lines	jsi::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 Lines	jsi::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 Lines	jsi::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

View Options

services/terraform/modules/keyserver_node_service/outputs.tf

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 Lines	jsi::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 Lines	jsi::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 Lines	jsi::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

View Options

services/terraform/modules/keyserver_node_service/variables.tf

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 Lines	jsi::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 Lines	jsi::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 Lines	jsi::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

View Options

services/terraform/self-host/outputs.tf

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 Lines	jsi::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 Lines	jsi::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 Lines	jsi::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

View Options

services/terraform/self-host/variables.tf

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 Lines	jsi::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 Lines	jsi::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 Lines	jsi::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

View Options

services/terraform/self-host/webapp.tf

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 Lines	jsi::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 Lines	jsi::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 Lines	jsi::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

[terraform] Create module for webapp/landing and convert webapp to moduleClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 43196

services/terraform/modules/keyserver_node_service/main.tf

services/terraform/modules/keyserver_node_service/outputs.tf

services/terraform/modules/keyserver_node_service/variables.tf

services/terraform/self-host/outputs.tf

services/terraform/self-host/variables.tf

services/terraform/self-host/webapp.tf

[terraform] Create module for webapp/landing and convert webapp to module
ClosedPublic
Actions

Revision Contents
Changeset List