aboutsummaryrefslogtreecommitdiff
path: root/android/olm-sdk/src/main/jni/olm_pk.cpp
diff options
context:
space:
mode:
authordec05eba <dec05eba@protonmail.com>2020-11-05 01:45:06 +0100
committerdec05eba <dec05eba@protonmail.com>2020-11-05 01:45:06 +0100
commit2a8202e74846d191a321cca1202175af9db6107d (patch)
treea6f455caf07da1186851f343a237a4c4e4484f46 /android/olm-sdk/src/main/jni/olm_pk.cpp
parent8efa0ec17d8c262f9c3fd7603e8074f74a053708 (diff)
Convert to sibs projectHEADmaster
Diffstat (limited to 'android/olm-sdk/src/main/jni/olm_pk.cpp')
-rw-r--r--android/olm-sdk/src/main/jni/olm_pk.cpp992
1 files changed, 0 insertions, 992 deletions
diff --git a/android/olm-sdk/src/main/jni/olm_pk.cpp b/android/olm-sdk/src/main/jni/olm_pk.cpp
deleted file mode 100644
index c528342..0000000
--- a/android/olm-sdk/src/main/jni/olm_pk.cpp
+++ /dev/null
@@ -1,992 +0,0 @@
-/*
- * Copyright 2018,2019 New Vector Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "olm_pk.h"
-
-#include "olm/olm.h"
-
-using namespace AndroidOlmSdk;
-
-OlmPkEncryption * initializePkEncryptionMemory()
-{
- size_t encryptionSize = olm_pk_encryption_size();
- OlmPkEncryption *encryptionPtr = (OlmPkEncryption *)malloc(encryptionSize);
-
- if (encryptionPtr)
- {
- // init encryption object
- encryptionPtr = olm_pk_encryption(encryptionPtr);
- LOGD(
- "## initializePkEncryptionMemory(): success - OLM encryption size=%lu",
- static_cast<long unsigned int>(encryptionSize)
- );
- }
- else
- {
- LOGE("## initializePkEncryptionMemory(): failure - OOM");
- }
-
- return encryptionPtr;
-}
-
-JNIEXPORT jlong OLM_PK_ENCRYPTION_FUNC_DEF(createNewPkEncryptionJni)(JNIEnv *env, jobject thiz)
-{
- const char* errorMessage = NULL;
- OlmPkEncryption *encryptionPtr = initializePkEncryptionMemory();
-
- // init encryption memory allocation
- if (!encryptionPtr)
- {
- LOGE("## createNewPkEncryptionJni(): failure - init encryption OOM");
- errorMessage = "init encryption OOM";
- }
- else
- {
- LOGD("## createNewPkEncryptionJni(): success - OLM encryption created");
- LOGD(
- "## createNewPkEncryptionJni(): encryptionPtr=%p (jlong)(intptr_t)encryptionPtr=%lld",
- encryptionPtr, (jlong)(intptr_t)encryptionPtr
- );
- }
-
- if (errorMessage)
- {
- // release the allocated data
- if (encryptionPtr)
- {
- olm_clear_pk_encryption(encryptionPtr);
- free(encryptionPtr);
- }
- env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage);
- }
-
- return (jlong)(intptr_t)encryptionPtr;
-}
-
-JNIEXPORT void OLM_PK_ENCRYPTION_FUNC_DEF(releasePkEncryptionJni)(JNIEnv *env, jobject thiz)
-{
- LOGD("## releasePkEncryptionJni(): IN");
-
- OlmPkEncryption* encryptionPtr = getPkEncryptionInstanceId(env, thiz);
-
- if (!encryptionPtr)
- {
- LOGE(" ## releasePkEncryptionJni(): failure - invalid Encryption ptr=NULL");
- }
- else
- {
- LOGD(" ## releasePkEncryptionJni(): encryptionPtr=%p", encryptionPtr);
- olm_clear_pk_encryption(encryptionPtr);
-
- LOGD(" ## releasePkEncryptionJni(): IN");
- // even if free(NULL) does not crash, logs are performed for debug
- // purpose
- free(encryptionPtr);
- LOGD(" ## releasePkEncryptionJni(): OUT");
- }
-}
-
-JNIEXPORT void OLM_PK_ENCRYPTION_FUNC_DEF(setRecipientKeyJni)(
- JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer
-) {
- const char *errorMessage = NULL;
- jbyte *keyPtr = NULL;
-
- OlmPkEncryption *encryptionPtr = getPkEncryptionInstanceId(env, thiz);
-
- if (!encryptionPtr)
- {
- LOGE(" ## pkSetRecipientKeyJni(): failure - invalid Encryption ptr=NULL");
- }
- else if (!aKeyBuffer)
- {
- LOGE(" ## pkSetRecipientKeyJni(): failure - invalid key");
- errorMessage = "invalid key";
- }
- else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, 0)))
- {
- LOGE(" ## pkSetRecipientKeyJni(): failure - key JNI allocation OOM");
- errorMessage = "key JNI allocation OOM";
- }
- else
- {
- if (olm_pk_encryption_set_recipient_key(encryptionPtr, keyPtr, (size_t)env->GetArrayLength(aKeyBuffer)) == olm_error())
- {
- errorMessage = olm_pk_encryption_last_error(encryptionPtr);
- LOGE(
- " ## pkSetRecipientKeyJni(): failure - olm_pk_encryption_set_recipient_key Msg=%s",
- errorMessage
- );
- }
- }
-
- if (keyPtr)
- {
- env->ReleaseByteArrayElements(aKeyBuffer, keyPtr, JNI_ABORT);
- }
-
- if (errorMessage)
- {
- env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage);
- }
-}
-
-JNIEXPORT jbyteArray OLM_PK_ENCRYPTION_FUNC_DEF(encryptJni)(
- JNIEnv *env, jobject thiz, jbyteArray aPlaintextBuffer, jobject aEncryptedMsg
-) {
- jbyteArray encryptedMsgRet = 0;
- const char* errorMessage = NULL;
- jbyte *plaintextPtr = NULL;
- jboolean plaintextIsCopied = JNI_FALSE;
-
- OlmPkEncryption *encryptionPtr = getPkEncryptionInstanceId(env, thiz);
- jclass encryptedMsgJClass = 0;
- jfieldID macFieldId;
- jfieldID ephemeralFieldId;
-
- if (!encryptionPtr)
- {
- LOGE(" ## pkEncryptJni(): failure - invalid Encryption ptr=NULL");
- }
- else if (!aPlaintextBuffer)
- {
- LOGE(" ## pkEncryptJni(): failure - invalid clear message");
- errorMessage = "invalid clear message";
- }
- else if (!(plaintextPtr = env->GetByteArrayElements(aPlaintextBuffer, &plaintextIsCopied)))
- {
- LOGE(" ## pkEncryptJni(): failure - plaintext JNI allocation OOM");
- errorMessage = "plaintext JNI allocation OOM";
- }
- else if (!(encryptedMsgJClass = env->GetObjectClass(aEncryptedMsg)))
- {
- LOGE(" ## pkEncryptJni(): failure - unable to get encrypted message class");
- errorMessage = "unable to get encrypted message class";
- }
- else if (!(macFieldId = env->GetFieldID(encryptedMsgJClass, "mMac", "Ljava/lang/String;")))
- {
- LOGE("## pkEncryptJni(): failure - unable to get MAC field");
- errorMessage = "unable to get MAC field";
- }
- else if (!(ephemeralFieldId = env->GetFieldID(encryptedMsgJClass, "mEphemeralKey", "Ljava/lang/String;")))
- {
- LOGE("## pkEncryptJni(): failure - unable to get ephemeral key field");
- errorMessage = "unable to get ephemeral key field";
- }
- else
- {
- size_t plaintextLength = (size_t)env->GetArrayLength(aPlaintextBuffer);
- size_t ciphertextLength = olm_pk_ciphertext_length(encryptionPtr, plaintextLength);
- size_t macLength = olm_pk_mac_length(encryptionPtr);
- size_t ephemeralLength = olm_pk_key_length();
- uint8_t *ciphertextPtr = NULL, *macPtr = NULL, *ephemeralPtr = NULL;
- size_t randomLength = olm_pk_encrypt_random_length(encryptionPtr);
- uint8_t *randomBuffPtr = NULL;
- LOGD("## pkEncryptJni(): randomLength=%lu",static_cast<long unsigned int>(randomLength));
- if (!(ciphertextPtr = (uint8_t*)malloc(ciphertextLength)))
- {
- LOGE("## pkEncryptJni(): failure - ciphertext JNI allocation OOM");
- errorMessage = "ciphertext JNI allocation OOM";
- }
- else if (!(macPtr = (uint8_t*)malloc(macLength + 1)))
- {
- LOGE("## pkEncryptJni(): failure - MAC JNI allocation OOM");
- errorMessage = "MAC JNI allocation OOM";
- }
- else if (!(ephemeralPtr = (uint8_t*)malloc(ephemeralLength + 1)))
- {
- LOGE("## pkEncryptJni(): failure: ephemeral key JNI allocation OOM");
- errorMessage = "ephemeral JNI allocation OOM";
- }
- else if (!setRandomInBuffer(env, &randomBuffPtr, randomLength))
- {
- LOGE("## pkEncryptJni(): failure - random buffer init");
- errorMessage = "random buffer init";
- }
- else
- {
- macPtr[macLength] = '\0';
- ephemeralPtr[ephemeralLength] = '\0';
-
- size_t returnValue = olm_pk_encrypt(
- encryptionPtr,
- plaintextPtr, plaintextLength,
- ciphertextPtr, ciphertextLength,
- macPtr, macLength,
- ephemeralPtr, ephemeralLength,
- randomBuffPtr, randomLength
- );
-
- if (returnValue == olm_error())
- {
- errorMessage = olm_pk_encryption_last_error(encryptionPtr);
- LOGE("## pkEncryptJni(): failure - olm_pk_encrypt Msg=%s", errorMessage);
- }
- else
- {
- encryptedMsgRet = env->NewByteArray(ciphertextLength);
- env->SetByteArrayRegion(
- encryptedMsgRet, 0, ciphertextLength, (jbyte*)ciphertextPtr
- );
-
- jstring macStr = env->NewStringUTF((char*)macPtr);
- env->SetObjectField(aEncryptedMsg, macFieldId, macStr);
- jstring ephemeralStr = env->NewStringUTF((char*)ephemeralPtr);
- env->SetObjectField(aEncryptedMsg, ephemeralFieldId, ephemeralStr);
- }
- }
-
- if (randomBuffPtr)
- {
- memset(randomBuffPtr, 0, randomLength);
- free(randomBuffPtr);
- }
- if (ephemeralPtr)
- {
- free(ephemeralPtr);
- }
- if (macPtr)
- {
- free(macPtr);
- }
- if (ciphertextPtr)
- {
- free(ciphertextPtr);
- }
- }
-
- if (plaintextPtr)
- {
- if (plaintextIsCopied)
- {
- memset(plaintextPtr, 0, (size_t)env->GetArrayLength(aPlaintextBuffer));
- }
- env->ReleaseByteArrayElements(aPlaintextBuffer, plaintextPtr, JNI_ABORT);
- }
-
- if (errorMessage)
- {
- env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage);
- }
-
- return encryptedMsgRet;
-}
-
-OlmPkDecryption * initializePkDecryptionMemory()
-{
- size_t decryptionSize = olm_pk_decryption_size();
- OlmPkDecryption *decryptionPtr = (OlmPkDecryption *)malloc(decryptionSize);
-
- if (decryptionPtr)
- {
- // init decryption object
- decryptionPtr = olm_pk_decryption(decryptionPtr);
- LOGD(
- "## initializePkDecryptionMemory(): success - OLM decryption size=%lu",
- static_cast<long unsigned int>(decryptionSize)
- );
- }
- else
- {
- LOGE("## initializePkDecryptionMemory(): failure - OOM");
- }
-
- return decryptionPtr;
-}
-
-JNIEXPORT jlong OLM_PK_DECRYPTION_FUNC_DEF(createNewPkDecryptionJni)(JNIEnv *env, jobject thiz)
-{
- const char* errorMessage = NULL;
- OlmPkDecryption *decryptionPtr = initializePkDecryptionMemory();
-
- // init encryption memory allocation
- if (!decryptionPtr)
- {
- LOGE("## createNewPkDecryptionJni(): failure - init decryption OOM");
- errorMessage = "init decryption OOM";
- }
- else
- {
- LOGD("## createNewPkDecryptionJni(): success - OLM decryption created");
- LOGD(
- "## createNewPkDecryptionJni(): decryptionPtr=%p (jlong)(intptr_t)decryptionPtr=%lld",
- decryptionPtr, (jlong)(intptr_t)decryptionPtr
- );
- }
-
- if (errorMessage)
- {
- // release the allocated data
- if (decryptionPtr)
- {
- olm_clear_pk_decryption(decryptionPtr);
- free(decryptionPtr);
- }
- env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage);
- }
-
- return (jlong)(intptr_t)decryptionPtr;
-}
-
-JNIEXPORT void OLM_PK_DECRYPTION_FUNC_DEF(releasePkDecryptionJni)(JNIEnv *env, jobject thiz)
-{
- LOGD("## releasePkDecryptionJni(): IN");
-
- OlmPkDecryption* decryptionPtr = getPkDecryptionInstanceId(env, thiz);
-
- if (!decryptionPtr)
- {
- LOGE(" ## releasePkDecryptionJni(): failure - invalid Decryption ptr=NULL");
- }
- else
- {
- LOGD(" ## releasePkDecryptionJni(): decryptionPtr=%p", encryptionPtr);
- olm_clear_pk_decryption(decryptionPtr);
-
- LOGD(" ## releasePkDecryptionJni(): IN");
- // even if free(NULL) does not crash, logs are performed for debug
- // purpose
- free(decryptionPtr);
- LOGD(" ## releasePkDecryptionJni(): OUT");
- }
-}
-
-JNIEXPORT jint OLM_PK_DECRYPTION_FUNC_DEF(privateKeyLength)(JNIEnv *env, jobject thiz)
-{
- return (jint) olm_pk_private_key_length();
-}
-
-JNIEXPORT jbyteArray OLM_PK_DECRYPTION_FUNC_DEF(setPrivateKeyJni)(JNIEnv *env, jobject thiz, jbyteArray key)
-{
- jbyteArray publicKeyRet = 0;
- jbyte *keyPtr = NULL;
- jboolean keyWasCopied = JNI_FALSE;
-
- const char* errorMessage = NULL;
-
- OlmPkDecryption* decryptionPtr = getPkDecryptionInstanceId(env, thiz);
-
- if (!decryptionPtr)
- {
- LOGE(" ## pkSetPrivateKeyJni(): failure - invalid Decryption ptr=NULL");
- }
- else if (!key)
- {
- LOGE(" ## pkSetPrivateKeyJni(): failure - invalid key");
- errorMessage = "invalid key";
- }
- else if (!(keyPtr = env->GetByteArrayElements(key, &keyWasCopied)))
- {
- LOGE(" ## pkSetPrivateKeyJni(): failure - key JNI allocation OOM");
- errorMessage = "key JNI allocation OOM";
- }
- else
- {
- size_t publicKeyLength = olm_pk_key_length();
- uint8_t *publicKeyPtr = NULL;
- size_t keyLength = (size_t)env->GetArrayLength(key);
- if (!(publicKeyPtr = (uint8_t*)malloc(publicKeyLength)))
- {
- LOGE("## pkSetPrivateKeyJni(): failure - public key JNI allocation OOM");
- errorMessage = "public key JNI allocation OOM";
- }
- else
- {
- size_t returnValue = olm_pk_key_from_private(
- decryptionPtr,
- publicKeyPtr, publicKeyLength,
- keyPtr, keyLength
- );
- if (returnValue == olm_error())
- {
- errorMessage = olm_pk_decryption_last_error(decryptionPtr);
- LOGE(" ## pkSetPrivateKeyJni(): failure - olm_pk_key_from_private Msg=%s", errorMessage);
- }
- else
- {
- publicKeyRet = env->NewByteArray(publicKeyLength);
- env->SetByteArrayRegion(
- publicKeyRet, 0, publicKeyLength, (jbyte*)publicKeyPtr
- );
- }
- }
- }
-
- if (keyPtr)
- {
- if (keyWasCopied)
- {
- memset(keyPtr, 0, (size_t)env->GetArrayLength(key));
- }
- env->ReleaseByteArrayElements(key, keyPtr, JNI_ABORT);
- }
-
- if (errorMessage)
- {
- env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage);
- }
-
- return publicKeyRet;
-}
-
-JNIEXPORT jbyteArray OLM_PK_DECRYPTION_FUNC_DEF(generateKeyJni)(JNIEnv *env, jobject thiz)
-{
- size_t randomLength = olm_pk_private_key_length();
- uint8_t *randomBuffPtr = NULL;
-
- jbyteArray publicKeyRet = 0;
- uint8_t *publicKeyPtr = NULL;
- size_t publicKeyLength = olm_pk_key_length();
- const char* errorMessage = NULL;
-
- OlmPkDecryption *decryptionPtr = getPkDecryptionInstanceId(env, thiz);
-
- if (!decryptionPtr)
- {
- LOGE(" ## pkGenerateKeyJni(): failure - invalid Decryption ptr=NULL");
- errorMessage = "invalid Decryption ptr=NULL";
- }
- else if (!setRandomInBuffer(env, &randomBuffPtr, randomLength))
- {
- LOGE("## pkGenerateKeyJni(): failure - random buffer init");
- errorMessage = "random buffer init";
- }
- else if (!(publicKeyPtr = static_cast<uint8_t*>(malloc(publicKeyLength))))
- {
- LOGE("## pkGenerateKeyJni(): failure - public key allocation OOM");
- errorMessage = "public key allocation OOM";
- }
- else
- {
- if (olm_pk_key_from_private(decryptionPtr, publicKeyPtr, publicKeyLength, randomBuffPtr, randomLength) == olm_error())
- {
- errorMessage = olm_pk_decryption_last_error(decryptionPtr);
- LOGE("## pkGenerateKeyJni(): failure - olm_pk_generate_key Msg=%s", errorMessage);
- }
- else
- {
- publicKeyRet = env->NewByteArray(publicKeyLength);
- env->SetByteArrayRegion(publicKeyRet, 0, publicKeyLength, (jbyte*)publicKeyPtr);
- LOGD("## pkGenerateKeyJni(): public key generated");
- }
- }
-
- if (randomBuffPtr)
- {
- memset(randomBuffPtr, 0, randomLength);
- free(randomBuffPtr);
- }
-
- if (errorMessage)
- {
- env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage);
- }
-
- return publicKeyRet;
-}
-
-JNIEXPORT jbyteArray OLM_PK_DECRYPTION_FUNC_DEF(privateKeyJni)(JNIEnv *env, jobject thiz)
-{
- jbyteArray privateKeyRet = 0;
-
- const char* errorMessage = NULL;
-
- OlmPkDecryption* decryptionPtr = getPkDecryptionInstanceId(env, thiz);
-
- if (!decryptionPtr)
- {
- LOGE(" ## pkPrivateKeyJni(): failure - invalid Decryption ptr=NULL");
- }
- else
- {
- size_t privateKeyLength = olm_pk_private_key_length();
- uint8_t *privateKeyPtr = NULL;
- if (!(privateKeyPtr = (uint8_t*)malloc(privateKeyLength)))
- {
- LOGE("## pkPrivateKeyJni(): failure - private key JNI allocation OOM");
- errorMessage = "private key JNI allocation OOM";
- }
- else
- {
- size_t returnValue = olm_pk_get_private_key(
- decryptionPtr,
- privateKeyPtr, privateKeyLength
- );
- if (returnValue == olm_error())
- {
- errorMessage = olm_pk_decryption_last_error(decryptionPtr);
- LOGE(" ## pkPrivateKeyJni(): failure - olm_pk_get_private_key Msg=%s", errorMessage);
- }
- else
- {
- privateKeyRet = env->NewByteArray(privateKeyLength);
- env->SetByteArrayRegion(
- privateKeyRet, 0, privateKeyLength, (jbyte*)privateKeyPtr
- );
- memset(privateKeyPtr, 0, privateKeyLength);
- }
- }
- }
-
- if (errorMessage)
- {
- env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage);
- }
-
- return privateKeyRet;
-}
-
-JNIEXPORT jbyteArray OLM_PK_DECRYPTION_FUNC_DEF(decryptJni)(
- JNIEnv *env, jobject thiz, jobject aEncryptedMsg
-) {
- const char* errorMessage = NULL;
- OlmPkDecryption *decryptionPtr = getPkDecryptionInstanceId(env, thiz);
-
- jclass encryptedMsgJClass = 0;
- jstring ciphertextJstring = 0;
- jstring macJstring = 0;
- jstring ephemeralKeyJstring = 0;
- jfieldID ciphertextFieldId;
- jfieldID macFieldId;
- jfieldID ephemeralKeyFieldId;
-
- const char *ciphertextPtr = NULL;
- const char *macPtr = NULL;
- const char *ephemeralKeyPtr = NULL;
-
- jbyteArray decryptedMsgRet = 0;
-
- if (!decryptionPtr)
- {
- LOGE(" ## pkDecryptJni(): failure - invalid Decryption ptr=NULL");
- errorMessage = "invalid Decryption ptr=NULL";
- }
- else if (!aEncryptedMsg)
- {
- LOGE(" ## pkDecryptJni(): failure - invalid encrypted message");
- errorMessage = "invalid encrypted message";
- }
- else if (!(encryptedMsgJClass = env->GetObjectClass(aEncryptedMsg)))
- {
- LOGE("## pkDecryptJni(): failure - unable to get encrypted message class");
- errorMessage = "unable to get encrypted message class";
- }
- else if (!(ciphertextFieldId = env->GetFieldID(encryptedMsgJClass,"mCipherText","Ljava/lang/String;")))
- {
- LOGE("## pkDecryptJni(): failure - unable to get message field");
- errorMessage = "unable to get message field";
- }
- else if (!(ciphertextJstring = (jstring)env->GetObjectField(aEncryptedMsg, ciphertextFieldId)))
- {
- LOGE("## pkDecryptJni(): failure - no ciphertext");
- errorMessage = "no ciphertext";
- }
- else if (!(ciphertextPtr = env->GetStringUTFChars(ciphertextJstring, 0)))
- {
- LOGE("## pkDecryptJni(): failure - ciphertext JNI allocation OOM");
- errorMessage = "ciphertext JNI allocation OOM";
- }
- else if (!(ciphertextJstring = (jstring)env->GetObjectField(aEncryptedMsg, ciphertextFieldId)))
- {
- LOGE("## pkDecryptJni(): failure - no ciphertext");
- errorMessage = "no ciphertext";
- }
- else if (!(ciphertextPtr = env->GetStringUTFChars(ciphertextJstring, 0)))
- {
- LOGE("## decryptMessageJni(): failure - ciphertext JNI allocation OOM");
- errorMessage = "ciphertext JNI allocation OOM";
- }
- else if (!(macFieldId = env->GetFieldID(encryptedMsgJClass,"mMac","Ljava/lang/String;")))
- {
- LOGE("## pkDecryptJni(): failure - unable to get MAC field");
- errorMessage = "unable to get MAC field";
- }
- else if (!(macJstring = (jstring)env->GetObjectField(aEncryptedMsg, macFieldId)))
- {
- LOGE("## pkDecryptJni(): failure - no MAC");
- errorMessage = "no MAC";
- }
- else if (!(macPtr = env->GetStringUTFChars(macJstring, 0)))
- {
- LOGE("## pkDecryptJni(): failure - MAC JNI allocation OOM");
- errorMessage = "ciphertext JNI allocation OOM";
- }
- else if (!(ephemeralKeyFieldId = env->GetFieldID(encryptedMsgJClass,"mEphemeralKey","Ljava/lang/String;")))
- {
- LOGE("## pkDecryptJni(): failure - unable to get ephemeral key field");
- errorMessage = "unable to get ephemeral key field";
- }
- else if (!(ephemeralKeyJstring = (jstring)env->GetObjectField(aEncryptedMsg, ephemeralKeyFieldId)))
- {
- LOGE("## pkDecryptJni(): failure - no ephemeral key");
- errorMessage = "no ephemeral key";
- }
- else if (!(ephemeralKeyPtr = env->GetStringUTFChars(ephemeralKeyJstring, 0)))
- {
- LOGE("## pkDecryptJni(): failure - ephemeral key JNI allocation OOM");
- errorMessage = "ephemeral key JNI allocation OOM";
- }
- else
- {
- size_t maxPlaintextLength = olm_pk_max_plaintext_length(
- decryptionPtr,
- (size_t)env->GetStringUTFLength(ciphertextJstring)
- );
- uint8_t *plaintextPtr = NULL;
- uint8_t *tempCiphertextPtr = NULL;
- size_t ciphertextLength = (size_t)env->GetStringUTFLength(ciphertextJstring);
- if (!(plaintextPtr = (uint8_t*)malloc(maxPlaintextLength)))
- {
- LOGE("## pkDecryptJni(): failure - plaintext JNI allocation OOM");
- errorMessage = "plaintext JNI allocation OOM";
- }
- else if (!(tempCiphertextPtr = (uint8_t*)malloc(ciphertextLength)))
- {
- LOGE("## pkDecryptJni(): failure - temp ciphertext JNI allocation OOM");
- }
- else
- {
- memcpy(tempCiphertextPtr, ciphertextPtr, ciphertextLength);
- size_t plaintextLength = olm_pk_decrypt(
- decryptionPtr,
- ephemeralKeyPtr, (size_t)env->GetStringUTFLength(ephemeralKeyJstring),
- macPtr, (size_t)env->GetStringUTFLength(macJstring),
- tempCiphertextPtr, ciphertextLength,
- plaintextPtr, maxPlaintextLength
- );
- if (plaintextLength == olm_error())
- {
- errorMessage = olm_pk_decryption_last_error(decryptionPtr);
- LOGE("## pkDecryptJni(): failure - olm_pk_decrypt Msg=%s", errorMessage);
- }
- else
- {
- decryptedMsgRet = env->NewByteArray(plaintextLength);
- env->SetByteArrayRegion(decryptedMsgRet, 0, plaintextLength, (jbyte*)plaintextPtr);
- LOGD(
- "## pkDecryptJni(): success returnedLg=%lu OK",
- static_cast<long unsigned int>(plaintextLength)
- );
- }
- }
-
- if (tempCiphertextPtr)
- {
- free(tempCiphertextPtr);
- }
- if (plaintextPtr)
- {
- memset(plaintextPtr, 0, maxPlaintextLength);
- free(plaintextPtr);
- }
- }
-
- if (ciphertextPtr)
- {
- env->ReleaseStringUTFChars(ciphertextJstring, ciphertextPtr);
- }
- if (macPtr)
- {
- env->ReleaseStringUTFChars(macJstring, macPtr);
- }
- if (ephemeralKeyPtr)
- {
- env->ReleaseStringUTFChars(ephemeralKeyJstring, ephemeralKeyPtr);
- }
-
- if (errorMessage)
- {
- env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage);
- }
-
- return decryptedMsgRet;
-}
-
-OlmPkSigning * initializePkSigningMemory()
-{
- size_t signingSize = olm_pk_signing_size();
- OlmPkSigning *signingPtr = (OlmPkSigning *)malloc(signingSize);
-
- if (signingPtr)
- {
- // init encryption object
- signingPtr = olm_pk_signing(signingPtr);
- LOGD(
- "## initializePkSigningMemory(): success - OLM signing size=%lu",
- static_cast<long unsigned int>(signingSize)
- );
- }
- else
- {
- LOGE("## initializePkSigningMemory(): failure - OOM");
- }
-
- return signingPtr;
-}
-
-JNIEXPORT jlong OLM_PK_SIGNING_FUNC_DEF(createNewPkSigningJni)(JNIEnv *env, jobject thiz)
-{
- const char* errorMessage = NULL;
- OlmPkSigning *signingPtr = initializePkSigningMemory();
-
- // init signing memory allocation
- if (!signingPtr)
- {
- LOGE("## createNewPkSigningJni(): failure - init signing OOM");
- errorMessage = "init signing OOM";
- }
- else
- {
- LOGD("## createNewPkSigningJni(): success - OLM signing created");
- LOGD(
- "## createNewPkSigningJni(): signingPtr=%p (jlong)(intptr_t)signingPtr=%lld",
- signingPtr, (jlong)(intptr_t)signingPtr
- );
- }
-
- if (errorMessage)
- {
- // release the allocated data
- if (signingPtr)
- {
- olm_clear_pk_signing(signingPtr);
- free(signingPtr);
- }
- env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage);
- }
-
- return (jlong)(intptr_t)signingPtr;
-}
-
-JNIEXPORT void OLM_PK_SIGNING_FUNC_DEF(releasePkSigningJni)(JNIEnv *env, jobject thiz)
-{
- LOGD("## releasePkSigningJni(): IN");
-
- OlmPkSigning* signingPtr = getPkSigningInstanceId(env, thiz);
-
- if (!signingPtr)
- {
- LOGE(" ## releasePkSigningJni(): failure - invalid Signing ptr=NULL");
- }
- else
- {
- LOGD(" ## releasePkSigningJni(): signingPtr=%p", signingPtr);
- olm_clear_pk_signing(signingPtr);
-
- LOGD(" ## releasePkSigningJni(): IN");
- // even if free(NULL) does not crash, logs are performed for debug
- // purpose
- free(signingPtr);
- LOGD(" ## releasePkSigningJni(): OUT");
- }
-}
-
-JNIEXPORT jbyteArray OLM_PK_SIGNING_FUNC_DEF(generateSeedJni)(JNIEnv *env, jobject thiz)
-{
- size_t randomLength = olm_pk_signing_seed_length();
- uint8_t *randomBuffPtr = NULL;
- jbyteArray randomRet = 0;
- const char* errorMessage = NULL;
-
- if (!setRandomInBuffer(env, &randomBuffPtr, randomLength))
- {
- errorMessage = "random buffer init";
- LOGE("## pkSigningGenerateSeedJni(): failure - %s", errorMessage);
- }
- else if (!(randomRet = env->NewByteArray(randomLength)))
- {
- errorMessage = "randomRet JNI allocation OOM";
- LOGE(" ## pkSigningGenerateSeedJni(): falure - %s", errorMessage);
- }
- else
- {
- env->SetByteArrayRegion(
- randomRet, 0, randomLength, (jbyte*)randomBuffPtr
- );
- }
-
- if (randomBuffPtr)
- {
- memset(randomBuffPtr, 0, randomLength);
- free(randomBuffPtr);
- }
-
- if (errorMessage)
- {
- env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage);
- }
-
- return randomRet;
-}
-
-JNIEXPORT jint OLM_PK_SIGNING_FUNC_DEF(seedLength)(JNIEnv *env, jobject thiz)
-{
- return (jint) olm_pk_signing_seed_length();
-}
-
-JNIEXPORT jbyteArray OLM_PK_SIGNING_FUNC_DEF(setKeyFromSeedJni)(JNIEnv *env, jobject thiz, jbyteArray seed)
-{
- const char* errorMessage = NULL;
- OlmPkSigning *signingPtr = getPkSigningInstanceId(env, thiz);
-
- jbyteArray publicKeyRet = 0;
- jbyte *seedPtr = NULL;
- jboolean seedWasCopied = JNI_FALSE;
-
- if (!signingPtr)
- {
- errorMessage = "invalid Siging ptr=NULL";
- LOGE(" ## setPkSigningKeyFromSeedJni(): failure - %s", errorMessage);
- }
- else if (!seed)
- {
- errorMessage = "invalid seed";
- LOGE(" ## setPkSigningKeyFromSeedJni: failure - %s", errorMessage);
- }
- else if (!(seedPtr = env->GetByteArrayElements(seed, &seedWasCopied)))
- {
- errorMessage = "seed JNI allocation OOM";
- LOGE(" ## setPkSigningKeyFromSeedJni(): failure - %s", errorMessage);
- }
- else
- {
- size_t publicKeyLength = olm_pk_signing_public_key_length();
- uint8_t *publicKeyPtr = NULL;
- size_t seedLength = (size_t)env->GetArrayLength(seed);
- if (!(publicKeyPtr = (uint8_t*)malloc(publicKeyLength)))
- {
- errorMessage = "public key JNI allocation OOM";
- LOGE(" ## setPkSigningKeyFromSeedJni(): falure - %s", errorMessage);
- }
- else
- {
- size_t returnValue = olm_pk_signing_key_from_seed(
- signingPtr,
- publicKeyPtr, publicKeyLength,
- seedPtr, seedLength
- );
- if (returnValue == olm_error())
- {
- errorMessage = olm_pk_signing_last_error(signingPtr);
- LOGE(" ## setPkSigningKeyFromSeedJni: failure - olm_pk_signing_key_from_seed Msg=%s", errorMessage);
- }
- else
- {
- if (!(publicKeyRet = env->NewByteArray(publicKeyLength))) {
- errorMessage = "publicKeyRet JNI allocation OOM";
- LOGE(" ## setPkSigningKeyFromSeedJni(): falure - %s", errorMessage);
- } else {
- env->SetByteArrayRegion(
- publicKeyRet, 0, publicKeyLength, (jbyte*)publicKeyPtr
- );
- }
- }
- }
- }
-
- if (seedPtr)
- {
- if (seedWasCopied)
- {
- memset(seedPtr, 0, (size_t)env->GetArrayLength(seed));
- }
- env->ReleaseByteArrayElements(seed, seedPtr, JNI_ABORT);
- }
-
- if (errorMessage)
- {
- env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage);
- }
-
- return publicKeyRet;
-}
-
-JNIEXPORT jbyteArray OLM_PK_SIGNING_FUNC_DEF(pkSignJni)(JNIEnv *env, jobject thiz, jbyteArray aMessage)
-{
- const char* errorMessage = NULL;
- OlmPkSigning *signingPtr = getPkSigningInstanceId(env, thiz);
-
- jbyteArray signatureRet = 0;
- jbyte *messagePtr = NULL;
- jboolean messageWasCopied = JNI_FALSE;
-
- if (!signingPtr)
- {
- errorMessage = "invalid Siging ptr=NULL";
- LOGE(" ## setPkSignJni(): failure - %s", errorMessage);
- }
- else if (!aMessage)
- {
- errorMessage = "message seed";
- LOGE(" ## setPkSignJni: failure - %s", errorMessage);
- }
- else if (!(messagePtr = env->GetByteArrayElements(aMessage, &messageWasCopied)))
- {
- errorMessage = "message JNI allocation OOM";
- LOGE(" ## setPkSignJni(): failure - %s", errorMessage);
- }
- else
- {
- size_t signatureLength = olm_pk_signature_length();
- uint8_t *signaturePtr = NULL;
- size_t messageLength = (size_t)env->GetArrayLength(aMessage);
- if (!(signaturePtr = (uint8_t*)malloc(signatureLength)))
- {
- errorMessage = "signature JNI allocation OOM";
- LOGE(" ## setPkSignJni(): falure - %s", errorMessage);
- }
- else
- {
- size_t returnValue = olm_pk_sign(
- signingPtr,
- (uint8_t *)messagePtr, messageLength,
- signaturePtr, signatureLength
- );
- if (returnValue == olm_error())
- {
- errorMessage = olm_pk_signing_last_error(signingPtr);
- LOGE(" ## setPkSignJni: failure - olm_pk_sign Msg=%s", errorMessage);
- }
- else
- {
- if (!(signatureRet = env->NewByteArray(signatureLength))) {
- errorMessage = "signatureRet JNI allocation OOM";
- LOGE(" ## setPkSignJni(): falure - %s", errorMessage);
- } else {
- env->SetByteArrayRegion(
- signatureRet, 0, signatureLength, (jbyte*)signaturePtr
- );
- }
- }
- }
- }
-
- if (messagePtr)
- {
- if (messageWasCopied)
- {
- memset(messagePtr, 0, (size_t)env->GetArrayLength(aMessage));
- }
- env->ReleaseByteArrayElements(aMessage, messagePtr, JNI_ABORT);
- }
-
- if (errorMessage)
- {
- env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage);
- }
-
- return signatureRet;
-}