Convert to sibs projectHEADmaster

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;
-}