diff options
Diffstat (limited to 'android/olm-sdk/src')
5 files changed, 361 insertions, 13 deletions
diff --git a/android/olm-sdk/src/androidTest/java/org/matrix/olm/OlmGroupSessionTest.java b/android/olm-sdk/src/androidTest/java/org/matrix/olm/OlmGroupSessionTest.java index 9be6375..69eb0e8 100644 --- a/android/olm-sdk/src/androidTest/java/org/matrix/olm/OlmGroupSessionTest.java +++ b/android/olm-sdk/src/androidTest/java/org/matrix/olm/OlmGroupSessionTest.java @@ -521,5 +521,107 @@ public class OlmGroupSessionTest { assertTrue(0!=EXPECTED_ERROR_MESSAGE.length()); assertTrue(EXPECTED_ERROR_MESSAGE.equals(exceptionMessage)); } + + + /** + * Test the import/export functions.<br> + **/ + @Test + public void test20TestInboundGroupSessionImportExport() { + + String sessionKey = "AgAAAAAwMTIzNDU2Nzg5QUJERUYwMTIzNDU2Nzg5QUJDREVGMDEyMzQ1Njc4OUFCREVGM" + + "DEyMzQ1Njc4OUFCQ0RFRjAxMjM0NTY3ODlBQkRFRjAxMjM0NTY3ODlBQkNERUYwMTIzND" + + "U2Nzg5QUJERUYwMTIzNDU2Nzg5QUJDREVGMDEyMw0bdg1BDq4Px/slBow06q8n/B9WBfw" + + "WYyNOB8DlUmXGGwrFmaSb9bR/eY8xgERrxmP07hFmD9uqA2p8PMHdnV5ysmgufE6oLZ5+" + + "8/mWQOW3VVTnDIlnwd8oHUYRuk8TCQ"; + + String message = "AwgAEhAcbh6UpbByoyZxufQ+h2B+8XHMjhR69G8F4+qjMaFlnIXusJZX3r8LnRORG9T3D" + + "XFdbVuvIWrLyRfm4i8QRbe8VPwGRFG57B1CtmxanuP8bHtnnYqlwPsD"; + + + OlmInboundGroupSession inboundGroupSession = null; + + try { + inboundGroupSession = new OlmInboundGroupSession(sessionKey); + } catch (Exception e) { + assertTrue("OlmInboundGroupSession failed " + e.getMessage(), false); + } + + boolean isVerified = false; + + try { + isVerified = inboundGroupSession.isVerified(); + } catch (Exception e) { + assertTrue("isVerified failed " + e.getMessage(), false); + } + + assertTrue(isVerified); + + OlmInboundGroupSession.DecryptMessageResult result = null; + + try { + result = inboundGroupSession.decryptMessage(message); + } catch (Exception e) { + assertTrue("decryptMessage failed " + e.getMessage(), false); + } + + assertTrue(TextUtils.equals(result.mDecryptedMessage, "Message")); + assertTrue(0 == result.mIndex); + + String export = null; + + try { + export = inboundGroupSession.export(0); + } catch (Exception e) { + assertTrue("export failed " + e.getMessage(), false); + } + assertTrue(!TextUtils.isEmpty(export)); + + long index = -1; + try { + index = inboundGroupSession.getFirstKnownIndex(); + } catch (Exception e) { + assertTrue("getFirstKnownIndex failed " + e.getMessage(), false); + } + assertTrue(index >=0); + + inboundGroupSession.releaseSession(); + inboundGroupSession = null; + + OlmInboundGroupSession inboundGroupSession2 = null; + + try { + inboundGroupSession2 = inboundGroupSession.importSession(export); + } catch (Exception e) { + assertTrue("OlmInboundGroupSession failed " + e.getMessage(), false); + } + + try { + isVerified = inboundGroupSession2.isVerified(); + } catch (Exception e) { + assertTrue("isVerified failed " + e.getMessage(), false); + } + + assertFalse(isVerified); + + result = null; + try { + result = inboundGroupSession2.decryptMessage(message); + } catch (Exception e) { + assertTrue("decryptMessage failed " + e.getMessage(), false); + } + + assertTrue(TextUtils.equals(result.mDecryptedMessage, "Message")); + assertTrue(0 == result.mIndex); + + try { + isVerified = inboundGroupSession2.isVerified(); + } catch (Exception e) { + assertTrue("isVerified failed " + e.getMessage(), false); + } + + assertTrue(isVerified); + inboundGroupSession2.releaseSession(); + } } diff --git a/android/olm-sdk/src/main/java/org/matrix/olm/OlmException.java b/android/olm-sdk/src/main/java/org/matrix/olm/OlmException.java index b0b1a6a..33ac49e 100644 --- a/android/olm-sdk/src/main/java/org/matrix/olm/OlmException.java +++ b/android/olm-sdk/src/main/java/org/matrix/olm/OlmException.java @@ -40,6 +40,9 @@ public class OlmException extends IOException { public static final int EXCEPTION_CODE_INIT_INBOUND_GROUP_SESSION = 201; public static final int EXCEPTION_CODE_INBOUND_GROUP_SESSION_IDENTIFIER = 202; public static final int EXCEPTION_CODE_INBOUND_GROUP_SESSION_DECRYPT_SESSION = 203; + public static final int EXCEPTION_CODE_INBOUND_GROUP_SESSION_FIRST_KNOWN_INDEX = 204; + public static final int EXCEPTION_CODE_INBOUND_GROUP_SESSION_IS_VERIFIED = 205; + public static final int EXCEPTION_CODE_INBOUND_GROUP_SESSION_EXPORT = 206; public static final int EXCEPTION_CODE_CREATE_OUTBOUND_GROUP_SESSION = 300; public static final int EXCEPTION_CODE_INIT_OUTBOUND_GROUP_SESSION = 301; diff --git a/android/olm-sdk/src/main/java/org/matrix/olm/OlmInboundGroupSession.java b/android/olm-sdk/src/main/java/org/matrix/olm/OlmInboundGroupSession.java index 571bddb..f5173c3 100644 --- a/android/olm-sdk/src/main/java/org/matrix/olm/OlmInboundGroupSession.java +++ b/android/olm-sdk/src/main/java/org/matrix/olm/OlmInboundGroupSession.java @@ -59,12 +59,24 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri * @throws OlmException constructor failure */ public OlmInboundGroupSession(String aSessionKey) throws OlmException { + this(aSessionKey, false); + } + + /** + * 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 an outbound group session. + * @param aSessionKey session key + * @param isImported true when the session key has been retrieved from a backup + * @throws OlmException constructor failure + */ + private OlmInboundGroupSession(String aSessionKey, boolean isImported) throws OlmException { if (TextUtils.isEmpty(aSessionKey)) { Log.e(LOG_TAG, "## initInboundGroupSession(): invalid session key"); throw new OlmException(OlmException.EXCEPTION_CODE_INIT_INBOUND_GROUP_SESSION, "invalid session key"); } else { try { - mNativeId = createNewSessionJni(aSessionKey.getBytes("UTF-8")); + mNativeId = createNewSessionJni(aSessionKey.getBytes("UTF-8"), isImported); } catch (Exception e) { throw new OlmException(OlmException.EXCEPTION_CODE_INIT_INBOUND_GROUP_SESSION, e.getMessage()); } @@ -76,9 +88,20 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri * Since a C prt is returned as a jlong, special care will be taken * to make the cast (OlmInboundGroupSession* to jlong) platform independent. * @param aSessionKeyBuffer session key from an outbound session + * @param isImported true when the session key has been retrieved from a backup * @return the initialized OlmInboundGroupSession* instance or throw an exception it fails. **/ - private native long createNewSessionJni(byte[] aSessionKeyBuffer); + private native long createNewSessionJni(byte[] aSessionKeyBuffer, boolean isImported); + + /** + * Create an OlmInboundGroupSession from its exported session data. + * @param exported the exported data + * @return the created OlmException + * @throws OlmException the failure reason + */ + public static OlmInboundGroupSession importSession(String exported) throws OlmException { + return new OlmInboundGroupSession(exported, true); + } /** * Release native session and invalid its JAVA reference counter part.<br> @@ -95,7 +118,7 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri * Destroy the corresponding OLM inbound group session native object.<br> * This method must ALWAYS be called when this JAVA instance * is destroyed (ie. garbage collected) to prevent memory leak in native side. - * See {@link #createNewSessionJni(byte[])}. + * See {@link #createNewSessionJni(byte[], boolean)}. */ private native void releaseSessionJni(); @@ -129,6 +152,86 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri private native byte[] sessionIdentifierJni(); /** + * Provides the first known index. + * @return the first known index. + * @throws OlmException the failure reason + */ + public long getFirstKnownIndex() throws OlmException { + long index = 0; + + try { + index = firstKnownIndexJni(); + } catch (Exception e) { + Log.e(LOG_TAG, "## getFirstKnownIndex() failed " + e.getMessage()); + throw new OlmException(OlmException.EXCEPTION_CODE_INBOUND_GROUP_SESSION_FIRST_KNOWN_INDEX, e.getMessage()); + } + + return index; + } + + /** + * Provides the first known index. + * An exception is thrown if the operation fails. + * @return the first known index. + */ + private native long firstKnownIndexJni(); + + /** + * Tells if the session is verified. + * @return true if the session is verified + * @throws OlmException the failure reason + */ + public boolean isVerified() throws OlmException { + boolean isVerified; + + try { + isVerified = isVerifiedJni(); + } catch (Exception e) { + Log.e(LOG_TAG, "## isVerified() failed " + e.getMessage()); + throw new OlmException(OlmException.EXCEPTION_CODE_INBOUND_GROUP_SESSION_IS_VERIFIED, e.getMessage()); + } + + return isVerified; + } + + /** + * Tells if the session is verified. + * @return true if the session is verified + */ + private native boolean isVerifiedJni(); + + /** + * Export the session from a message index as String. + * @param messageIndex the message index + * @return the session as String + * @throws OlmException the failure reason + */ + public String export(long messageIndex) throws OlmException { + String result = null; + + try { + byte[] bytesBuffer = exportJni(messageIndex); + + if (null != bytesBuffer) { + result = new String(bytesBuffer, "UTF-8"); + } + } catch (Exception e) { + Log.e(LOG_TAG, "## export() failed " + e.getMessage()); + throw new OlmException(OlmException.EXCEPTION_CODE_INBOUND_GROUP_SESSION_EXPORT, e.getMessage()); + } + + return result; + } + + /** + * Exports the session as byte array from a message index + * An exception is thrown if the operation fails. + * @param messageIndex key used to encrypt the serialized session data + * @return the session saved as bytes array + */ + private native byte[] exportJni(long messageIndex); + + /** * Decrypt the message passed in parameter.<br> * In case of error, null is returned and an error message description is provided in aErrorMsg. * @param aEncryptedMsg the message to be decrypted @@ -156,7 +259,7 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri * Decrypt a message. * An exception is thrown if the operation fails. * @param aEncryptedMsg the encrypted message - * @param aDecryptMessageResult the decryptMessage informaton + * @param aDecryptMessageResult the decryptMessage information * @return the decrypted message */ private native byte[] decryptMessageJni(byte[] aEncryptedMsg, DecryptMessageResult aDecryptMessageResult); diff --git a/android/olm-sdk/src/main/jni/olm_inbound_group_session.cpp b/android/olm-sdk/src/main/jni/olm_inbound_group_session.cpp index 23910bb..114b7cd 100644 --- a/android/olm-sdk/src/main/jni/olm_inbound_group_session.cpp +++ b/android/olm-sdk/src/main/jni/olm_inbound_group_session.cpp @@ -54,9 +54,10 @@ JNIEXPORT void OLM_INBOUND_GROUP_SESSION_FUNC_DEF(releaseSessionJni)(JNIEnv *env * Since a C prt is returned as a jlong, special care will be taken * to make the cast (OlmInboundGroupSession* => jlong) platform independent. * @param aSessionKeyBuffer session key from an outbound session + * @param isImported true when the session key has been retrieved from a backup * @return the initialized OlmInboundGroupSession* instance or throw an exception it fails. **/ -JNIEXPORT jlong OLM_INBOUND_GROUP_SESSION_FUNC_DEF(createNewSessionJni)(JNIEnv *env, jobject thiz, jbyteArray aSessionKeyBuffer) +JNIEXPORT jlong OLM_INBOUND_GROUP_SESSION_FUNC_DEF(createNewSessionJni)(JNIEnv *env, jobject thiz, jbyteArray aSessionKeyBuffer, jboolean isImported) { const char* errorMessage = NULL; OlmInboundGroupSession* sessionPtr = NULL; @@ -92,7 +93,18 @@ JNIEXPORT jlong OLM_INBOUND_GROUP_SESSION_FUNC_DEF(createNewSessionJni)(JNIEnv * size_t sessionKeyLength = (size_t)env->GetArrayLength(aSessionKeyBuffer); LOGD(" ## createNewSessionJni(): sessionKeyLength=%lu", static_cast<long unsigned int>(sessionKeyLength)); - size_t sessionResult = olm_init_inbound_group_session(sessionPtr, (const uint8_t*)sessionKeyPtr, sessionKeyLength); + size_t sessionResult; + + if (JNI_FALSE == isImported) + { + LOGD(" ## createNewSessionJni(): init"); + sessionResult = olm_init_inbound_group_session(sessionPtr, (const uint8_t*)sessionKeyPtr, sessionKeyLength); + } + else + { + LOGD(" ## createNewSessionJni(): import"); + sessionResult = olm_import_inbound_group_session(sessionPtr, (const uint8_t*)sessionKeyPtr, sessionKeyLength); + } if (sessionResult == olm_error()) { @@ -112,18 +124,12 @@ JNIEXPORT jlong OLM_INBOUND_GROUP_SESSION_FUNC_DEF(createNewSessionJni)(JNIEnv * if (errorMessage) { - env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage); - } - - if (errorMessage) - { // release the allocated session if (sessionPtr) { olm_clear_inbound_group_session(sessionPtr); free(sessionPtr); } - env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage); } @@ -326,6 +332,135 @@ JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(decryptMessageJni)(JNIEn return decryptedMsgBuffer; } +/** + * Provides the first known index. + * An exception is thrown if the operation fails. + * @return the first known index + */ +JNIEXPORT jlong OLM_INBOUND_GROUP_SESSION_FUNC_DEF(firstKnownIndexJni)(JNIEnv *env, jobject thiz) +{ + const char* errorMessage = NULL; + OlmInboundGroupSession *sessionPtr = getInboundGroupSessionInstanceId(env, thiz); + long returnValue = 0; + + LOGD("## firstKnownIndexJni(): inbound group session IN"); + + if (!sessionPtr) + { + LOGE(" ## firstKnownIndexJni(): failure - invalid inbound group session instance"); + errorMessage = "invalid inbound group session instance"; + } + else + { + returnValue = olm_inbound_group_session_first_known_index(sessionPtr); + } + + if (errorMessage) + { + env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage); + } + + return returnValue; +} + +/** + * Tells if the session is verified. + * An exception is thrown if the operation fails. + * @return true if the session is verified + */ +JNIEXPORT jboolean OLM_INBOUND_GROUP_SESSION_FUNC_DEF(isVerifiedJni)(JNIEnv *env, jobject thiz) +{ + const char* errorMessage = NULL; + OlmInboundGroupSession *sessionPtr = getInboundGroupSessionInstanceId(env, thiz); + jboolean returnValue = JNI_FALSE; + + LOGD("## isVerifiedJni(): inbound group session IN"); + + if (!sessionPtr) + { + LOGE(" ## isVerifiedJni(): failure - invalid inbound group session instance"); + errorMessage = "invalid inbound group session instance"; + } + else + { + LOGE(" ## isVerifiedJni(): faaa %d", olm_inbound_group_session_is_verified(sessionPtr)); + + returnValue = (0 != olm_inbound_group_session_is_verified(sessionPtr)) ? JNI_TRUE : JNI_FALSE; + } + + if (errorMessage) + { + env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage); + } + + return returnValue; +} + +/** + * Exports the session as byte array from a message index + * An exception is thrown if the operation fails. + * @param messageIndex key used to encrypt the serialized session data + * @return the session saved as bytes array + **/ +JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(exportJni)(JNIEnv *env, jobject thiz, jlong messageIndex) { + jbyteArray exportedByteArray = 0; + const char* errorMessage = NULL; + OlmInboundGroupSession *sessionPtr = getInboundGroupSessionInstanceId(env, thiz); + + LOGD("## exportJni(): inbound group session IN"); + + if (!sessionPtr) + { + LOGE(" ## exportJni (): failure - invalid inbound group session instance"); + errorMessage = "invalid inbound group session instance"; + } + else + { + size_t length = olm_export_inbound_group_session_length(sessionPtr); + + LOGD(" ## exportJni(): length =%lu", static_cast<long unsigned int>(length)); + + void *bufferPtr = malloc(length * sizeof(uint8_t)); + + if (!bufferPtr) + { + LOGE(" ## exportJni(): failure - pickledPtr buffer OOM"); + errorMessage = "pickledPtr buffer OOM"; + } + else + { + size_t result = olm_export_inbound_group_session(sessionPtr, + (uint8_t*)bufferPtr, + length, + (long) messageIndex); + + if (result == olm_error()) + { + errorMessage = olm_inbound_group_session_last_error(sessionPtr); + LOGE(" ## exportJni(): failure - olm_export_inbound_group_session() Msg=%s", errorMessage); + } + else + { + LOGD(" ## exportJni(): success - result=%lu buffer=%.*s", static_cast<long unsigned int>(result), static_cast<int>(length), static_cast<char*>(bufferPtr)); + + exportedByteArray = env->NewByteArray(length); + env->SetByteArrayRegion(exportedByteArray, 0 , length, (jbyte*)bufferPtr); + + // clean before leaving + memset(bufferPtr, 0, length); + } + + free(bufferPtr); + } + } + + if (errorMessage) + { + env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage); + } + + return exportedByteArray; +} /** * Serialize and encrypt session instance into a base64 string.<br> diff --git a/android/olm-sdk/src/main/jni/olm_inbound_group_session.h b/android/olm-sdk/src/main/jni/olm_inbound_group_session.h index 00990dd..be4c013 100644 --- a/android/olm-sdk/src/main/jni/olm_inbound_group_session.h +++ b/android/olm-sdk/src/main/jni/olm_inbound_group_session.h @@ -30,11 +30,16 @@ extern "C" { // session creation/destruction JNIEXPORT void OLM_INBOUND_GROUP_SESSION_FUNC_DEF(releaseSessionJni)(JNIEnv *env, jobject thiz); -JNIEXPORT jlong OLM_INBOUND_GROUP_SESSION_FUNC_DEF(createNewSessionJni)(JNIEnv *env, jobject thiz, jbyteArray aSessionKeyBuffer); +JNIEXPORT jlong OLM_INBOUND_GROUP_SESSION_FUNC_DEF(createNewSessionJni)(JNIEnv *env, jobject thiz, jbyteArray aSessionKeyBuffer, jboolean isImported); JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(sessionIdentifierJni)(JNIEnv *env, jobject thiz); JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(decryptMessageJni)(JNIEnv *env, jobject thiz, jbyteArray aEncryptedMsg, jobject aDecryptIndex); +JNIEXPORT jlong OLM_INBOUND_GROUP_SESSION_FUNC_DEF(firstKnownIndexJni)(JNIEnv *env, jobject thiz); +JNIEXPORT jboolean OLM_INBOUND_GROUP_SESSION_FUNC_DEF(isVerifiedJni)(JNIEnv *env, jobject thiz); + +JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(exportJni)(JNIEnv *env, jobject thiz, jlong messageIndex); + // serialization JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKey); JNIEXPORT jlong OLM_INBOUND_GROUP_SESSION_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedData, jbyteArray aKey); |