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

[keyserver] extend redis cache to store user identities returned by findUserIdentitiesClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 44987

keyserver/src/utils/redis-cache.js

[keyserver] extend redis cache to store user identities returned by findUserIdentities
ClosedPublic
Actions

Revision Contents
Changeset List