diff options
Diffstat (limited to 'java/android/OlmLibSdk')
11 files changed, 546 insertions, 186 deletions
diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmInboundGroupSession.java b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmInboundGroupSession.java index 53ef7a3..aa15c32 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmInboundGroupSession.java +++ b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmInboundGroupSession.java @@ -34,20 +34,34 @@ public class OlmInboundGroupSession implements Serializable { */ private long mNativeOlmInboundGroupSessionId; - - public OlmInboundGroupSession() { - initNewSession(); - } - /** * Getter on the native inbound group session ID. * @return native inbound group session ID */ - public long getOlmInboundGroupSessionId(){ + public long getOlmInboundGroupSessionId() { return mNativeOlmInboundGroupSessionId; } /** + * Constructor.<br> + * Create and save a new native session instance ID and start a new inbound group session. + * The session key parameter is retrieved from a outbound group session + * See {@link #initNewSession()} and {@link #initInboundGroupSessionWithSessionKey(String)} + * @param aSessionKey session key + * @throws OlmUtilsException + */ + public OlmInboundGroupSession(String aSessionKey) throws OlmUtilsException { + if(initNewSession()) { + if( 0 != initInboundGroupSessionWithSessionKey(aSessionKey)) { + releaseSession();// prevent memory leak before throwing + throw new OlmUtilsException(OlmUtilsException.EXCEPTION_CODE_INIT_INBOUND_GROUP_SESSION); + } + } else { + throw new OlmUtilsException(OlmUtilsException.EXCEPTION_CODE_INIT_NEW_SESSION_FAILURE); + } + } + + /** * Release native session and invalid its JAVA reference counter part.<br> * Public API for {@link #releaseSessionJni()}. * To be called before any other API call. @@ -88,12 +102,13 @@ public class OlmInboundGroupSession implements Serializable { private native long initNewSessionJni(); /** - * Creates a new inbound group session.<br> - * The session key parameter is retrieved from a outbound group session. + * Start a new inbound group session.<br> + * The session key parameter is retrieved from a outbound group session + * see {@link OlmOutboundGroupSession#sessionKey()} * @param aSessionKey session key * @return 0 if operation succeed, -1 otherwise */ - public int initInboundGroupSessionWithSessionKey(String aSessionKey) { + private int initInboundGroupSessionWithSessionKey(String aSessionKey) { int retCode = -1; if(TextUtils.isEmpty(aSessionKey)){ diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmOutboundGroupSession.java b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmOutboundGroupSession.java index 63c0c36..bbe2718 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmOutboundGroupSession.java +++ b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmOutboundGroupSession.java @@ -28,16 +28,30 @@ public class OlmOutboundGroupSession { */ private long mNativeOlmOutboundGroupSessionId; - public OlmOutboundGroupSession() { - initNewSession(); - } - /** * Getter on the native outbound group session ID. * @return native outbound group session ID */ public long getOlmInboundGroupSessionId(){ - return mNativeOlmInboundGroupSessionId; + return mNativeOlmOutboundGroupSessionId; + } + + /** + * Constructor.<br> + * Create and save a new session native instance ID and + * initialise a new outbound group session.<br> + * See {@link #initNewSession()} and {@link #initOutboundGroupSession()} + * @throws OlmUtilsException + */ + public OlmOutboundGroupSession() throws OlmUtilsException { + if(initNewSession()) { + if( 0 != initOutboundGroupSession()) { + releaseSession();// prevent memory leak before throwing + throw new OlmUtilsException(OlmUtilsException.EXCEPTION_CODE_INIT_OUTBOUND_GROUP_SESSION); + } + } else { + throw new OlmUtilsException(OlmUtilsException.EXCEPTION_CODE_INIT_NEW_SESSION_FAILURE); + } } /** @@ -45,9 +59,8 @@ public class OlmOutboundGroupSession { * Public API for {@link #releaseSessionJni()}. * To be called before any other API call. */ - public void releaseSession(){ - releaseSessionJni(); - + public void releaseSession() { + releaseSessionJni(); mNativeOlmOutboundGroupSessionId = 0; } @@ -80,54 +93,66 @@ public class OlmOutboundGroupSession { */ private native long initNewSessionJni(); - /** - * Creates a new outbound group session.<br> - * The session key parameter is retrieved from a outbound group session. + * Start a new outbound group session.<br> * @return 0 if operation succeed, -1 otherwise */ - public int initOutboundGroupSession() { + private int initOutboundGroupSession() { return initOutboundGroupSessionJni(); } - public native int initOutboundGroupSessionJni(); - - - + private native int initOutboundGroupSessionJni(); + /** + * Get a base64-encoded identifier for this session. + * @return session identifier if operation succeed, null otherwise. + */ public String sessionIdentifier() { String retValue = null; - //retValue = sessionIdentifierJni(); + retValue = sessionIdentifierJni(); return retValue; } - public native String sessionIdentifierJni(); - + private native String sessionIdentifierJni(); - - - public long messageIndex() { - long retValue =0; - //retValue = messageIndexJni(); + /** + * Get the current message index for this session.<br> + * Each message is sent with an increasing index, this + * method returns the index for the next message. + * @return current session index + */ + public int messageIndex() { + int retValue =0; + retValue = messageIndexJni(); return retValue; } - private native long messageIndexJni(); - - - + private native int messageIndexJni(); + /** + * Get the base64-encoded current ratchet key for this session.<br> + * Each message is sent with a different ratchet key. This method returns the + * ratchet key that will be used for the next message. + * @return outbound session key + */ public String sessionKey() { String retValue = null; - //retValue = sessionKeyJni(); + retValue = sessionKeyJni(); return retValue; } private native String sessionKeyJni(); - + /** + * Encrypt some plain-text message.<br> + * @param aClearMsg message to be encrypted + * @return the encrypted message if operation succeed, null otherwise + */ public String encryptMessage(String aClearMsg) { String retValue = null; - //retValue = encryptMessageJni(aClearMsg); + + if(!TextUtils.isEmpty(aClearMsg)) { + retValue = encryptMessageJni(aClearMsg); + } return retValue; } diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmUtilsException.java b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmUtilsException.java new file mode 100644 index 0000000..f0cdc83 --- /dev/null +++ b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmUtilsException.java @@ -0,0 +1,35 @@ +/* + * Copyright 2016 OpenMarket 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. + */ + +package org.matrix.olm; + +public class OlmUtilsException extends Exception { + // exception codes + public static final int EXCEPTION_CODE_INIT_NEW_SESSION_FAILURE = 0; + public static final int EXCEPTION_CODE_INIT_OUTBOUND_GROUP_SESSION = 1; + public static final int EXCEPTION_CODE_INIT_INBOUND_GROUP_SESSION = 2; + + private final int mCode; + + public OlmUtilsException(int aExceptionCode) { + super(); + mCode = aExceptionCode; + } + + public int getExceptionCode() { + return mCode; + } +} diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/Android.mk b/java/android/OlmLibSdk/olm-sdk/src/main/jni/Android.mk index 01c0dc9..92a9359 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/Android.mk +++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/Android.mk @@ -45,8 +45,9 @@ $(SRC_ROOT_DIR)/lib/crypto-algorithms/aes.c \ $(SRC_ROOT_DIR)/lib/curve25519-donna/curve25519-donna.c \ olm_account.cpp \ olm_session.cpp \ -olm_utility.cpp \ -olm_inbound_group_session.cpp +olm_jni_helper.cpp \ +olm_inbound_group_session.cpp \ +olm_outbound_group_session.cpp LOCAL_LDLIBS := -llog diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_account.cpp b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_account.cpp index ba15c13..860ff3e 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_account.cpp +++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_account.cpp @@ -15,7 +15,6 @@ */ #include "olm_account.h" -#include "olm_utility.h" /** * Init memory allocation for account creation. @@ -85,9 +84,12 @@ JNIEXPORT jlong OLM_ACCOUNT_FUNC_DEF(initNewAccountJni)(JNIEnv *env, jobject thi } else { - // allocate random buffer + // get random buffer size randomSize = olm_create_account_random_length(accountPtr); - if(!setRandomInBuffer(&randomBuffPtr, randomSize)) + LOGD("## initNewAccount(): randomSize=%lu", randomSize); + + // allocate random buffer + if((0!=randomSize) && !setRandomInBuffer(&randomBuffPtr, randomSize)) { LOGE("## initNewAccount(): failure - random buffer init"); } @@ -219,7 +221,7 @@ JNIEXPORT jint OLM_ACCOUNT_FUNC_DEF(generateOneTimeKeys)(JNIEnv *env, jobject th randomLength = olm_account_generate_one_time_keys_random_length(accountPtr, (size_t)aNumberOfKeys); LOGD("## generateOneTimeKeys(): randomLength=%ld", randomLength); - if(!setRandomInBuffer(&randomBufferPtr, randomLength)) + if((0!=randomLength) && !setRandomInBuffer(&randomBufferPtr, randomLength)) { LOGE("## generateOneTimeKeys(): failure - random buffer init"); } diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_inbound_group_session.cpp b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_inbound_group_session.cpp index 43e9e20..16e5a0b 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_inbound_group_session.cpp +++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_inbound_group_session.cpp @@ -15,7 +15,6 @@ */ #include "olm_inbound_group_session.h" -#include "olm_utility.h" /** @@ -123,45 +122,54 @@ JNIEXPORT jint OLM_INBOUND_GROUP_SESSION_FUNC_DEF(initInboundGroupSessionWithSes } +/** +* Get a base64-encoded identifier for this inbound group session. +*/ JNIEXPORT jstring OLM_INBOUND_GROUP_SESSION_FUNC_DEF(sessionIdentifierJni)(JNIEnv *env, jobject thiz) { OlmInboundGroupSession *sessionPtr = NULL; uint8_t *sessionIdPtr = NULL; jstring returnValueStr=0; - // get the size to alloc to contain the id - size_t lengthSessionId = olm_inbound_group_session_id_length(sessionPtr); + LOGD("## sessionIdentifierJni(): inbound group session IN"); if(NULL == (sessionPtr = (OlmInboundGroupSession*)getInboundGroupSessionInstanceId(env,thiz))) { LOGE("## sessionIdentifierJni(): failure - invalid inbound group session instance"); } - else if(NULL == (sessionIdPtr = (uint8_t*)malloc(lengthSessionId*sizeof(uint8_t)))) - { - LOGE("## sessionIdentifierJni(): failure - identifier allocation OOM"); - } else { - size_t result = olm_inbound_group_session_id(sessionPtr, sessionIdPtr, lengthSessionId); - if (result == olm_error()) + // get the size to alloc + size_t lengthSessionId = olm_inbound_group_session_id_length(sessionPtr); + LOGD("## sessionIdentifierJni(): inbound group session lengthSessionId=%lu",lengthSessionId); + + if(NULL == (sessionIdPtr = (uint8_t*)malloc(lengthSessionId*sizeof(uint8_t)))) { - const char *errorMsgPtr = olm_inbound_group_session_last_error(sessionPtr); - LOGE("## sessionIdentifierJni(): failure - get session identifier failure Msg=%s",errorMsgPtr); + LOGE("## sessionIdentifierJni(): failure - inbound group session identifier allocation OOM"); } else { - // update length - sessionIdPtr[result] = static_cast<char>('\0'); - - LOGD("## sessionIdentifierJni(): success - result=%lu sessionId=%s",result, (char*)sessionIdPtr); - returnValueStr = env->NewStringUTF((const char*)sessionIdPtr); + size_t result = olm_inbound_group_session_id(sessionPtr, sessionIdPtr, lengthSessionId); + if (result == olm_error()) + { + const char *errorMsgPtr = olm_inbound_group_session_last_error(sessionPtr); + LOGE("## sessionIdentifierJni(): failure - get inbound group session identifier failure Msg=%s",errorMsgPtr); + } + else + { + // update length + sessionIdPtr[result] = static_cast<char>('\0'); + LOGD("## sessionIdentifierJni(): success - inbound group session result=%lu sessionId=%s",result, (char*)sessionIdPtr); + returnValueStr = env->NewStringUTF((const char*)sessionIdPtr); + } + free(sessionIdPtr); } - free(sessionIdPtr); } return returnValueStr; } + JNIEXPORT jstring OLM_INBOUND_GROUP_SESSION_FUNC_DEF(decryptMessageJni)(JNIEnv *env, jobject thiz, jstring aEncryptedMsg) { jstring decryptedMsgRetValue = 0; @@ -178,7 +186,7 @@ JNIEXPORT jstring OLM_INBOUND_GROUP_SESSION_FUNC_DEF(decryptMessageJni)(JNIEnv * } else if(0 == aEncryptedMsg) { - LOGE("## decryptMessageJni(): failure - invalid clear message"); + LOGE("## decryptMessageJni(): failure - invalid encrypted message"); } else if(0 == (encryptedMsgPtr = env->GetStringUTFChars(aEncryptedMsg, 0))) { diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_jni.h b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_jni.h index 8f1555d..2bfb9f8 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_jni.h +++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_jni.h @@ -53,4 +53,21 @@ static const int ERROR_CODE_KO = -1; // constants static const int ACCOUNT_CREATION_RANDOM_MODULO = 256; +#ifdef __cplusplus +extern "C" { +#endif + +// internal helper functions +bool setRandomInBuffer(uint8_t **aBuffer2Ptr, size_t aRandomSize); +jlong getSessionInstanceId(JNIEnv* aJniEnv, jobject aJavaObject); +jlong getAccountInstanceId(JNIEnv* aJniEnv, jobject aJavaObject); +jlong getInboundGroupSessionInstanceId(JNIEnv* aJniEnv, jobject aJavaObject); +jlong getOutboundGroupSessionInstanceId(JNIEnv* aJniEnv, jobject aJavaObject); + + +#ifdef __cplusplus +} +#endif + + #endif diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_jni_helper.cpp b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_jni_helper.cpp new file mode 100644 index 0000000..1d64d75 --- /dev/null +++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_jni_helper.cpp @@ -0,0 +1,220 @@ +/** + * Created by pedrocon on 06/10/2016. + */ +/* + * Copyright 2016 OpenMarket 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_jni.h" + +/** +* Init a buffer with a given number of random values. +* @param aBuffer2Ptr the buffer to be initialized +* @param aRandomSize the number of random values to apply +* @return true if operation succeed, false otherwise +**/ +bool setRandomInBuffer(uint8_t **aBuffer2Ptr, size_t aRandomSize) +{ + bool retCode = false; + if(NULL == aBuffer2Ptr) + { + LOGD("## setRandomInBuffer(): failure - aBuffer=NULL"); + } + else if(0 == aRandomSize) + { + LOGD("## setRandomInBuffer(): failure - random size=0"); + } + else if(NULL == (*aBuffer2Ptr = (uint8_t*)malloc(aRandomSize*sizeof(uint8_t)))) + { + LOGD("## setRandomInBuffer(): failure - alloc mem OOM"); + } + else + { + LOGD("## setRandomInBuffer(): randomSize=%ld",aRandomSize); + + srand(time(NULL)); // init seed + for(size_t i=0;i<aRandomSize;i++) + { + (*aBuffer2Ptr)[i] = (uint8_t)(rand()%ACCOUNT_CREATION_RANDOM_MODULO); + + // debug purpose + //LOGD("## setRandomInBuffer(): randomBuffPtr[%ld]=%d",i, (*aBuffer2Ptr)[i]); + } + + retCode = true; + } + return retCode; +} + + +/** +* Read the account instance ID of the calling object. +* @param aJniEnv pointer pointing on the JNI function table +* @param aJavaObject reference to the object on which the method is invoked +* @return the instance ID if operation succeed, -1 if instance ID was not found. +**/ +jlong getAccountInstanceId(JNIEnv* aJniEnv, jobject aJavaObject) +{ + jlong instanceId=-1; + jfieldID instanceIdField; + jclass loaderClass; + + if(NULL!=aJniEnv) + { + if(0 != (loaderClass=aJniEnv->GetObjectClass(aJavaObject))) + { + if(0 != (instanceIdField=aJniEnv->GetFieldID(loaderClass, "mNativeOlmAccountId", "J"))) + { + instanceId = aJniEnv->GetLongField(aJavaObject, instanceIdField); + aJniEnv->DeleteLocalRef(loaderClass); + LOGD("## getAccountInstanceId(): read from java instanceId=%lld",instanceId); + } + else + { + LOGD("## getAccountInstanceId() ERROR! GetFieldID=null"); + } + } + else + { + LOGD("## getAccountInstanceId() ERROR! GetObjectClass=null"); + } + } + else + { + LOGD("## getAccountInstanceId() ERROR! aJniEnv=NULL"); + } + LOGD("## getAccountInstanceId() success - instanceId=%lld",instanceId); + return instanceId; +} + +/** +* Read the session instance ID of the calling object (aJavaObject).<br> +* @param aJniEnv pointer pointing on the JNI function table +* @param aJavaObject reference to the object on which the method is invoked +* @return the instance ID if read succeed, -1 otherwise. +**/ +jlong getSessionInstanceId(JNIEnv* aJniEnv, jobject aJavaObject) +{ + jlong instanceId=-1; + jfieldID instanceIdField; + jclass loaderClass; + + if(NULL!=aJniEnv) + { + if(0 != (loaderClass=aJniEnv->GetObjectClass(aJavaObject))) + { + if(0 != (instanceIdField=aJniEnv->GetFieldID(loaderClass, "mNativeOlmSessionId", "J"))) + { + instanceId = aJniEnv->GetLongField(aJavaObject, instanceIdField); + aJniEnv->DeleteLocalRef(loaderClass); + } + else + { + LOGD("## getSessionInstanceId() ERROR! GetFieldID=null"); + } + } + else + { + LOGD("## getSessionInstanceId() ERROR! GetObjectClass=null"); + } + } + else + { + LOGD("## getSessionInstanceId() ERROR! aJniEnv=NULL"); + } + + //LOGD("## getSessionInstanceId() success - instanceId=%lld",instanceId); + return instanceId; +} + + +/** +* Read the inbound group session instance ID of the calling object (aJavaObject).<br> +* @param aJniEnv pointer pointing on the JNI function table +* @param aJavaObject reference to the object on which the method is invoked +* @return the instance ID if read succeed, -1 otherwise. +**/ +jlong getInboundGroupSessionInstanceId(JNIEnv* aJniEnv, jobject aJavaObject) +{ + jlong instanceId=-1; + jfieldID instanceIdField; + jclass loaderClass; + + if(NULL!=aJniEnv) + { + if(0 != (loaderClass=aJniEnv->GetObjectClass(aJavaObject))) + { + if(0 != (instanceIdField=aJniEnv->GetFieldID(loaderClass, "mNativeOlmInboundGroupSessionId", "J"))) + { + instanceId = aJniEnv->GetLongField(aJavaObject, instanceIdField); + aJniEnv->DeleteLocalRef(loaderClass); + } + else + { + LOGD("## getInboundGroupSessionInstanceId() ERROR! GetFieldID=null"); + } + } + else + { + LOGD("## getInboundGroupSessionInstanceId() ERROR! GetObjectClass=null"); + } + } + else + { + LOGD("## getInboundGroupSessionInstanceId() ERROR! aJniEnv=NULL"); + } + + return instanceId; +} + + +/** +* Read the outbound group session instance ID of the calling object (aJavaObject).<br> +* @param aJniEnv pointer pointing on the JNI function table +* @param aJavaObject reference to the object on which the method is invoked +* @return the instance ID if read succeed, -1 otherwise. +**/ +jlong getOutboundGroupSessionInstanceId(JNIEnv* aJniEnv, jobject aJavaObject) +{ + jlong instanceId=-1; + jfieldID instanceIdField; + jclass loaderClass; + + if(NULL!=aJniEnv) + { + if(0 != (loaderClass=aJniEnv->GetObjectClass(aJavaObject))) + { + if(0 != (instanceIdField=aJniEnv->GetFieldID(loaderClass, "mNativeOlmOutboundGroupSessionId", "J"))) + { + instanceId = aJniEnv->GetLongField(aJavaObject, instanceIdField); + aJniEnv->DeleteLocalRef(loaderClass); + } + else + { + LOGD("## getOutboundGroupSessionInstanceId() ERROR! GetFieldID=null"); + } + } + else + { + LOGD("## getOutboundGroupSessionInstanceId() ERROR! GetObjectClass=null"); + } + } + else + { + LOGD("## getOutboundGroupSessionInstanceId() ERROR! aJniEnv=NULL"); + } + + return instanceId; +} diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_outbound_group_session.cpp b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_outbound_group_session.cpp index 40af39d..46c0ee4 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_outbound_group_session.cpp +++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_outbound_group_session.cpp @@ -15,7 +15,6 @@ */ #include "olm_outbound_group_session.h" -#include "olm_utility.h" /** @@ -31,12 +30,12 @@ JNIEXPORT void OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(releaseSessionJni)(JNIEnv *en if(NULL == (sessionPtr = (OlmOutboundGroupSession*)getOutboundGroupSessionInstanceId(env,thiz))) { - LOGE("## releaseSessionJni(): failure - invalid inbound group session instance"); + LOGE("## releaseSessionJni(): failure - invalid outbound group session instance"); } else { size_t retCode = olm_clear_outbound_group_session(sessionPtr); - LOGD("## releaseSessionJni(): clear_inbound_group_session=%lu",retCode); + LOGD("## releaseSessionJni(): clear_outbound_group_session=%lu",retCode); LOGD("## releaseSessionJni(): IN"); free(sessionPtr); @@ -73,25 +72,26 @@ JNIEXPORT jlong OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(initNewSessionJni)(JNIEnv *e } /** - * Create a new outbound session.<br> + * Start a new outbound session.<br> * @return ERROR_CODE_OK if operation succeed, ERROR_CODE_KO otherwise */ -JNIEXPORT jint OLM_INBOUND_GROUP_SESSION_FUNC_DEF(initOutboundGroupSessionJni)(JNIEnv *env, jobject thiz) +JNIEXPORT jint OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(initOutboundGroupSessionJni)(JNIEnv *env, jobject thiz) { jint retCode = ERROR_CODE_KO; OlmOutboundGroupSession *sessionPtr = NULL; uint8_t *randomBuffPtr = NULL; - size_t sessionResult; + + LOGD("## initOutboundGroupSessionJni(): IN"); if(NULL == (sessionPtr = (OlmOutboundGroupSession*)getOutboundGroupSessionInstanceId(env,thiz))) { - LOGE("## initOutboundGroupSessionJni(): failure - invalid inbound group session instance"); + LOGE("## initOutboundGroupSessionJni(): failure - invalid outbound group session instance"); } else { // compute random buffer size_t randomLength = olm_init_outbound_group_session_random_length(sessionPtr); - + LOGW("## initOutboundGroupSessionJni(): randomLength=%lu",randomLength); if((0!=randomLength) && !setRandomInBuffer(&randomBuffPtr, randomLength)) { LOGE("## initOutboundGroupSessionJni(): failure - random buffer init"); @@ -103,190 +103,224 @@ JNIEXPORT jint OLM_INBOUND_GROUP_SESSION_FUNC_DEF(initOutboundGroupSessionJni)(J LOGW("## initOutboundGroupSessionJni(): random buffer is not required"); } - size_t sessionResult = olm_init_outbound_group_session(sessionPtr, sessionKeyPtr, sessionKeyLength); + size_t sessionResult = olm_init_outbound_group_session(sessionPtr, randomBuffPtr, randomLength); if(sessionResult == olm_error()) { - const char *errorMsgPtr = olm_inbound_group_session_last_error(sessionPtr); - LOGE("## initInboundSessionFromIdKeyJni(): failure - init inbound session creation Msg=%s",errorMsgPtr); + const char *errorMsgPtr = olm_outbound_group_session_last_error(sessionPtr); + LOGE("## initOutboundGroupSessionJni(): failure - init outbound session creation Msg=%s",errorMsgPtr); } else { retCode = ERROR_CODE_OK; - LOGD("## initInboundSessionFromIdKeyJni(): success - result=%lu", sessionResult); + LOGD("## initOutboundGroupSessionJni(): success - result=%lu", sessionResult); } - - } } - - else if(0 == aSessionKey) + if(NULL != randomBuffPtr) { - LOGE("## initInboundGroupSessionWithSessionKeyJni(): failure - invalid aSessionKey"); + free(randomBuffPtr); } - else if(NULL == (sessionKeyPtr = (const uint8_t *)env->GetStringUTFChars(aSessionKey, 0))) + + return retCode; +} + +/** +* Get a base64-encoded identifier for this outbound group session. +*/ +JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(sessionIdentifierJni)(JNIEnv *env, jobject thiz) +{ + OlmOutboundGroupSession *sessionPtr = NULL; + uint8_t *sessionIdPtr = NULL; + jstring returnValueStr=0; + + LOGD("## sessionIdentifierJni(): outbound group session IN"); + + if(NULL == (sessionPtr = (OlmOutboundGroupSession*)getOutboundGroupSessionInstanceId(env,thiz))) { - LOGE("## initInboundSessionFromIdKeyJni(): failure - session key JNI allocation OOM"); + LOGE("## sessionIdentifierJni(): failure - invalid outbound group session instance"); } else { - size_t sessionKeyLength = (size_t)env->GetStringUTFLength(aSessionKey); - LOGD("## initInboundSessionFromIdKeyJni(): sessionKeyLength=%lu",sessionKeyLength); + // get the size to alloc + size_t lengthSessionId = olm_outbound_group_session_id_length(sessionPtr); + LOGD("## sessionIdentifierJni(): outbound group session lengthSessionId=%lu",lengthSessionId); - sessionResult = olm_init_inbound_group_session(sessionPtr, sessionKeyPtr, sessionKeyLength); - if(sessionResult == olm_error()) { - const char *errorMsgPtr = olm_inbound_group_session_last_error(sessionPtr); - LOGE("## initInboundSessionFromIdKeyJni(): failure - init inbound session creation Msg=%s",errorMsgPtr); + if(NULL == (sessionIdPtr = (uint8_t*)malloc(lengthSessionId*sizeof(uint8_t)))) + { + LOGE("## sessionIdentifierJni(): failure - outbound identifier allocation OOM"); } else { - retCode = ERROR_CODE_OK; - LOGD("## initInboundSessionFromIdKeyJni(): success - result=%lu", sessionResult); - } - } + size_t result = olm_outbound_group_session_id(sessionPtr, sessionIdPtr, lengthSessionId); + if (result == olm_error()) + { + const char *errorMsgPtr = olm_outbound_group_session_last_error(sessionPtr); + LOGE("## sessionIdentifierJni(): failure - outbound group session identifier failure Msg=%s",errorMsgPtr); + } + else + { + // update length + sessionIdPtr[result] = static_cast<char>('\0'); + LOGD("## sessionIdentifierJni(): success - outbound group session identifier result=%lu sessionId=%s",result, (char*)sessionIdPtr); + returnValueStr = env->NewStringUTF((const char*)sessionIdPtr); + } - // free local alloc - if(NULL!= sessionKeyPtr) - { - env->ReleaseStringUTFChars(aSessionKey, (const char*)sessionKeyPtr); - } + // free alloc + free(sessionIdPtr); + } + } - return retCode; + return returnValueStr; } -JNIEXPORT jstring OLM_INBOUND_GROUP_SESSION_FUNC_DEF(sessionIdentifierJni)(JNIEnv *env, jobject thiz) +/** +* Get the current message index for this session.<br> +* Each message is sent with an increasing index, this +* method returns the index for the next message. +* @return current session index +*/ +JNIEXPORT jint OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(messageIndexJni)(JNIEnv *env, jobject thiz) { - OlmInboundGroupSession *sessionPtr = NULL; - uint8_t *sessionIdPtr = NULL; - jstring returnValueStr=0; + OlmOutboundGroupSession *sessionPtr = NULL; + jint indexRetValue = 0; - // get the size to alloc to contain the id - size_t lengthSessionId = olm_inbound_group_session_id_length(sessionPtr); + LOGD("## messageIndexJni(): IN"); - if(NULL == (sessionPtr = (OlmInboundGroupSession*)getInboundGroupSessionInstanceId(env,thiz))) + if(NULL == (sessionPtr = (OlmOutboundGroupSession*)getOutboundGroupSessionInstanceId(env,thiz))) + { + LOGE("## messageIndexJni(): failure - invalid outbound group session instance"); + } + else { - LOGE("## sessionIdentifierJni(): failure - invalid inbound group session instance"); + indexRetValue = static_cast<jint>(olm_outbound_group_session_message_index(sessionPtr)); } - else if(NULL == (sessionIdPtr = (uint8_t*)malloc(lengthSessionId*sizeof(uint8_t)))) + LOGD("## messageIndexJni(): success - index=%d",indexRetValue); + + return indexRetValue; +} + + +/** +* Get the base64-encoded current ratchet key for this session.<br> +*/ +JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(sessionKeyJni)(JNIEnv *env, jobject thiz) +{ + OlmOutboundGroupSession *sessionPtr = NULL; + uint8_t *sessionKeyPtr = NULL; + jstring returnValueStr=0; + + LOGD("## sessionKeyJni(): outbound group session IN"); + + if(NULL == (sessionPtr = (OlmOutboundGroupSession*)getOutboundGroupSessionInstanceId(env,thiz))) { - LOGE("## sessionIdentifierJni(): failure - identifier allocation OOM"); + LOGE(" ## sessionKeyJni(): failure - invalid outbound group session instance"); } else { - size_t result = olm_inbound_group_session_id(sessionPtr, sessionIdPtr, lengthSessionId); - if (result == olm_error()) + // get the size to alloc + size_t sessionKeyLength = olm_outbound_group_session_key_length(sessionPtr); + LOGD(" ## sessionKeyJni(): sessionKeyLength=%lu",sessionKeyLength); + + if(NULL == (sessionKeyPtr = (uint8_t*)malloc(sessionKeyLength*sizeof(uint8_t)))) { - const char *errorMsgPtr = olm_inbound_group_session_last_error(sessionPtr); - LOGE("## sessionIdentifierJni(): failure - get session identifier failure Msg=%s",errorMsgPtr); + LOGE(" ## sessionKeyJni(): failure - session key allocation OOM"); } else { - // update length - sessionIdPtr[result] = static_cast<char>('\0'); + size_t result = olm_outbound_group_session_key(sessionPtr, sessionKeyPtr, sessionKeyLength); + if (result == olm_error()) + { + const char *errorMsgPtr = olm_outbound_group_session_last_error(sessionPtr); + LOGE(" ## sessionKeyJni(): failure - session key failure Msg=%s",errorMsgPtr); + } + else + { + // update length + sessionKeyPtr[result] = static_cast<char>('\0'); + LOGD(" ## sessionKeyJni(): success - outbound group session key result=%lu sessionKey=%s",result, (char*)sessionKeyPtr); + returnValueStr = env->NewStringUTF((const char*)sessionKeyPtr); + } - LOGD("## sessionIdentifierJni(): success - result=%lu sessionId=%s",result, (char*)sessionIdPtr); - returnValueStr = env->NewStringUTF((const char*)sessionIdPtr); + // free alloc + free(sessionKeyPtr); } - free(sessionIdPtr); } return returnValueStr; } -JNIEXPORT jstring OLM_INBOUND_GROUP_SESSION_FUNC_DEF(decryptMessageJni)(JNIEnv *env, jobject thiz, jstring aEncryptedMsg) + +JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(encryptMessageJni)(JNIEnv *env, jobject thiz, jstring aClearMsg) { - jstring decryptedMsgRetValue = 0; - OlmInboundGroupSession *sessionPtr = NULL; - const char *encryptedMsgPtr = NULL; - uint8_t *plainTextMsgPtr = NULL; - uint8_t *tempEncryptedPtr = NULL; + jstring encryptedMsgRetValue = 0; + OlmOutboundGroupSession *sessionPtr = NULL; + const char *clearMsgPtr = NULL; + uint8_t *encryptedMsgPtr = NULL; - LOGD("## decryptMessageJni(): IN"); + LOGD("## encryptMessageJni(): IN"); - if(NULL == (sessionPtr = (OlmInboundGroupSession*)getInboundGroupSessionInstanceId(env,thiz))) + if(NULL == (sessionPtr = (OlmOutboundGroupSession*)getOutboundGroupSessionInstanceId(env,thiz))) { - LOGE("## decryptMessageJni(): failure - invalid inbound group session ptr=NULL"); + LOGE(" ## encryptMessageJni(): failure - invalid outbound group session ptr=NULL"); } - else if(0 == aEncryptedMsg) + else if(0 == aClearMsg) { - LOGE("## decryptMessageJni(): failure - invalid clear message"); + LOGE(" ## encryptMessageJni(): failure - invalid clear message"); } - else if(0 == (encryptedMsgPtr = env->GetStringUTFChars(aEncryptedMsg, 0))) + else if(0 == (clearMsgPtr = env->GetStringUTFChars(aClearMsg, 0))) { - LOGE("## decryptMessageJni(): failure - encrypted message JNI allocation OOM"); + LOGE(" ## encryptMessageJni(): failure - clear message JNI allocation OOM"); } else { - // get encrypted message length - size_t encryptedMsgLength = (size_t)env->GetStringUTFLength(aEncryptedMsg); + // get clear message length + size_t clearMsgLength = (size_t)env->GetStringUTFLength(aClearMsg); + LOGD(" ## encryptMessageJni(): clearMsgLength=%lu",clearMsgLength); - // create a dedicated temp buffer to be used in next Olm API calls - if(NULL == (tempEncryptedPtr = static_cast<uint8_t*>(malloc(encryptedMsgLength*sizeof(uint8_t))))) + // compute max encrypted length + size_t encryptedMsgLength = olm_group_encrypt_message_length(sessionPtr,clearMsgLength); + if(NULL == (encryptedMsgPtr = (uint8_t*)malloc(encryptedMsgLength*sizeof(uint8_t)))) { - LOGE("## decryptMessageJni(): failure - tempEncryptedPtr allocation OOM"); + LOGE("## encryptMessageJni(): failure - encryptedMsgPtr buffer OOM"); } else { - memcpy(tempEncryptedPtr, encryptedMsgPtr, encryptedMsgLength); - LOGD("## decryptMessageJni(): encryptedMsgLength=%lu encryptedMsg=%s",encryptedMsgLength,encryptedMsgPtr); - - // get max plaintext length - size_t maxPlainTextLength = olm_group_decrypt_max_plaintext_length(sessionPtr, - tempEncryptedPtr, - encryptedMsgLength); - if(maxPlainTextLength == olm_error()) + LOGD(" ## encryptMessageJni(): estimated encryptedMsgLength=%lu",encryptedMsgLength); + + size_t decryptedLength = olm_group_encrypt(sessionPtr, + (uint8_t*)clearMsgPtr, + clearMsgLength, + encryptedMsgPtr, + encryptedMsgLength); + if(decryptedLength == olm_error()) { - const char *errorMsgPtr = olm_inbound_group_session_last_error(sessionPtr); - LOGE("## decryptMessageJni(): failure - olm_group_decrypt_max_plaintext_length Msg=%s",errorMsgPtr); + const char *errorMsgPtr = olm_outbound_group_session_last_error(sessionPtr); + LOGE(" ## encryptMessageJni(): failure - olm_group_decrypt Msg=%s",errorMsgPtr); } else { - LOGD("## decryptMessageJni(): maxPlaintextLength=%lu",maxPlainTextLength); - - // allocate output decrypted message - plainTextMsgPtr = static_cast<uint8_t*>(malloc(maxPlainTextLength*sizeof(uint8_t))); - - // decrypt, but before reload encrypted buffer (previous one was destroyed) - memcpy(tempEncryptedPtr, encryptedMsgPtr, encryptedMsgLength); - size_t plaintextLength = olm_group_decrypt(sessionPtr, - tempEncryptedPtr, - encryptedMsgLength, - plainTextMsgPtr, - maxPlainTextLength); - if(plaintextLength == olm_error()) - { - const char *errorMsgPtr = olm_inbound_group_session_last_error(sessionPtr); - LOGE("## decryptMessageJni(): failure - olm_group_decrypt Msg=%s",errorMsgPtr); - } - else - { - // update decrypted buffer size - plainTextMsgPtr[plaintextLength] = static_cast<char>('\0'); - - LOGD("## decryptMessageJni(): decrypted returnedLg=%lu plainTextMsgPtr=%s",plaintextLength, (char*)plainTextMsgPtr); - decryptedMsgRetValue = env->NewStringUTF((const char*)plainTextMsgPtr); - } + // update decrypted buffer size + encryptedMsgPtr[decryptedLength] = static_cast<char>('\0'); + + LOGD(" ## encryptMessageJni(): decrypted returnedLg=%lu plainTextMsgPtr=%s",decryptedLength, (char*)encryptedMsgPtr); + encryptedMsgRetValue = env->NewStringUTF((const char*)encryptedMsgPtr); } } - } + } // free alloc - if(NULL != encryptedMsgPtr) + if(NULL != clearMsgPtr) { - env->ReleaseStringUTFChars(aEncryptedMsg, encryptedMsgPtr); + env->ReleaseStringUTFChars(aClearMsg, clearMsgPtr); } - if(NULL != tempEncryptedPtr) - { - free(tempEncryptedPtr); - } - - if(NULL != plainTextMsgPtr) + if(NULL != encryptedMsgPtr) { - free(plainTextMsgPtr); + free(encryptedMsgPtr); } - return decryptedMsgRetValue; + return encryptedMsgRetValue; } diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_outbound_group_session.h b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_outbound_group_session.h index 1270dc2..6e264aa 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_outbound_group_session.h +++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_outbound_group_session.h @@ -31,9 +31,12 @@ extern "C" { JNIEXPORT void OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(releaseSessionJni)(JNIEnv *env, jobject thiz); JNIEXPORT jlong OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(initNewSessionJni)(JNIEnv *env, jobject thiz); -JNIEXPORT jint OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(initOutboundGroupSessionJni)(JNIEnv *env, jobject thiz, jstring aSessionKey); +JNIEXPORT jint OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(initOutboundGroupSessionJni)(JNIEnv *env, jobject thiz); JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(sessionIdentifierJni)(JNIEnv *env, jobject thiz); -JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(decryptMessageJni)(JNIEnv *env, jobject thiz, jstring aEncryptedMsg); +JNIEXPORT jint OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(messageIndexJni)(JNIEnv *env, jobject thiz); +JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(sessionKeyJni)(JNIEnv *env, jobject thiz); + +JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(encryptMessageJni)(JNIEnv *env, jobject thiz, jstring aClearMsgPtr); #ifdef __cplusplus diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_session.cpp b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_session.cpp index 435540c..5911591 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_session.cpp +++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_session.cpp @@ -15,7 +15,6 @@ */ #include "olm_session.h" -#include "olm_utility.h" /** @@ -120,6 +119,7 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(initOutboundSessionJni)(JNIEnv *env, jobject else { // allocate random buffer size_t randomSize = olm_create_outbound_session_random_length(sessionPtr); + LOGD("## initOutboundSessionJni(): randomSize=%lu",randomSize); if((0!=randomSize) && !setRandomInBuffer(&randomBuffPtr, randomSize)) { LOGE("## initOutboundSessionJni(): failure - random buffer init"); @@ -485,7 +485,7 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(encryptMessageJni)(JNIEnv *env, jobject thiz // Note: olm_encrypt_random_length() can return 0, which means // it just does not need new random data to encrypt a new message size_t randomLength = olm_encrypt_random_length(sessionPtr); - + LOGD("## encryptMessageJni(): randomLength=%lu", randomLength); if((0!=randomLength) && !setRandomInBuffer(&randomBuffPtr, randomLength)) { LOGE("## encryptMessageJni(): failure - random buffer init"); |