From 034fa6be40b1a354dad5394cdb43651f435f8adb Mon Sep 17 00:00:00 2001 From: pedroGitt Date: Tue, 18 Oct 2016 15:59:36 +0200 Subject: - Add new API for OlmUtility - Introducing namespace AndroidOlmSdk - Fix logs (function names mixed up) - Add new check based on the calling java object instance type (IsInstanceOf()) - Fix return value for getXXXInstanceId() in case of failure. Now 0 is returned. --- .../OlmLibSdk/olm-sdk/src/main/jni/olm_utility.cpp | 210 ++++++++++++++++++++- 1 file changed, 203 insertions(+), 7 deletions(-) (limited to 'java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_utility.cpp') diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_utility.cpp b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_utility.cpp index fb9c9c5..1bd82a0 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_utility.cpp +++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_utility.cpp @@ -14,24 +14,220 @@ * limitations under the License. */ -#include "olm_jni.h" #include "olm_utility.h" +using namespace AndroidOlmSdk; + +OlmUtility* initializeUtilityMemory() +{ + OlmUtility* utilityPtr = NULL; + size_t utilitySize = olm_utility_size(); + + if(NULL != (utilityPtr=(OlmUtility*)malloc(utilitySize))) + { + utilityPtr = olm_utility(utilityPtr); + LOGD("## initializeUtilityMemory(): success - OLM utility size=%lu",utilitySize); + } + else + { + LOGE("## initializeUtilityMemory(): failure - OOM"); + } + + return utilityPtr; +} + + +JNIEXPORT jlong OLM_UTILITY_FUNC_DEF(initUtilityJni)(JNIEnv *env, jobject thiz) +{ + OlmUtility* utilityPtr = NULL; + + LOGD("## initUtilityJni(): IN"); + + // init account memory allocation + if(NULL == (utilityPtr = initializeUtilityMemory())) + { + LOGE(" ## initUtilityJni(): failure - init OOM"); + } + else + { + LOGD(" ## initUtilityJni(): success"); + } + + return (jlong)(intptr_t)utilityPtr; +} + + +JNIEXPORT void OLM_UTILITY_FUNC_DEF(releaseUtilityJni)(JNIEnv *env, jobject thiz) +{ + OlmUtility* utilityPtr = NULL; + + if(NULL == (utilityPtr = (OlmUtility*)getUtilityInstanceId(env,thiz))) + { + LOGE("## releaseUtilityJni(): failure - utility ptr=NULL"); + } + else + { + olm_clear_utility(utilityPtr); + free(utilityPtr); + } +} + + /** * Verify an ed25519 signature. * If the key was too small then the message will be "OLM.INVALID_BASE64". * If the signature was invalid then the message will be "OLM.BAD_MESSAGE_MAC". - * @param aKey the ed25519 key. - * @param aMessage the message which was signed. - * @param aSignature the base64-encoded signature to be checked. + * + * @param aSignature the base64-encoded message signature to be checked. + * @param aKey the ed25519 key (fingerprint key) + * @param aMessage the message which was signed * @param the result error if there is a problem with the verification. * @return true if validation succeed, false otherwise */ -JNIEXPORT bool OLM_UTILITY_FUNC_DEF(ed25519VerifyJni)(JNIEnv *env, jobject thiz, jstring aKey, jstring aMessage, jstring aSignature, jobject aErrorMessage) +JNIEXPORT jstring OLM_UTILITY_FUNC_DEF(verifyEd25519SignatureJni)(JNIEnv *env, jobject thiz, jstring aSignature, jstring aKey, jstring aMessage) +{ + jstring errorMessageRetValue = 0; + OlmUtility* utilityPtr = NULL; + const char* signaturePtr = NULL; + const char* keyPtr = NULL; + const char* messagePtr = NULL; + + LOGD("## verifyEd25519SignatureJni(): IN"); + + if(NULL == (utilityPtr = (OlmUtility*)getUtilityInstanceId(env,thiz))) + { + LOGE(" ## verifyEd25519SignatureJni(): failure - invalid utility ptr=NULL"); + } + else if((0 == aSignature) || (0 == aKey) || (0 == aMessage)) + { + LOGE(" ## verifyEd25519SignatureJni(): failure - invalid input parameters "); + } + else if(0 == (signaturePtr = env->GetStringUTFChars(aSignature, 0))) + { + LOGE(" ## verifyEd25519SignatureJni(): failure - signature JNI allocation OOM"); + } + else if(0 == (keyPtr = env->GetStringUTFChars(aKey, 0))) + { + LOGE(" ## verifyEd25519SignatureJni(): failure - key JNI allocation OOM"); + } + else if(0 == (messagePtr = env->GetStringUTFChars(aMessage, 0))) + { + LOGE(" ## verifyEd25519SignatureJni(): failure - message JNI allocation OOM"); + } + else + { + size_t signatureLength = (size_t)env->GetStringUTFLength(aSignature); + size_t keyLength = (size_t)env->GetStringUTFLength(aKey); + size_t messageLength = (size_t)env->GetStringUTFLength(aMessage); + LOGD(" ## verifyEd25519SignatureJni(): signatureLength=%lu keyLength=%lu messageLength=%lu",signatureLength,keyLength,messageLength); + + size_t result = olm_ed25519_verify(utilityPtr, + (void const *)keyPtr, + keyLength, + (void const *)messagePtr, + messageLength, + (void*)signaturePtr, + signatureLength); + if(result == olm_error()) { + const char *errorMsgPtr = olm_utility_last_error(utilityPtr); + errorMessageRetValue = env->NewStringUTF(errorMsgPtr); + LOGE("## verifyEd25519SignatureJni(): failure - session creation Msg=%s",errorMsgPtr); + } + else + { + LOGD("## verifyEd25519SignatureJni(): success - result=%ld", result); + } + } + + // free alloc + if(NULL != signaturePtr) + { + env->ReleaseStringUTFChars(aSignature, signaturePtr); + } + + if(NULL != keyPtr) + { + env->ReleaseStringUTFChars(aKey, keyPtr); + } + + if(NULL != messagePtr) + { + env->ReleaseStringUTFChars(aMessage, messagePtr); + } + + return errorMessageRetValue; +} + +/** +* Compute the digest (SHA 256) for the message passed in parameter.
+* The digest value is the function return value. +* @param aMessage +* @return digest of the message if operation succeed, null otherwise +**/ +JNIEXPORT jstring OLM_UTILITY_FUNC_DEF(sha256Jni)(JNIEnv *env, jobject thiz, jstring aMessageToHash) { - bool retCode = false; + jstring sha256RetValue = 0; + OlmUtility* utilityPtr = NULL; + const char* messagePtr = NULL; + void *hashValuePtr = NULL; + + LOGD("## sha256Jni(): IN"); + + if(NULL == (utilityPtr = (OlmUtility*)getUtilityInstanceId(env,thiz))) + { + LOGE(" ## sha256Jni(): failure - invalid utility ptr=NULL"); + } + else if(0 == aMessageToHash) + { + LOGE(" ## sha256Jni(): failure - invalid message parameters "); + } + else if(0 == (messagePtr = env->GetStringUTFChars(aMessageToHash, 0))) + { + LOGE(" ## sha256Jni(): failure - message JNI allocation OOM"); + } + else + { + // get lengths + size_t messageLength = (size_t)env->GetStringUTFLength(aMessageToHash); + size_t hashLength = olm_sha256_length(utilityPtr); + + if(NULL == (hashValuePtr = static_cast(malloc((hashLength+1)*sizeof(uint8_t))))) + { + LOGE("## sha256Jni(): failure - hash value allocation OOM"); + } + else + { + size_t result = olm_sha256(utilityPtr, + (void const *)messagePtr, + messageLength, + (void *)hashValuePtr, + hashLength); + if(result == olm_error()) + { + const char *errorMsgPtr = olm_utility_last_error(utilityPtr); + LOGE("## sha256Jni(): failure - hash creation Msg=%s",errorMsgPtr); + } + else + { + // update length + (static_cast(hashValuePtr))[result] = static_cast('\0'); + + LOGD("## sha256Jni(): success - result=%lu hashValue=%s",result, (char*)hashValuePtr); + sha256RetValue = env->NewStringUTF((const char*)hashValuePtr); + } + } + + } + if(NULL != hashValuePtr) + { + free(hashValuePtr); + } + if(NULL != messagePtr) + { + env->ReleaseStringUTFChars(aMessageToHash, messagePtr); + } - return retCode; + return sha256RetValue; } \ No newline at end of file -- cgit v1.2.3