diff options
Diffstat (limited to 'java/android/OlmLibSdk/olm-sdk')
14 files changed, 500 insertions, 542 deletions
diff --git a/java/android/OlmLibSdk/olm-sdk/src/androidTest/java/org/matrix/olm/OlmSessionTest.java b/java/android/OlmLibSdk/olm-sdk/src/androidTest/java/org/matrix/olm/OlmSessionTest.java index 6c888d0..675d72c 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/androidTest/java/org/matrix/olm/OlmSessionTest.java +++ b/java/android/OlmLibSdk/olm-sdk/src/androidTest/java/org/matrix/olm/OlmSessionTest.java @@ -112,7 +112,7 @@ public class OlmSessionTest { assertTrue(0!=aliceSession.getOlmSessionId()); // CREATE ALICE OUTBOUND SESSION and encrypt message to bob - assertNotNull(aliceSession.initOutboundSessionWithAccount(aliceAccount, bobIdentityKey, bobOneTimeKey)); + assertNotNull(aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey)); String clearMsg = "Heloo bob , this is alice!"; OlmMessage encryptedMsgToBob = aliceSession.encryptMessage(clearMsg); assertNotNull(encryptedMsgToBob); @@ -129,7 +129,7 @@ public class OlmSessionTest { assertTrue(0!=bobSession.getOlmSessionId()); try { - bobSession.initInboundSessionWithAccount(bobAccount, encryptedMsgToBob.mCipherText); + bobSession.initInboundSession(bobAccount, encryptedMsgToBob.mCipherText); } catch (Exception e) { assertTrue("initInboundSessionWithAccount failed " + e.getMessage(), false); } @@ -211,7 +211,7 @@ public class OlmSessionTest { assertTrue(0!=aliceSession.getOlmSessionId()); // CREATE ALICE OUTBOUND SESSION and encrypt message to bob - assertNotNull(aliceSession.initOutboundSessionWithAccount(aliceAccount, bobIdentityKey, bobOneTimeKey)); + assertNotNull(aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey)); String helloClearMsg = "Hello I'm Alice!"; OlmMessage encryptedAliceToBobMsg1 = aliceSession.encryptMessage(helloClearMsg); @@ -229,7 +229,7 @@ public class OlmSessionTest { assertTrue(0!=bobSession.getOlmSessionId()); try { - bobSession.initInboundSessionWithAccount(bobAccount, encryptedAliceToBobMsg1.mCipherText); + bobSession.initInboundSession(bobAccount, encryptedAliceToBobMsg1.mCipherText); } catch (Exception e) { assertTrue("initInboundSessionWithAccount failed " + e.getMessage(), false); } @@ -381,7 +381,7 @@ public class OlmSessionTest { String bobOneTimeKey1 = TestHelper.getOneTimeKey(bobOneTimeKeys, 1); // create alice inbound session for bob - assertTrue(0==aliceSession.initOutboundSessionWithAccount(aliceAccount, bobIdentityKey, bobOneTimeKey1)); + assertTrue(0==aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey1)); String aliceClearMsg = "hello helooo to bob!"; OlmMessage encryptedAliceToBobMsg1 = aliceSession.encryptMessage(aliceClearMsg); @@ -389,7 +389,7 @@ public class OlmSessionTest { // init bob session with alice PRE KEY try { - bobSession.initInboundSessionWithAccount(bobAccount, encryptedAliceToBobMsg1.mCipherText); + bobSession.initInboundSession(bobAccount, encryptedAliceToBobMsg1.mCipherText); } catch (Exception e) { assertTrue("initInboundSessionWithAccount failed " + e.getMessage(), false); } @@ -463,7 +463,7 @@ public class OlmSessionTest { assertTrue(0!=aliceSession.getOlmSessionId()); // CREATE ALICE OUTBOUND SESSION and encrypt message to bob - assertNotNull(aliceSession.initOutboundSessionWithAccount(aliceAccount, bobIdentityKey, bobOneTimeKey)); + assertNotNull(aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey)); String helloClearMsg = "Hello I'm Alice!"; OlmMessage encryptedAliceToBobMsg1 = aliceSession.encryptMessage(helloClearMsg); @@ -481,7 +481,7 @@ public class OlmSessionTest { // init bob session with alice PRE KEY try { - bobSession.initInboundSessionWithAccount(bobAccount, encryptedAliceToBobMsg1.mCipherText); + bobSession.initInboundSession(bobAccount, encryptedAliceToBobMsg1.mCipherText); } catch (Exception e) { assertTrue("initInboundSessionWithAccount failed " + e.getMessage(), false); } @@ -608,13 +608,13 @@ public class OlmSessionTest { } // SANITY CHECK TESTS FOR: initOutboundSessionWithAccount() - assertTrue(-1==aliceSession.initOutboundSessionWithAccount(null, bobIdentityKey, bobOneTimeKey)); - assertTrue(-1==aliceSession.initOutboundSessionWithAccount(aliceAccount, null, bobOneTimeKey)); - assertTrue(-1==aliceSession.initOutboundSessionWithAccount(aliceAccount, bobIdentityKey, null)); - assertTrue(-1==aliceSession.initOutboundSessionWithAccount(null, null, null)); + assertTrue(-1==aliceSession.initOutboundSession(null, bobIdentityKey, bobOneTimeKey)); + assertTrue(-1==aliceSession.initOutboundSession(aliceAccount, null, bobOneTimeKey)); + assertTrue(-1==aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, null)); + assertTrue(-1==aliceSession.initOutboundSession(null, null, null)); // init properly - assertTrue(0==aliceSession.initOutboundSessionWithAccount(aliceAccount, bobIdentityKey, bobOneTimeKey)); + assertTrue(0==aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey)); // SANITY CHECK TESTS FOR: encryptMessage() assertTrue(null==aliceSession.encryptMessage(null)); @@ -629,7 +629,7 @@ public class OlmSessionTest { bobSession = new OlmSession(); String errorMessage = null; try { - bobSession.initInboundSessionWithAccount(null, encryptedMsgToBob.mCipherText); + bobSession.initInboundSession(null, encryptedMsgToBob.mCipherText); } catch (Exception e) { errorMessage = e.getMessage(); } @@ -638,7 +638,7 @@ public class OlmSessionTest { errorMessage = null; try { - bobSession.initInboundSessionWithAccount(bobAccount, null); + bobSession.initInboundSession(bobAccount, null); } catch (Exception e) { errorMessage = e.getMessage(); } @@ -647,7 +647,7 @@ public class OlmSessionTest { errorMessage = null; try { - bobSession.initInboundSessionWithAccount(bobAccount, INVALID_PRE_KEY); + bobSession.initInboundSession(bobAccount, INVALID_PRE_KEY); } catch (Exception e) { errorMessage = e.getMessage(); } @@ -657,7 +657,7 @@ public class OlmSessionTest { // init properly errorMessage = null; try { - bobSession.initInboundSessionWithAccount(bobAccount, encryptedMsgToBob.mCipherText); + bobSession.initInboundSession(bobAccount, encryptedMsgToBob.mCipherText); } catch (Exception e) { errorMessage = e.getMessage(); } diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/CommonSerializeUtils.java b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/CommonSerializeUtils.java index c3f9757..72437e4 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/CommonSerializeUtils.java +++ b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/CommonSerializeUtils.java @@ -35,7 +35,7 @@ abstract class CommonSerializeUtils { * @param aOutStream output stream for serializing * @throws IOException exception */ - protected void serializeObject(ObjectOutputStream aOutStream) throws IOException { + protected void serialize(ObjectOutputStream aOutStream) throws IOException { aOutStream.defaultWriteObject(); // generate serialization key @@ -43,7 +43,7 @@ abstract class CommonSerializeUtils { // compute pickle string StringBuffer errorMsg = new StringBuffer(); - String pickledData = serializeDataWithKey(key, errorMsg); + String pickledData = serialize(key, errorMsg); if(null == pickledData) { throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_SERIALIZATION, String.valueOf(errorMsg)); @@ -59,33 +59,22 @@ abstract class CommonSerializeUtils { * @throws IOException exception * @throws ClassNotFoundException exception */ - protected void deserializeObject(ObjectInputStream aInStream) throws IOException, ClassNotFoundException { + protected void deserialize(ObjectInputStream aInStream) throws IOException, ClassNotFoundException { aInStream.defaultReadObject(); - StringBuffer errorMsg = new StringBuffer(); String key = (String) aInStream.readObject(); String pickledData = (String) aInStream.readObject(); - if(TextUtils.isEmpty(key)) { + if (TextUtils.isEmpty(key)) { throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_DESERIALIZATION, OlmException.EXCEPTION_MSG_INVALID_PARAMS_DESERIALIZATION+" key"); - - } else if(TextUtils.isEmpty(pickledData)) { + } else if (TextUtils.isEmpty(pickledData)) { throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_DESERIALIZATION, OlmException.EXCEPTION_MSG_INVALID_PARAMS_DESERIALIZATION+" pickle"); - - } else if(!createNewObjectFromSerialization()) { - throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_DESERIALIZATION, OlmException.EXCEPTION_MSG_INIT_NEW_ACCOUNT_DESERIALIZATION); - - } else if(!initWithSerializedData(pickledData, key, errorMsg)) { - releaseObjectFromSerialization(); // prevent memory leak - throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_DESERIALIZATION, String.valueOf(errorMsg)); - - } else { - Log.d(LOG_TAG,"## readObject(): success"); } + + deserialize(pickledData, key); + Log.d(LOG_TAG,"## deserializeObject(): success"); } - protected abstract String serializeDataWithKey(String aKey, StringBuffer aErrorMsg); - protected abstract boolean initWithSerializedData(String aSerializedData, String aKey, StringBuffer aErrorMsg); - protected abstract boolean createNewObjectFromSerialization(); - protected abstract void releaseObjectFromSerialization(); + protected abstract String serialize(String aKey, StringBuffer aErrorMsg); + protected abstract void deserialize(String aSerializedData, String aKey) throws IOException; } diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmAccount.java b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmAccount.java index 1e41fa1..649085e 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmAccount.java +++ b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmAccount.java @@ -69,105 +69,6 @@ public class OlmAccount extends CommonSerializeUtils implements Serializable { } /** - * Kick off the serialization mechanism. - * @param aOutStream output stream for serializing - * @throws IOException exception - */ - private void writeObject(ObjectOutputStream aOutStream) throws IOException { - serializeObject(aOutStream); - } - - /** - * Kick off the deserialization mechanism. - * @param aInStream input stream - * @throws IOException exception - * @throws ClassNotFoundException exception - */ - private void readObject(ObjectInputStream aInStream) throws IOException, ClassNotFoundException { - deserializeObject(aInStream); - } - - @Override - protected boolean createNewObjectFromSerialization() { - return createNewAccount(); - } - - @Override - protected void releaseObjectFromSerialization() { - releaseAccount(); - } - - /** - * Return an account as a base64 string.<br> - * The account is serialized and encrypted with aKey. - * In case of failure, an error human readable - * description is provide in aErrorMsg. - * @param aKey encryption key - * @param aErrorMsg error message description - * @return pickled base64 string if operation succeed, null otherwise - */ - @Override - protected String serializeDataWithKey(String aKey, StringBuffer aErrorMsg) { - String pickleRetValue = null; - - // sanity check - if(null == aErrorMsg) { - Log.e(LOG_TAG,"## serializeDataWithKey(): invalid parameter - aErrorMsg=null"); - } else if(TextUtils.isEmpty(aKey)) { - aErrorMsg.append("Invalid input parameters in serializeDataWithKey()"); - } else { - aErrorMsg.setLength(0); - try { - pickleRetValue = new String(serializeDataWithKeyJni(aKey.getBytes("UTF-8"), aErrorMsg), "UTF-8"); - } catch (Exception e) { - Log.e(LOG_TAG, "## serializeDataWithKey() failed " + e.getMessage()); - aErrorMsg.append(e.getMessage()); - } - } - - return pickleRetValue; - } - private native byte[] serializeDataWithKeyJni(byte[] aKey, StringBuffer aErrorMsg); - - - /** - * Loads an account from a pickled base64 string.<br> - * See {@link #serializeDataWithKey(String, StringBuffer)} - * @param aSerializedData pickled account in a base64 string format - * @param aKey key used to encrypted - * @param aErrorMsg error message description - * @return true if operation succeed, false otherwise - */ - @Override - protected boolean initWithSerializedData(String aSerializedData, String aKey, StringBuffer aErrorMsg) { - boolean retCode = false; - String jniError; - - if (null == aErrorMsg) { - Log.e(LOG_TAG, "## initWithSerializedData(): invalid input error parameter"); - } else { - aErrorMsg.setLength(0); - - try { - if (TextUtils.isEmpty(aSerializedData) || TextUtils.isEmpty(aKey)) { - Log.e(LOG_TAG, "## initWithSerializedData(): invalid input parameters"); - } else if (null == (jniError = initWithSerializedDataJni(aSerializedData.getBytes("UTF-8"), aKey.getBytes("UTF-8")))) { - retCode = true; - } else { - aErrorMsg.append(jniError); - } - } catch (Exception e) { - Log.e(LOG_TAG, "## initWithSerializedData() failed " + e.getMessage()); - aErrorMsg.append(e.getMessage()); - } - } - - return retCode; - } - - private native String initWithSerializedDataJni(byte[] aSerializedDataBuffer, byte[] aKeyBuffer); - - /** * Getter on the account ID. * @return native account ID */ @@ -230,6 +131,14 @@ public class OlmAccount extends CommonSerializeUtils implements Serializable { private native long createNewAccountJni(); /** + * Return true the object resources have been released.<br> + * @return true the object resources have been released + */ + public boolean isReleased() { + return (0 == mNativeId); + } + + /** * Return the identity keys (identity and fingerprint keys) in a dictionary.<br> * Public API for {@link #identityKeysJni()}.<br> * Ex:<tt> @@ -394,14 +303,6 @@ public class OlmAccount extends CommonSerializeUtils implements Serializable { private native byte[] signMessageJni(byte[] aMessage); /** - * Return true the object resources have been released.<br> - * @return true the object resources have been released - */ - public boolean isReleased() { - return (0 == mNativeId); - } - - /** * Build a string-string dictionary from a jsonObject.<br> * @param jsonObject the object to parse * @return the map @@ -461,4 +362,95 @@ public class OlmAccount extends CommonSerializeUtils implements Serializable { return null; } + + //============================================================================================================== + // Serialization management + //============================================================================================================== + + /** + * Kick off the serialization mechanism. + * @param aOutStream output stream for serializing + * @throws IOException exception + */ + private void writeObject(ObjectOutputStream aOutStream) throws IOException { + serialize(aOutStream); + } + + /** + * Kick off the deserialization mechanism. + * @param aInStream input stream + * @throws IOException exception + * @throws ClassNotFoundException exception + */ + private void readObject(ObjectInputStream aInStream) throws IOException, ClassNotFoundException { + deserialize(aInStream); + } + + /** + * Return an account as a base64 string.<br> + * The account is serialized and encrypted with aKey. + * In case of failure, an error human readable + * description is provide in aErrorMsg. + * @param aKey encryption key + * @param aErrorMsg error message description + * @return pickled base64 string if operation succeed, null otherwise + */ + @Override + protected String serialize(String aKey, StringBuffer aErrorMsg) { + String pickleRetValue = null; + + // sanity check + if(null == aErrorMsg) { + Log.e(LOG_TAG,"## serialize(): invalid parameter - aErrorMsg=null"); + } else if(TextUtils.isEmpty(aKey)) { + aErrorMsg.append("Invalid input parameters in serializeDataWithKey()"); + } else { + aErrorMsg.setLength(0); + try { + pickleRetValue = new String(serializeJni(aKey.getBytes("UTF-8"), aErrorMsg), "UTF-8"); + } catch (Exception e) { + Log.e(LOG_TAG, "## serialize() failed " + e.getMessage()); + aErrorMsg.append(e.getMessage()); + } + } + + return pickleRetValue; + } + + private native byte[] serializeJni(byte[] aKey, StringBuffer aErrorMsg); + + /** + * Loads an account from a pickled base64 string.<br> + * See {@link #serialize(String, StringBuffer)} + * @param aSerializedData pickled account in a base64 string format + * @param aKey key used to encrypted + */ + @Override + protected void deserialize(String aSerializedData, String aKey) throws IOException { + if (!createNewAccount()) { + throw new OlmException(OlmException.EXCEPTION_CODE_INIT_ACCOUNT_CREATION,OlmException.EXCEPTION_MSG_INIT_ACCOUNT_CREATION); + } + + StringBuffer errorMsg = new StringBuffer(); + + try { + String jniError; + if (TextUtils.isEmpty(aSerializedData) || TextUtils.isEmpty(aKey)) { + Log.e(LOG_TAG, "## deserialize(): invalid input parameters"); + errorMsg.append("invalid input parameters"); + } else if (null != (jniError = deserializeJni(aSerializedData.getBytes("UTF-8"), aKey.getBytes("UTF-8")))) { + errorMsg.append(jniError); + } + } catch (Exception e) { + Log.e(LOG_TAG, "## deserialize() failed " + e.getMessage()); + errorMsg.append(e.getMessage()); + } + + if (errorMsg.length() > 0) { + releaseAccount(); + throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_DESERIALIZATION, String.valueOf(errorMsg)); + } + } + + private native String deserializeJni(byte[] aSerializedDataBuffer, byte[] aKeyBuffer); } 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 bfd50fb..68878c7 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 @@ -65,13 +65,13 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri * 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 - * See {@link #createNewSession()} and {@link #initInboundGroupSessionWithSessionKey(String)} + * See {@link #createNewSession()} and {@link #initInboundGroupSession(String)} * @param aSessionKey session key * @throws OlmException constructor failure */ public OlmInboundGroupSession(String aSessionKey) throws OlmException { if(createNewSession()) { - if (0 != initInboundGroupSessionWithSessionKey(aSessionKey)) { + if (0 != initInboundGroupSession(aSessionKey)) { releaseSession();// prevent memory leak before throwing throw new OlmException(OlmException.EXCEPTION_CODE_INIT_INBOUND_GROUP_SESSION,OlmException.EXCEPTION_MSG_INIT_INBOUND_GROUP_SESSION); } @@ -115,29 +115,37 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri private native long createNewSessionJni(); /** + * Return true the object resources have been released.<br> + * @return true the object resources have been released + */ + public boolean isReleased() { + return (0 == mNativeId); + } + + /** * Start a new inbound group session.<br> * The session key parameter is retrieved from an outbound group session * see {@link OlmOutboundGroupSession#sessionKey()} * @param aSessionKey session key * @return 0 if operation succeed, -1 otherwise */ - private int initInboundGroupSessionWithSessionKey(String aSessionKey) { + private int initInboundGroupSession(String aSessionKey) { int retCode = -1; if(TextUtils.isEmpty(aSessionKey)){ - Log.e(LOG_TAG, "## initInboundGroupSessionWithSessionKey(): invalid session key"); + Log.e(LOG_TAG, "## initInboundGroupSession(): invalid session key"); } else { try { - retCode = initInboundGroupSessionWithSessionKeyJni(aSessionKey.getBytes("UTF-8")); + retCode = initInboundGroupSessionJni(aSessionKey.getBytes("UTF-8")); } catch (Exception e) { - Log.e(LOG_TAG, "## initInboundGroupSessionWithSessionKey() failed " + e.getMessage()); + Log.e(LOG_TAG, "## initInboundGroupSession() failed " + e.getMessage()); } } return retCode; } - private native int initInboundGroupSessionWithSessionKeyJni(byte[] aSessionKeyBuffer); + private native int initInboundGroupSessionJni(byte[] aSessionKeyBuffer); /** * Retrieve the base64-encoded identifier for this inbound group session. @@ -187,13 +195,17 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri private native byte[] decryptMessageJni(byte[] aEncryptedMsg, DecryptMessageResult aDecryptMessageResult, StringBuffer aErrorMsg); + //============================================================================================================== + // Serialization management + //============================================================================================================== + /** * Kick off the serialization mechanism. * @param aOutStream output stream for serializing * @throws IOException exception */ private void writeObject(ObjectOutputStream aOutStream) throws IOException { - serializeObject(aOutStream); + serialize(aOutStream); } /** @@ -203,17 +215,7 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri * @throws ClassNotFoundException exception */ private void readObject(ObjectInputStream aInStream) throws IOException, ClassNotFoundException { - deserializeObject(aInStream); - } - - @Override - protected boolean createNewObjectFromSerialization() { - return createNewSession(); - } - - @Override - protected void releaseObjectFromSerialization() { - releaseSession(); + deserialize(aInStream); } /** @@ -226,20 +228,20 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri * @return pickled base64 string if operation succeed, null otherwise */ @Override - protected String serializeDataWithKey(String aKey, StringBuffer aErrorMsg) { + protected String serialize(String aKey, StringBuffer aErrorMsg) { String pickleRetValue = null; // sanity check if(null == aErrorMsg) { - Log.e(LOG_TAG,"## serializeDataWithKey(): invalid parameter - aErrorMsg=null"); + Log.e(LOG_TAG,"## serialize(): invalid parameter - aErrorMsg=null"); } else if(TextUtils.isEmpty(aKey)) { - aErrorMsg.append("Invalid input parameters in serializeDataWithKey()"); + aErrorMsg.append("Invalid input parameters in serialize()"); } else { aErrorMsg.setLength(0); try { - pickleRetValue = new String(serializeDataWithKeyJni(aKey.getBytes("UTF-8"), aErrorMsg), "UTF-8"); + pickleRetValue = new String(serializeJni(aKey.getBytes("UTF-8"), aErrorMsg), "UTF-8"); } catch (Exception e) { - Log.e(LOG_TAG, "## serializeDataWithKey() failed " + e.getMessage()); + Log.e(LOG_TAG, "## serialize() failed " + e.getMessage()); aErrorMsg.append(e.getMessage()); } } @@ -247,60 +249,51 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri return pickleRetValue; } /** - * JNI counter part of {@link #serializeDataWithKey(String, StringBuffer)}. + * JNI counter part of {@link #serialize(String, StringBuffer)}. * @param aKey encryption key * @param aErrorMsg error message description * @return pickled base64 string if operation succeed, null otherwise */ - private native byte[] serializeDataWithKeyJni(byte[] aKey, StringBuffer aErrorMsg); - + private native byte[] serializeJni(byte[] aKey, StringBuffer aErrorMsg); /** - * Load an inbound group session from a pickled base64 string.<br> - * See {@link #serializeDataWithKey(String, StringBuffer)} - * @param aSerializedData pickled inbound group session in a base64 string format - * @param aKey encrypting key used in {@link #serializeDataWithKey(String, StringBuffer)} - * @param aErrorMsg error message description - * @return true if operation succeed, false otherwise + * Loads an account from a pickled base64 string.<br> + * See {@link #serialize(String, StringBuffer)} + * @param aSerializedData pickled account in a base64 string format + * @param aKey key used to encrypted */ @Override - protected boolean initWithSerializedData(String aSerializedData, String aKey, StringBuffer aErrorMsg) { - boolean retCode = false; - String jniError; + protected void deserialize(String aSerializedData, String aKey) throws IOException { + if (!createNewSession()) { + throw new OlmException(OlmException.EXCEPTION_CODE_INIT_ACCOUNT_CREATION,OlmException.EXCEPTION_MSG_INIT_ACCOUNT_CREATION); + } - if(null == aErrorMsg) { - Log.e(LOG_TAG, "## initWithSerializedData(): invalid input error parameter"); - } else { - aErrorMsg.setLength(0); - try { - if (TextUtils.isEmpty(aSerializedData) || TextUtils.isEmpty(aKey)) { - Log.e(LOG_TAG, "## initWithSerializedData(): invalid input parameters"); - } else if (null == (jniError = initWithSerializedDataJni(aSerializedData.getBytes("UTF-8"), aKey.getBytes("UTF-8")))) { - retCode = true; - } else { - aErrorMsg.append(jniError); - } - } catch (Exception e) { - Log.e(LOG_TAG, "## initWithSerializedData() failed " + e.getMessage()); - aErrorMsg.append(e.getMessage()); + StringBuffer errorMsg = new StringBuffer(); + + try { + String jniError; + if (TextUtils.isEmpty(aSerializedData) || TextUtils.isEmpty(aKey)) { + Log.e(LOG_TAG, "## deserialize(): invalid input parameters"); + errorMsg.append("invalid input parameters"); + } else if (null != (jniError = deserializeJni(aSerializedData.getBytes("UTF-8"), aKey.getBytes("UTF-8")))) { + errorMsg.append(jniError); } + } catch (Exception e) { + Log.e(LOG_TAG, "## deserialize() failed " + e.getMessage()); + errorMsg.append(e.getMessage()); } - return retCode; + if (errorMsg.length() > 0) { + releaseSession(); + throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_DESERIALIZATION, String.valueOf(errorMsg)); + } } + /** - * JNI counter part of {@link #initWithSerializedData(String, String, StringBuffer)}. + * JNI counter part of {@link #deserialize(String, String)}. * @param aSerializedData pickled session in a base64 string format - * @param aKey key used to encrypted in {@link #serializeDataWithKey(String, StringBuffer)} + * @param aKey key used to encrypted in {@link #serialize(String, StringBuffer)} * @return null if operation succeed, an error message if operation failed */ - private native String initWithSerializedDataJni(byte[] aSerializedData, byte[] aKey); - - /** - * Return true the object resources have been released.<br> - * @return true the object resources have been released - */ - public boolean isReleased() { - return (0 == mNativeId); - } + private native String deserializeJni(byte[] aSerializedData, byte[] aKey); } 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 b9c21ff..66a44d2 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 @@ -70,105 +70,6 @@ public class OlmOutboundGroupSession extends CommonSerializeUtils implements Ser } /** - * Kick off the serialization mechanism. - * @param aOutStream output stream for serializing - * @throws IOException exception - */ - private void writeObject(ObjectOutputStream aOutStream) throws IOException { - serializeObject(aOutStream); - } - - /** - * Kick off the deserialization mechanism. - * @param aInStream input stream - * @throws IOException exception - * @throws ClassNotFoundException exception - */ - private void readObject(ObjectInputStream aInStream) throws IOException, ClassNotFoundException { - deserializeObject(aInStream); - } - - @Override - protected boolean createNewObjectFromSerialization() { - return createNewSession(); - } - - @Override - protected void releaseObjectFromSerialization() { - releaseSession(); - } - - /** - * Return the current outbound group session as a base64 serialized string.<br> - * The session is serialized and encrypted with aKey. - * In case of failure, an error human readable - * description is provide in aErrorMsg. - * @param aKey encryption key - * @param aErrorMsg error message description - * @return pickled base64 string if operation succeed, null otherwise - */ - @Override - protected String serializeDataWithKey(String aKey, StringBuffer aErrorMsg) { - String pickleRetValue = null; - - // sanity check - if(null == aErrorMsg) { - Log.e(LOG_TAG,"## serializeDataWithKey(): invalid parameter - aErrorMsg=null"); - } else if(TextUtils.isEmpty(aKey)) { - aErrorMsg.append("Invalid input parameters in serializeDataWithKey()"); - } else { - aErrorMsg.setLength(0); - try { - pickleRetValue = serializeDataWithKeyJni(aKey.getBytes("UTF-8"), aErrorMsg); - } catch (Exception e) { - Log.e(LOG_TAG,"## serializeDataWithKey(): failed " + e.getMessage()); - aErrorMsg.append(e.getMessage()); - } - } - - return pickleRetValue; - } - private native String serializeDataWithKeyJni(byte[] aKey, StringBuffer aErrorMsg); - - - /** - * Load an outbound group session from a pickled base64 string.<br> - * See {@link #serializeDataWithKey(String, StringBuffer)} - * @param aSerializedData pickled outbound group session in a base64 string format - * @param aKey encrypting key used in {@link #serializeDataWithKey(String, StringBuffer)} - * @param aErrorMsg error message description - * @return true if operation succeed, false otherwise - */ - @Override - protected boolean initWithSerializedData(String aSerializedData, String aKey, StringBuffer aErrorMsg) { - boolean retCode = false; - String jniError; - - if(null == aErrorMsg) { - Log.e(LOG_TAG, "## initWithSerializedData(): invalid input error parameter"); - } else { - aErrorMsg.setLength(0); - - try { - if (TextUtils.isEmpty(aSerializedData) || TextUtils.isEmpty(aKey)) { - Log.e(LOG_TAG, "## initWithSerializedData(): invalid input parameters"); - } else if (null == (jniError = initWithSerializedDataJni(aSerializedData.getBytes("UTF-8"), aKey.getBytes("UTF-8")))) { - retCode = true; - } else { - aErrorMsg.append(jniError); - } - } catch (Exception e) { - Log.e(LOG_TAG, "## initWithSerializedData(): failed " + e.getMessage()); - aErrorMsg.append(e.getMessage()); - } - } - - return retCode; - } - private native String initWithSerializedDataJni(byte[] aSerializedData, byte[] aKey); - - - /** * Release native session and invalid its JAVA reference counter part.<br> * Public API for {@link #releaseSessionJni()}. */ @@ -204,6 +105,14 @@ public class OlmOutboundGroupSession extends CommonSerializeUtils implements Ser private native long createNewSessionJni(); /** + * Return true the object resources have been released.<br> + * @return true the object resources have been released + */ + public boolean isReleased() { + return (0 == mNativeId); + } + + /** * Start a new outbound group session.<br> * @return 0 if operation succeed, -1 otherwise */ @@ -290,11 +199,96 @@ public class OlmOutboundGroupSession extends CommonSerializeUtils implements Ser } private native byte[] encryptMessageJni(byte[] aClearMsgBuffer, StringBuffer aErrorMsg); + + //============================================================================================================== + // Serialization management + //============================================================================================================== + /** - * Return true the object resources have been released.<br> - * @return true the object resources have been released + * Kick off the serialization mechanism. + * @param aOutStream output stream for serializing + * @throws IOException exception */ - public boolean isReleased() { - return (0 == mNativeId); + private void writeObject(ObjectOutputStream aOutStream) throws IOException { + serialize(aOutStream); } + + /** + * Kick off the deserialization mechanism. + * @param aInStream input stream + * @throws IOException exception + * @throws ClassNotFoundException exception + */ + private void readObject(ObjectInputStream aInStream) throws IOException, ClassNotFoundException { + deserialize(aInStream); + } + + /** + * Return the current outbound group session as a base64 serialized string.<br> + * The session is serialized and encrypted with aKey. + * In case of failure, an error human readable + * description is provide in aErrorMsg. + * @param aKey encryption key + * @param aErrorMsg error message description + * @return pickled base64 string if operation succeed, null otherwise + */ + @Override + protected String serialize(String aKey, StringBuffer aErrorMsg) { + String pickleRetValue = null; + + // sanity check + if(null == aErrorMsg) { + Log.e(LOG_TAG,"## serialize(): invalid parameter - aErrorMsg=null"); + } else if(TextUtils.isEmpty(aKey)) { + aErrorMsg.append("Invalid input parameters in serialize()"); + } else { + aErrorMsg.setLength(0); + try { + pickleRetValue = serializeJni(aKey.getBytes("UTF-8"), aErrorMsg); + } catch (Exception e) { + Log.e(LOG_TAG,"## serialize(): failed " + e.getMessage()); + aErrorMsg.append(e.getMessage()); + } + } + + return pickleRetValue; + } + private native String serializeJni(byte[] aKey, StringBuffer aErrorMsg); + + + /** + * Loads an account from a pickled base64 string.<br> + * See {@link #serialize(String, StringBuffer)} + * @param aSerializedData pickled account in a base64 string format + * @param aKey key used to encrypted + */ + @Override + protected void deserialize(String aSerializedData, String aKey) throws IOException { + if (!createNewSession()) { + throw new OlmException(OlmException.EXCEPTION_CODE_INIT_ACCOUNT_CREATION,OlmException.EXCEPTION_MSG_INIT_ACCOUNT_CREATION); + } + + StringBuffer errorMsg = new StringBuffer(); + + try { + String jniError; + if (TextUtils.isEmpty(aSerializedData) || TextUtils.isEmpty(aKey)) { + Log.e(LOG_TAG, "## deserialize(): invalid input parameters"); + errorMsg.append("invalid input parameters"); + } else if (null != (jniError = deserializeJni(aSerializedData.getBytes("UTF-8"), aKey.getBytes("UTF-8")))) { + errorMsg.append(jniError); + } + } catch (Exception e) { + Log.e(LOG_TAG, "## deserialize() failed " + e.getMessage()); + errorMsg.append(e.getMessage()); + } + + if (errorMsg.length() > 0) { + releaseSession(); + throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_DESERIALIZATION, String.valueOf(errorMsg)); + } + } + + private native String deserializeJni(byte[] aSerializedData, byte[] aKey); + } diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmSession.java b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmSession.java index 85804a1..36a95a1 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmSession.java +++ b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmSession.java @@ -28,8 +28,8 @@ import java.io.Serializable; /** * Session class used to create Olm sessions in conjunction with {@link OlmAccount} class.<br> * Olm session is used to encrypt data between devices, especially to create Olm group sessions (see {@link OlmOutboundGroupSession} and {@link OlmInboundGroupSession}).<br> - * To establish an Olm session with Bob, Alice calls {@link #initOutboundSessionWithAccount(OlmAccount, String, String)} with Bob's identity and onetime keys. Then Alice generates an encrypted PRE_KEY message ({@link #encryptMessage(String)}) - * used by Bob to open the Olm session in his side with {@link #initOutboundSessionWithAccount(OlmAccount, String, String)}. + * To establish an Olm session with Bob, Alice calls {@link #initOutboundSession(OlmAccount, String, String)} with Bob's identity and onetime keys. Then Alice generates an encrypted PRE_KEY message ({@link #encryptMessage(String)}) + * used by Bob to open the Olm session in his side with {@link #initOutboundSession(OlmAccount, String, String)}. * From this step on, messages can be exchanged by using {@link #encryptMessage(String)} and {@link #decryptMessage(OlmMessage)}. * <br><br>Detailed implementation guide is available at <a href="http://matrix.org/docs/guides/e2e_implementation.html">Implementing End-to-End Encryption in Matrix clients</a>. */ @@ -49,104 +49,6 @@ public class OlmSession extends CommonSerializeUtils implements Serializable { } /** - * Kick off the serialization mechanism. - * @param aOutStream output stream for serializing - * @throws IOException exception - */ - private void writeObject(ObjectOutputStream aOutStream) throws IOException { - serializeObject(aOutStream); - } - - /** - * Kick off the deserialization mechanism. - * @param aInStream input stream - * @throws IOException exception - * @throws ClassNotFoundException exception - */ - private void readObject(ObjectInputStream aInStream) throws IOException, ClassNotFoundException { - deserializeObject(aInStream); - } - - @Override - protected boolean createNewObjectFromSerialization() { - return createNewSession(); - } - - @Override - protected void releaseObjectFromSerialization() { - releaseSession(); - } - - /** - * Return a session as a base64 string.<br> - * The account is serialized and encrypted with aKey. - * In case of failure, an error human readable - * description is provide in aErrorMsg. - * @param aKey encryption key - * @param aErrorMsg error message description - * @return pickled base64 string if operation succeed, null otherwise - */ - @Override - protected String serializeDataWithKey(String aKey, StringBuffer aErrorMsg) { - String pickleRetValue = null; - - // sanity check - if(null == aErrorMsg) { - Log.e(LOG_TAG,"## serializeDataWithKey(): invalid parameter - aErrorMsg=null"); - } else if(TextUtils.isEmpty(aKey)) { - aErrorMsg.append("Invalid input parameters in serializeDataWithKey()"); - } else { - aErrorMsg.setLength(0); - try { - pickleRetValue = serializeDataWithKeyJni(aKey.getBytes("UTF-8"), aErrorMsg); - } catch (Exception e) { - Log.e(LOG_TAG,"## serializeDataWithKey(): failed " + e.getMessage()); - aErrorMsg.append(e.getMessage()); - } - } - - return pickleRetValue; - } - private native String serializeDataWithKeyJni(byte[] aKey, StringBuffer aErrorMsg); - - - /** - * Loads a session from a pickled base64 string.<br> - * See {@link #serializeDataWithKey(String, StringBuffer)} - * @param aSerializedData pickled account in a base64 string format - * @param aKey key used to encrypted - * @param aErrorMsg error message description - * @return true if operation succeed, false otherwise - */ - @Override - protected boolean initWithSerializedData(String aSerializedData, String aKey, StringBuffer aErrorMsg) { - boolean retCode = false; - String jniError; - - if(null == aErrorMsg) { - Log.e(LOG_TAG, "## initWithSerializedData(): invalid input error parameter"); - } else { - aErrorMsg.setLength(0); - - try { - if (TextUtils.isEmpty(aSerializedData) || TextUtils.isEmpty(aKey)) { - Log.e(LOG_TAG, "## initWithSerializedData(): invalid input parameters"); - } else if (null == (jniError = initWithSerializedDataJni(aSerializedData.getBytes("UTF-8"), aKey.getBytes("UTF-8")))) { - retCode = true; - } else { - aErrorMsg.append(jniError); - } - } catch (Exception e) { - Log.e(LOG_TAG, "## initWithSerializedData(): failed " + e.getMessage()); - aErrorMsg.append(e.getMessage()); - } - } - - return retCode; - } - private native String initWithSerializedDataJni(byte[] aSerializedData, byte[] aKey); - - /** * Getter on the session ID. * @return native session ID */ @@ -189,7 +91,6 @@ public class OlmSession extends CommonSerializeUtils implements Serializable { */ private native long initNewSessionJni(); - /** * Create a native account instance without any initialization.<br> * Since the account is left uninitialized, this @@ -210,6 +111,14 @@ public class OlmSession extends CommonSerializeUtils implements Serializable { private native long createNewSessionJni(); /** + * Return true the object resources have been released.<br> + * @return true the object resources have been released + */ + public boolean isReleased() { + return (0 == mNativeId); + } + + /** * Creates a new out-bound session for sending messages to a recipient * identified by an identity key and a one time key.<br> * @param aAccount the account to associate with this session @@ -217,7 +126,7 @@ public class OlmSession extends CommonSerializeUtils implements Serializable { * @param aTheirOneTimeKey the one time key of the recipient * @return 0 if operation succeed, -1 otherwise */ - public int initOutboundSessionWithAccount(OlmAccount aAccount, String aTheirIdentityKey, String aTheirOneTimeKey) { + public int initOutboundSession(OlmAccount aAccount, String aTheirIdentityKey, String aTheirOneTimeKey) { int retCode=-1; if ((null == aAccount) || TextUtils.isEmpty(aTheirIdentityKey) || TextUtils.isEmpty(aTheirOneTimeKey)) { @@ -226,7 +135,7 @@ public class OlmSession extends CommonSerializeUtils implements Serializable { try { retCode = initOutboundSessionJni(aAccount.getOlmAccountId(), aTheirIdentityKey.getBytes("UTF-8"), aTheirOneTimeKey.getBytes("UTF-8")); } catch (Exception e) { - Log.e(LOG_TAG, "## initOutboundSessionWithAccount(): " + e.getMessage()); + Log.e(LOG_TAG, "## initOutboundSession(): " + e.getMessage()); } } @@ -243,9 +152,9 @@ public class OlmSession extends CommonSerializeUtils implements Serializable { * @param aPreKeyMsg PRE KEY message * @exception Exception the failure reason */ - public void initInboundSessionWithAccount(OlmAccount aAccount, String aPreKeyMsg) throws Exception { + public void initInboundSession(OlmAccount aAccount, String aPreKeyMsg) throws Exception { if ((null == aAccount) || TextUtils.isEmpty(aPreKeyMsg)){ - Log.e(LOG_TAG, "## initInboundSessionWithAccount(): invalid input parameters"); + Log.e(LOG_TAG, "## initInboundSession(): invalid input parameters"); throw new Exception("invalid input parameters"); } else { StringBuffer errorMsg = new StringBuffer(); @@ -253,7 +162,7 @@ public class OlmSession extends CommonSerializeUtils implements Serializable { try { initInboundSessionJni(aAccount.getOlmAccountId(), aPreKeyMsg.getBytes("UTF-8"), errorMsg); } catch (Exception e) { - Log.e(LOG_TAG, "## initInboundSessionWithAccount(): " + e.getMessage()); + Log.e(LOG_TAG, "## initInboundSession(): " + e.getMessage()); errorMsg.append(errorMsg); } @@ -276,16 +185,16 @@ public class OlmSession extends CommonSerializeUtils implements Serializable { * @param aPreKeyMsg PRE KEY message * @return 0 if operation succeed, -1 otherwise */ - public int initInboundSessionWithAccountFrom(OlmAccount aAccount, String aTheirIdentityKey, String aPreKeyMsg) { + public int initInboundSessionFrom(OlmAccount aAccount, String aTheirIdentityKey, String aPreKeyMsg) { int retCode=-1; if((null==aAccount) || TextUtils.isEmpty(aPreKeyMsg)){ - Log.e(LOG_TAG, "## initInboundSessionWithAccount(): invalid input parameters"); + Log.e(LOG_TAG, "## initInboundSessionFrom(): invalid input parameters"); } else { try { retCode = initInboundSessionFromIdKeyJni(aAccount.getOlmAccountId(), aTheirIdentityKey.getBytes("UTF-8"), aPreKeyMsg.getBytes("UTF-8")); } catch (Exception e) { - Log.e(LOG_TAG, "## initInboundSessionWithAccountFrom(): " + e.getMessage()); + Log.e(LOG_TAG, "## initInboundSessionFrom(): " + e.getMessage()); } } @@ -400,12 +309,94 @@ public class OlmSession extends CommonSerializeUtils implements Serializable { private native byte[] decryptMessageJni(OlmMessage aEncryptedMsg); + //============================================================================================================== + // Serialization management + //============================================================================================================== + /** - * Return true the object resources have been released.<br> - * @return true the object resources have been released + * Kick off the serialization mechanism. + * @param aOutStream output stream for serializing + * @throws IOException exception */ - public boolean isReleased() { - return (0 == mNativeId); + private void writeObject(ObjectOutputStream aOutStream) throws IOException { + serialize(aOutStream); } + + /** + * Kick off the deserialization mechanism. + * @param aInStream input stream + * @throws IOException exception + * @throws ClassNotFoundException exception + */ + private void readObject(ObjectInputStream aInStream) throws IOException, ClassNotFoundException { + deserialize(aInStream); + } + + /** + * Return a session as a base64 string.<br> + * The account is serialized and encrypted with aKey. + * In case of failure, an error human readable + * description is provide in aErrorMsg. + * @param aKey encryption key + * @param aErrorMsg error message description + * @return pickled base64 string if operation succeed, null otherwise + */ + @Override + protected String serialize(String aKey, StringBuffer aErrorMsg) { + String pickleRetValue = null; + + // sanity check + if(null == aErrorMsg) { + Log.e(LOG_TAG,"## serializeDataWithKey(): invalid parameter - aErrorMsg=null"); + } else if(TextUtils.isEmpty(aKey)) { + aErrorMsg.append("Invalid input parameters in serializeDataWithKey()"); + } else { + aErrorMsg.setLength(0); + try { + pickleRetValue = serializeJni(aKey.getBytes("UTF-8"), aErrorMsg); + } catch (Exception e) { + Log.e(LOG_TAG,"## serializeDataWithKey(): failed " + e.getMessage()); + aErrorMsg.append(e.getMessage()); + } + } + + return pickleRetValue; + } + private native String serializeJni(byte[] aKey, StringBuffer aErrorMsg); + + /** + * Loads an account from a pickled base64 string.<br> + * See {@link #serialize(String, StringBuffer)} + * @param aSerializedData pickled account in a base64 string format + * @param aKey key used to encrypted + */ + @Override + protected void deserialize(String aSerializedData, String aKey) throws IOException { + if (!createNewSession()) { + throw new OlmException(OlmException.EXCEPTION_CODE_INIT_ACCOUNT_CREATION,OlmException.EXCEPTION_MSG_INIT_ACCOUNT_CREATION); + } + + StringBuffer errorMsg = new StringBuffer(); + + try { + String jniError; + if (TextUtils.isEmpty(aSerializedData) || TextUtils.isEmpty(aKey)) { + Log.e(LOG_TAG, "## deserialize(): invalid input parameters"); + errorMsg.append("invalid input parameters"); + } else if (null != (jniError = deserializeJni(aSerializedData.getBytes("UTF-8"), aKey.getBytes("UTF-8")))) { + errorMsg.append(jniError); + } + } catch (Exception e) { + Log.e(LOG_TAG, "## deserialize() failed " + e.getMessage()); + errorMsg.append(e.getMessage()); + } + + if (errorMsg.length() > 0) { + releaseSession(); + throw new OlmException(OlmException.EXCEPTION_CODE_ACCOUNT_DESERIALIZATION, String.valueOf(errorMsg)); + } + } + + private native String deserializeJni(byte[] aSerializedData, byte[] aKey); } 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 06709e7..d57e55b 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 @@ -476,7 +476,7 @@ JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(signMessageJni)(JNIEnv *env, jobject t * @param[out] aErrorMsg error message set if operation failed * @return a base64 string if operation succeed, null otherwise **/ -JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg) +JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg) { jbyteArray pickledDataRetValue = 0; jclass errorMsgJClass = 0; @@ -485,44 +485,44 @@ JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, jbyte* keyPtr = NULL; OlmAccount* accountPtr = NULL; - LOGD("## serializeDataWithKeyJni(): IN"); + LOGD("## serializeJni(): IN"); if (!aKeyBuffer) { - LOGE(" ## serializeDataWithKeyJni(): failure - invalid key"); + LOGE(" ## serializeJni(): failure - invalid key"); } else if (!aErrorMsg) { - LOGE(" ## serializeDataWithKeyJni(): failure - invalid error object"); + LOGE(" ## serializeJni(): failure - invalid error object"); } else if (!(accountPtr = (OlmAccount*)getAccountInstanceId(env,thiz))) { - LOGE(" ## serializeDataWithKeyJni(): failure - invalid account ptr"); + LOGE(" ## serializeJni(): failure - invalid account ptr"); } else if (!(errorMsgJClass = env->GetObjectClass(aErrorMsg))) { - LOGE(" ## serializeDataWithKeyJni(): failure - unable to get error class"); + LOGE(" ## serializeJni(): failure - unable to get error class"); } else if (!(errorMsgMethodId = env->GetMethodID(errorMsgJClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;"))) { - LOGE(" ## serializeDataWithKeyJni(): failure - unable to get error method ID"); + LOGE(" ## serializeJni(): failure - unable to get error method ID"); } else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, NULL))) { - LOGE(" ## serializeDataWithKeyJni(): failure - keyPtr JNI allocation OOM"); + LOGE(" ## serializeJni(): failure - keyPtr JNI allocation OOM"); } else { size_t pickledLength = olm_pickle_account_length(accountPtr); size_t keyLength = (size_t)env->GetArrayLength(aKeyBuffer); - LOGD(" ## serializeDataWithKeyJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength)); - LOGD(" ## serializeDataWithKeyJni(): key=%s",(char const *)keyPtr); + LOGD(" ## serializeJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength)); + LOGD(" ## serializeJni(): key=%s",(char const *)keyPtr); void *pickledPtr = malloc((pickledLength+1)*sizeof(uint8_t)); if (!pickledPtr) { - LOGE(" ## serializeDataWithKeyJni(): failure - pickledPtr buffer OOM"); + LOGE(" ## serializeJni(): failure - pickledPtr buffer OOM"); } else { @@ -534,7 +534,7 @@ JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, if (result == olm_error()) { const char *errorMsgPtr = olm_account_last_error(accountPtr); - LOGE(" ## serializeDataWithKeyJni(): failure - olm_pickle_account() Msg=%s",errorMsgPtr); + LOGE(" ## serializeJni(): failure - olm_pickle_account() Msg=%s",errorMsgPtr); if(0 != (errorJstring = env->NewStringUTF(errorMsgPtr))) { @@ -546,7 +546,7 @@ JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, // build success output (static_cast<char*>(pickledPtr))[pickledLength] = static_cast<char>('\0'); - LOGD(" ## serializeDataWithKeyJni(): success - result=%lu pickled=%s", static_cast<long unsigned int>(result), static_cast<char*>(pickledPtr)); + LOGD(" ## serializeJni(): success - result=%lu pickled=%s", static_cast<long unsigned int>(result), static_cast<char*>(pickledPtr)); pickledDataRetValue = env->NewByteArray(pickledLength+1); env->SetByteArrayRegion(pickledDataRetValue, 0 , pickledLength+1, (jbyte*)pickledPtr); @@ -566,42 +566,42 @@ JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, } -JNIEXPORT jstring OLM_ACCOUNT_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer) +JNIEXPORT jstring OLM_ACCOUNT_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer) { OlmAccount* accountPtr = NULL; jstring errorMessageRetValue = 0; jbyte* keyPtr = NULL; jbyte* pickledPtr = NULL; - LOGD("## initWithSerializedDataJni(): IN"); + LOGD("## deserializeJni(): IN"); if (!aKeyBuffer) { - LOGE(" ## initWithSerializedDataJni(): failure - invalid key"); + LOGE(" ## deserializeJni(): failure - invalid key"); } else if (!aSerializedDataBuffer) { - LOGE(" ## initWithSerializedDataJni(): failure - serialized data"); + LOGE(" ## deserializeJni(): failure - serialized data"); } else if (!(accountPtr = (OlmAccount*)getAccountInstanceId(env,thiz))) { - LOGE(" ## initWithSerializedDataJni(): failure - account failure OOM"); + LOGE(" ## deserializeJni(): failure - account failure OOM"); } else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, 0))) { - LOGE(" ## initWithSerializedDataJni(): failure - keyPtr JNI allocation OOM"); + LOGE(" ## deserializeJni(): failure - keyPtr JNI allocation OOM"); } else if (!(pickledPtr = env->GetByteArrayElements(aSerializedDataBuffer, 0))) { - LOGE(" ## initWithSerializedDataJni(): failure - pickledPtr JNI allocation OOM"); + LOGE(" ## deserializeJni(): failure - pickledPtr JNI allocation OOM"); } else { size_t pickledLength = (size_t)env->GetArrayLength(aSerializedDataBuffer); size_t keyLength = (size_t)env->GetArrayLength(aKeyBuffer); - LOGD(" ## initWithSerializedDataJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength)); - LOGD(" ## initWithSerializedDataJni(): key=%s",(char const *)keyPtr); - LOGD(" ## initWithSerializedDataJni(): pickled=%s",(char const *)pickledPtr); + LOGD(" ## deserializeJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength)); + LOGD(" ## deserializeJni(): key=%s",(char const *)keyPtr); + LOGD(" ## deserializeJni(): pickled=%s",(char const *)pickledPtr); size_t result = olm_unpickle_account(accountPtr, (void const *)keyPtr, @@ -611,12 +611,12 @@ JNIEXPORT jstring OLM_ACCOUNT_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, j if (result == olm_error()) { const char *errorMsgPtr = olm_account_last_error(accountPtr); - LOGE(" ## initWithSerializedDataJni(): failure - olm_unpickle_account() Msg=%s",errorMsgPtr); + LOGE(" ## deserializeJni(): failure - olm_unpickle_account() Msg=%s",errorMsgPtr); errorMessageRetValue = env->NewStringUTF(errorMsgPtr); } else { - LOGD(" ## initWithSerializedDataJni(): success - result=%lu ", static_cast<long unsigned int>(result)); + LOGD(" ## deserializeJni(): success - result=%lu ", static_cast<long unsigned int>(result)); } } diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_account.h b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_account.h index c866dbc..94a0381 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_account.h +++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_account.h @@ -47,8 +47,8 @@ JNIEXPORT jint OLM_ACCOUNT_FUNC_DEF(markOneTimeKeysAsPublishedJni)(JNIEnv *env, JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(signMessageJni)(JNIEnv *env, jobject thiz, jbyteArray aMessage); // serialization -JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg); -JNIEXPORT jstring OLM_ACCOUNT_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer); +JNIEXPORT jbyteArray OLM_ACCOUNT_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg); +JNIEXPORT jstring OLM_ACCOUNT_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer); #ifdef __cplusplus } 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 ca47dbb..d396eb9 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 @@ -86,41 +86,41 @@ JNIEXPORT jlong OLM_INBOUND_GROUP_SESSION_FUNC_DEF(createNewSessionJni)(JNIEnv * * @param aSessionKey session key from an outbound session * @return ERROR_CODE_OK if operation succeed, ERROR_CODE_KO otherwise */ -JNIEXPORT jint OLM_INBOUND_GROUP_SESSION_FUNC_DEF(initInboundGroupSessionWithSessionKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aSessionKeyBuffer) +JNIEXPORT jint OLM_INBOUND_GROUP_SESSION_FUNC_DEF(initInboundGroupSessionJni)(JNIEnv *env, jobject thiz, jbyteArray aSessionKeyBuffer) { jint retCode = ERROR_CODE_KO; OlmInboundGroupSession *sessionPtr = NULL; jbyte* sessionKeyPtr = NULL; size_t sessionResult; - LOGD("## initInboundGroupSessionWithSessionKeyJni(): inbound group session IN"); + LOGD("## initInboundGroupSessionJni(): inbound group session IN"); if (!(sessionPtr = (OlmInboundGroupSession*)getInboundGroupSessionInstanceId(env,thiz))) { - LOGE(" ## initInboundGroupSessionWithSessionKeyJni(): failure - invalid inbound group session instance"); + LOGE(" ## initInboundGroupSessionJni(): failure - invalid inbound group session instance"); } else if (!aSessionKeyBuffer) { - LOGE(" ## initInboundGroupSessionWithSessionKeyJni(): failure - invalid aSessionKey"); + LOGE(" ## initInboundGroupSessionJni(): failure - invalid aSessionKey"); } else if (!(sessionKeyPtr = env->GetByteArrayElements(aSessionKeyBuffer, 0))) { - LOGE(" ## initInboundSessionFromIdKeyJni(): failure - session key JNI allocation OOM"); + LOGE(" ## initInboundGroupSessionJni(): failure - session key JNI allocation OOM"); } else { size_t sessionKeyLength = (size_t)env->GetArrayLength(aSessionKeyBuffer); - LOGD(" ## initInboundSessionFromIdKeyJni(): sessionKeyLength=%lu",static_cast<long unsigned int>(sessionKeyLength)); + LOGD(" ## initInboundGroupSessionJni(): sessionKeyLength=%lu",static_cast<long unsigned int>(sessionKeyLength)); sessionResult = olm_init_inbound_group_session(sessionPtr, (const uint8_t*)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); + LOGE(" ## initInboundGroupSessionJni(): failure - init inbound session creation Msg=%s",errorMsgPtr); } else { retCode = ERROR_CODE_OK; - LOGD(" ## initInboundSessionFromIdKeyJni(): success - result=%lu", static_cast<long unsigned int>(sessionResult)); + LOGD(" ## initInboundGroupSessionJni(): success - result=%lu", static_cast<long unsigned int>(sessionResult)); } } @@ -337,7 +337,7 @@ JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(decryptMessageJni)(JNIEn * @param[out] aErrorMsg error message set if operation failed * @return a base64 string if operation succeed, null otherwise **/ -JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg) +JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg) { jbyteArray pickledDataRet = 0; @@ -346,44 +346,44 @@ JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni) jbyte* keyPtr = NULL; OlmInboundGroupSession* sessionPtr = NULL; - LOGD("## inbound group session serializeDataWithKeyJni(): IN"); + LOGD("## inbound group session serializeJni(): IN"); if (!(sessionPtr = (OlmInboundGroupSession*)getInboundGroupSessionInstanceId(env,thiz))) { - LOGE(" ## serializeDataWithKeyJni(): failure - invalid session ptr"); + LOGE(" ## serializeJni(): failure - invalid session ptr"); } else if (!aKeyBuffer) { - LOGE(" ## serializeDataWithKeyJni(): failure - invalid key"); + LOGE(" ## serializeJni(): failure - invalid key"); } else if (!aErrorMsg) { - LOGE(" ## serializeDataWithKeyJni(): failure - invalid error object"); + LOGE(" ## serializeJni(): failure - invalid error object"); } else if (!(errorMsgJClass = env->GetObjectClass(aErrorMsg))) { - LOGE(" ## serializeDataWithKeyJni(): failure - unable to get error class"); + LOGE(" ## serializeJni(): failure - unable to get error class"); } else if (!(errorMsgMethodId = env->GetMethodID(errorMsgJClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;"))) { - LOGE(" ## serializeDataWithKeyJni(): failure - unable to get error method ID"); + LOGE(" ## serializeJni(): failure - unable to get error method ID"); } else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, 0))) { - LOGE(" ## serializeDataWithKeyJni(): failure - keyPtr JNI allocation OOM"); + LOGE(" ## serializeJni(): failure - keyPtr JNI allocation OOM"); } else { size_t pickledLength = olm_pickle_inbound_group_session_length(sessionPtr); size_t keyLength = (size_t)env->GetArrayLength(aKeyBuffer); - LOGD(" ## serializeDataWithKeyJni(): pickledLength=%lu keyLength=%lu", static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength)); - LOGD(" ## serializeDataWithKeyJni(): key=%s",(char const *)keyPtr); + LOGD(" ## serializeJni(): pickledLength=%lu keyLength=%lu", static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength)); + LOGD(" ## serializeJni(): key=%s",(char const *)keyPtr); void *pickledPtr = malloc((pickledLength+1)*sizeof(uint8_t)); if (!pickledPtr) { - LOGE(" ## serializeDataWithKeyJni(): failure - pickledPtr buffer OOM"); + LOGE(" ## serializeJni(): failure - pickledPtr buffer OOM"); } else { @@ -395,7 +395,7 @@ JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni) if (result == olm_error()) { const char *errorMsgPtr = olm_inbound_group_session_last_error(sessionPtr); - LOGE(" ## serializeDataWithKeyJni(): failure - olm_pickle_outbound_group_session() Msg=%s",errorMsgPtr); + LOGE(" ## serializeJni(): failure - olm_pickle_outbound_group_session() Msg=%s",errorMsgPtr); jstring errorJstring = env->NewStringUTF(errorMsgPtr); @@ -407,7 +407,7 @@ JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni) else { (static_cast<char*>(pickledPtr))[pickledLength] = static_cast<char>('\0'); - LOGD(" ## serializeDataWithKeyJni(): success - result=%lu pickled=%s", static_cast<long unsigned int>(result), static_cast<char*>(pickledPtr)); + LOGD(" ## serializeJni(): success - result=%lu pickled=%s", static_cast<long unsigned int>(result), static_cast<char*>(pickledPtr)); pickledDataRet = env->NewByteArray(pickledLength); env->SetByteArrayRegion(pickledDataRet, 0 , pickledLength, (jbyte*)pickledPtr); @@ -427,42 +427,42 @@ JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni) } -JNIEXPORT jstring OLM_INBOUND_GROUP_SESSION_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer) +JNIEXPORT jstring OLM_INBOUND_GROUP_SESSION_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer) { OlmInboundGroupSession* sessionPtr = NULL; jstring errorMessageRetValue = 0; jbyte* keyPtr = NULL; jbyte* pickledPtr = NULL; - LOGD("## initWithSerializedDataJni(): IN"); + LOGD("## deserializeJni(): IN"); if (!(sessionPtr = (OlmInboundGroupSession*)getInboundGroupSessionInstanceId(env,thiz))) { - LOGE(" ## initWithSerializedDataJni(): failure - session failure OOM"); + LOGE(" ## deserializeJni(): failure - session failure OOM"); } else if (!aKeyBuffer) { - LOGE(" ## initWithSerializedDataJni(): failure - invalid key"); + LOGE(" ## deserializeJni(): failure - invalid key"); } else if (!aSerializedDataBuffer) { - LOGE(" ## initWithSerializedDataJni(): failure - serialized data"); + LOGE(" ## deserializeJni(): failure - serialized data"); } else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, 0))) { - LOGE(" ## initWithSerializedDataJni(): failure - keyPtr JNI allocation OOM"); + LOGE(" ## deserializeJni(): failure - keyPtr JNI allocation OOM"); } else if (!(pickledPtr = env->GetByteArrayElements(aSerializedDataBuffer, 0))) { - LOGE(" ## initWithSerializedDataJni(): failure - pickledPtr JNI allocation OOM"); + LOGE(" ## deserializeJni(): failure - pickledPtr JNI allocation OOM"); } else { size_t pickledLength = (size_t)env->GetArrayLength(aSerializedDataBuffer); size_t keyLength = (size_t)env->GetArrayLength(aKeyBuffer); - LOGD(" ## initWithSerializedDataJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength)); - LOGD(" ## initWithSerializedDataJni(): key=%s",(char const *)keyPtr); - LOGD(" ## initWithSerializedDataJni(): pickled=%s",(char const *)pickledPtr); + LOGD(" ## deserializeJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength)); + LOGD(" ## deserializeJni(): key=%s",(char const *)keyPtr); + LOGD(" ## deserializeJni(): pickled=%s",(char const *)pickledPtr); size_t result = olm_unpickle_inbound_group_session(sessionPtr, (void const *)keyPtr, @@ -472,12 +472,12 @@ JNIEXPORT jstring OLM_INBOUND_GROUP_SESSION_FUNC_DEF(initWithSerializedDataJni)( if (result == olm_error()) { const char *errorMsgPtr = olm_inbound_group_session_last_error(sessionPtr); - LOGE(" ## initWithSerializedDataJni(): failure - olm_unpickle_inbound_group_session() Msg=%s",errorMsgPtr); + LOGE(" ## deserializeJni(): failure - olm_unpickle_inbound_group_session() Msg=%s",errorMsgPtr); errorMessageRetValue = env->NewStringUTF(errorMsgPtr); } else { - LOGD(" ## initWithSerializedDataJni(): success - result=%lu ", static_cast<long unsigned int>(result)); + LOGD(" ## deserializeJni(): success - result=%lu ", static_cast<long unsigned int>(result)); } } diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_inbound_group_session.h b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_inbound_group_session.h index 7ed6d8b..0ef55cf 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_inbound_group_session.h +++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_inbound_group_session.h @@ -32,13 +32,13 @@ extern "C" { 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); -JNIEXPORT jint OLM_INBOUND_GROUP_SESSION_FUNC_DEF(initInboundGroupSessionWithSessionKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aSessionKeyBuffer); +JNIEXPORT jint OLM_INBOUND_GROUP_SESSION_FUNC_DEF(initInboundGroupSessionJni)(JNIEnv *env, jobject thiz, jbyteArray aSessionKeyBuffer); 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, jobject aErrorMsg); // serialization -JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aKey, jobject aErrorMsg); -JNIEXPORT jstring OLM_INBOUND_GROUP_SESSION_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedData, jbyteArray aKey); +JNIEXPORT jbyteArray OLM_INBOUND_GROUP_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKey, jobject aErrorMsg); +JNIEXPORT jstring OLM_INBOUND_GROUP_SESSION_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedData, jbyteArray aKey); #ifdef __cplusplus 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 aa0e5e7..4168742 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 @@ -372,7 +372,7 @@ JNIEXPORT jbyteArray OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(encryptMessageJni)(JNIE * @param[out] aErrorMsg error message set if operation failed * @return a base64 string if operation succeed, null otherwise **/ -JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg) +JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg) { jstring pickledDataRetValue = 0; jclass errorMsgJClass = 0; @@ -381,44 +381,44 @@ JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)(J jbyte* keyPtr = NULL; OlmOutboundGroupSession* sessionPtr = NULL; - LOGD("## outbound group session serializeDataWithKeyJni(): IN"); + LOGD("## outbound group session serializeJni(): IN"); if (!(sessionPtr = (OlmOutboundGroupSession*)getOutboundGroupSessionInstanceId(env,thiz))) { - LOGE(" ## serializeDataWithKeyJni(): failure - invalid session ptr"); + LOGE(" ## serializeJni(): failure - invalid session ptr"); } else if (!aKeyBuffer) { - LOGE(" ## serializeDataWithKeyJni(): failure - invalid key"); + LOGE(" ## serializeJni(): failure - invalid key"); } else if (!aErrorMsg) { - LOGE(" ## serializeDataWithKeyJni(): failure - invalid error object"); + LOGE(" ## serializeJni(): failure - invalid error object"); } else if (!(errorMsgJClass = env->GetObjectClass(aErrorMsg))) { - LOGE(" ## serializeDataWithKeyJni(): failure - unable to get error class"); + LOGE(" ## serializeJni(): failure - unable to get error class"); } else if (!(errorMsgMethodId = env->GetMethodID(errorMsgJClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;"))) { - LOGE(" ## serializeDataWithKeyJni(): failure - unable to get error method ID"); + LOGE(" ## serializeJni(): failure - unable to get error method ID"); } else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, 0))) { - LOGE(" ## serializeDataWithKeyJni(): failure - keyPtr JNI allocation OOM"); + LOGE(" ## serializeJni(): failure - keyPtr JNI allocation OOM"); } else { size_t pickledLength = olm_pickle_outbound_group_session_length(sessionPtr); size_t keyLength = (size_t)env->GetArrayLength(aKeyBuffer); - LOGD(" ## serializeDataWithKeyJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength)); - LOGD(" ## serializeDataWithKeyJni(): key=%s",(char const *)keyPtr); + LOGD(" ## serializeJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength)); + LOGD(" ## serializeJni(): key=%s",(char const *)keyPtr); void *pickledPtr = malloc((pickledLength+1)*sizeof(uint8_t)); if(!pickledPtr) { - LOGE(" ## serializeDataWithKeyJni(): failure - pickledPtr buffer OOM"); + LOGE(" ## serializeJni(): failure - pickledPtr buffer OOM"); } else { @@ -430,7 +430,7 @@ JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)(J if (result == olm_error()) { const char *errorMsgPtr = olm_outbound_group_session_last_error(sessionPtr); - LOGE(" ## serializeDataWithKeyJni(): failure - olm_pickle_outbound_group_session() Msg=%s",errorMsgPtr); + LOGE(" ## serializeJni(): failure - olm_pickle_outbound_group_session() Msg=%s",errorMsgPtr); if (!(errorJstring = env->NewStringUTF(errorMsgPtr))) { @@ -442,7 +442,7 @@ JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)(J // build success output (static_cast<char*>(pickledPtr))[pickledLength] = static_cast<char>('\0'); pickledDataRetValue = env->NewStringUTF((const char*)pickledPtr); - LOGD(" ## serializeDataWithKeyJni(): success - result=%lu pickled=%s", static_cast<long unsigned int>(result), static_cast<char*>(pickledPtr)); + LOGD(" ## serializeJni(): success - result=%lu pickled=%s", static_cast<long unsigned int>(result), static_cast<char*>(pickledPtr)); } } @@ -459,42 +459,42 @@ JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)(J } -JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer) +JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer) { OlmOutboundGroupSession* sessionPtr = NULL; jstring errorMessageRetValue = 0; jbyte* keyPtr = NULL; jbyte* pickledPtr = NULL; - LOGD("## initWithSerializedDataJni(): IN"); + LOGD("## deserializeJni(): IN"); if (!(sessionPtr = (OlmOutboundGroupSession*)getOutboundGroupSessionInstanceId(env,thiz))) { - LOGE(" ## initWithSerializedDataJni(): failure - session failure OOM"); + LOGE(" ## deserializeJni(): failure - session failure OOM"); } else if (!aKeyBuffer) { - LOGE(" ## initWithSerializedDataJni(): failure - invalid key"); + LOGE(" ## deserializeJni(): failure - invalid key"); } else if (!aSerializedDataBuffer) { - LOGE(" ## initWithSerializedDataJni(): failure - serialized data"); + LOGE(" ## deserializeJni(): failure - serialized data"); } else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, 0))) { - LOGE(" ## initWithSerializedDataJni(): failure - keyPtr JNI allocation OOM"); + LOGE(" ## deserializeJni(): failure - keyPtr JNI allocation OOM"); } else if (!(pickledPtr = env->GetByteArrayElements(aSerializedDataBuffer, 0))) { - LOGE(" ## initWithSerializedDataJni(): failure - pickledPtr JNI allocation OOM"); + LOGE(" ## deserializeJni(): failure - pickledPtr JNI allocation OOM"); } else { size_t pickledLength = (size_t)env->GetArrayLength(aSerializedDataBuffer); size_t keyLength = (size_t)env->GetArrayLength(aKeyBuffer); - LOGD(" ## initWithSerializedDataJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength)); - LOGD(" ## initWithSerializedDataJni(): key=%s",(char const *)keyPtr); - LOGD(" ## initWithSerializedDataJni(): pickled=%s",(char const *)pickledPtr); + LOGD(" ## deserializeJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength)); + LOGD(" ## deserializeJni(): key=%s",(char const *)keyPtr); + LOGD(" ## deserializeJni(): pickled=%s",(char const *)pickledPtr); size_t result = olm_unpickle_outbound_group_session(sessionPtr, (void const *)keyPtr, @@ -504,12 +504,12 @@ JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(initWithSerializedDataJni) if (result == olm_error()) { const char *errorMsgPtr = olm_outbound_group_session_last_error(sessionPtr); - LOGE(" ## initWithSerializedDataJni(): failure - olm_unpickle_outbound_group_session() Msg=%s",errorMsgPtr); + LOGE(" ## deserializeJni(): failure - olm_unpickle_outbound_group_session() Msg=%s",errorMsgPtr); errorMessageRetValue = env->NewStringUTF(errorMsgPtr); } else { - LOGD(" ## initWithSerializedDataJni(): success - result=%lu ", static_cast<long unsigned int>(result)); + LOGD(" ## deserializeJni(): success - result=%lu ", static_cast<long unsigned int>(result)); } } 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 37f0ea6..f954bef 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 @@ -40,8 +40,8 @@ JNIEXPORT jbyteArray OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(sessionKeyJni)(JNIEnv * JNIEXPORT jbyteArray OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(encryptMessageJni)(JNIEnv *env, jobject thiz, jbyteArray aClearMsgBuffer, jobject aErrorMsg); // serialization -JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aKey, jobject aErrorMsg); -JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedData, jbyteArray aKey); +JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKey, jobject aErrorMsg); +JNIEXPORT jstring OLM_OUTBOUND_GROUP_SESSION_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedData, jbyteArray aKey); #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 3731d14..4a1717a 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 @@ -780,7 +780,7 @@ JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(getSessionIdentifierJni)(JNIEnv *env, * @param[out] aErrorMsg error message set if operation failed * @return a base64 string if operation succeed, null otherwise **/ -JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg) +JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg) { jstring pickledDataRetValue = 0; jclass errorMsgJClass = 0; @@ -789,44 +789,44 @@ JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, job jbyte* keyPtr = NULL; OlmSession* sessionPtr = NULL; - LOGD("## serializeDataWithKeyJni(): IN"); + LOGD("## serializeJni(): IN"); if (!(sessionPtr = (OlmSession*)getSessionInstanceId(env,thiz))) { - LOGE(" ## serializeDataWithKeyJni(): failure - invalid session ptr"); + LOGE(" ## serializeJni(): failure - invalid session ptr"); } else if (!aKeyBuffer) { - LOGE(" ## serializeDataWithKeyJni(): failure - invalid key"); + LOGE(" ## serializeJni(): failure - invalid key"); } else if (!aErrorMsg) { - LOGE(" ## serializeDataWithKeyJni(): failure - invalid error object"); + LOGE(" ## serializeJni(): failure - invalid error object"); } else if (!(errorMsgJClass = env->GetObjectClass(aErrorMsg))) { - LOGE(" ## serializeDataWithKeyJni(): failure - unable to get error class"); + LOGE(" ## serializeJni(): failure - unable to get error class"); } else if (!(errorMsgMethodId = env->GetMethodID(errorMsgJClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;"))) { - LOGE(" ## serializeDataWithKeyJni(): failure - unable to get error method ID"); + LOGE(" ## serializeJni(): failure - unable to get error method ID"); } else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, 0))) { - LOGE(" ## serializeDataWithKeyJni(): failure - keyPtr JNI allocation OOM"); + LOGE(" ## serializeJni(): failure - keyPtr JNI allocation OOM"); } else { size_t pickledLength = olm_pickle_session_length(sessionPtr); size_t keyLength = (size_t)env->GetArrayLength(aKeyBuffer); - LOGD(" ## serializeDataWithKeyJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength)); - LOGD(" ## serializeDataWithKeyJni(): key=%s",(char const *)keyPtr); + LOGD(" ## serializeJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength)); + LOGD(" ## serializeJni(): key=%s",(char const *)keyPtr); void *pickledPtr = malloc((pickledLength+1)*sizeof(uint8_t)); if (!pickledPtr) { - LOGE(" ## serializeDataWithKeyJni(): failure - pickledPtr buffer OOM"); + LOGE(" ## serializeJni(): failure - pickledPtr buffer OOM"); } else { @@ -838,7 +838,7 @@ JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, job if (result == olm_error()) { const char *errorMsgPtr = olm_session_last_error(sessionPtr); - LOGE(" ## serializeDataWithKeyJni(): failure - olm_pickle_session() Msg=%s",errorMsgPtr); + LOGE(" ## serializeJni(): failure - olm_pickle_session() Msg=%s",errorMsgPtr); if ((errorJstring = env->NewStringUTF(errorMsgPtr))) { @@ -850,7 +850,7 @@ JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, job // build success output (static_cast<char*>(pickledPtr))[pickledLength] = static_cast<char>('\0'); pickledDataRetValue = env->NewStringUTF((const char*)pickledPtr); - LOGD(" ## serializeDataWithKeyJni(): success - result=%lu pickled=%s", static_cast<long unsigned int>(result), static_cast<char*>(pickledPtr)); + LOGD(" ## serializeJni(): success - result=%lu pickled=%s", static_cast<long unsigned int>(result), static_cast<char*>(pickledPtr)); } free(pickledPtr); @@ -867,42 +867,42 @@ JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, job } -JNIEXPORT jstring OLM_SESSION_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer) +JNIEXPORT jstring OLM_SESSION_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedDataBuffer, jbyteArray aKeyBuffer) { OlmSession* sessionPtr = NULL; jstring errorMessageRetValue = 0; jbyte* keyPtr = NULL; jbyte* pickledPtr = NULL; - LOGD("## initWithSerializedDataJni(): IN"); + LOGD("## deserializeJni(): IN"); if (!(sessionPtr = (OlmSession*)getSessionInstanceId(env,thiz))) { - LOGE(" ## initWithSerializedDataJni(): failure - session failure OOM"); + LOGE(" ## deserializeJni(): failure - session failure OOM"); } else if (!aKeyBuffer) { - LOGE(" ## initWithSerializedDataJni(): failure - invalid key"); + LOGE(" ## deserializeJni(): failure - invalid key"); } else if (!aSerializedDataBuffer) { - LOGE(" ## initWithSerializedDataJni(): failure - serialized data"); + LOGE(" ## deserializeJni(): failure - serialized data"); } else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, 0))) { - LOGE(" ## initWithSerializedDataJni(): failure - keyPtr JNI allocation OOM"); + LOGE(" ## deserializeJni(): failure - keyPtr JNI allocation OOM"); } else if (!(pickledPtr = env->GetByteArrayElements(aSerializedDataBuffer, 0))) { - LOGE(" ## initWithSerializedDataJni(): failure - pickledPtr JNI allocation OOM"); + LOGE(" ## deserializeJni(): failure - pickledPtr JNI allocation OOM"); } else { size_t pickledLength = (size_t)env->GetArrayLength(aSerializedDataBuffer); size_t keyLength = (size_t)env->GetArrayLength(aKeyBuffer); - LOGD(" ## initWithSerializedDataJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength)); - LOGD(" ## initWithSerializedDataJni(): key=%s",(char const *)keyPtr); - LOGD(" ## initWithSerializedDataJni(): pickled=%s",(char const *)pickledPtr); + LOGD(" ## deserializeJni(): pickledLength=%lu keyLength=%lu",static_cast<long unsigned int>(pickledLength), static_cast<long unsigned int>(keyLength)); + LOGD(" ## deserializeJni(): key=%s",(char const *)keyPtr); + LOGD(" ## deserializeJni(): pickled=%s",(char const *)pickledPtr); size_t result = olm_unpickle_session(sessionPtr, (void const *)keyPtr, @@ -912,14 +912,13 @@ JNIEXPORT jstring OLM_SESSION_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, j if (result == olm_error()) { const char *errorMsgPtr = olm_session_last_error(sessionPtr); - LOGE(" ## initWithSerializedDataJni(): failure - olm_unpickle_account() Msg=%s",errorMsgPtr); + LOGE(" ## deserializeJni(): failure - olm_unpickle_account() Msg=%s",errorMsgPtr); errorMessageRetValue = env->NewStringUTF(errorMsgPtr); } else { - LOGD(" ## initWithSerializedDataJni(): success - result=%lu ", static_cast<long unsigned int>(result)); + LOGD(" ## initJni(): success - result=%lu ", static_cast<long unsigned int>(result)); } - } // free alloc diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_session.h b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_session.h index 9ce12d4..95b421b 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_session.h +++ b/java/android/OlmLibSdk/olm-sdk/src/main/jni/olm_session.h @@ -50,8 +50,8 @@ JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(decryptMessageJni)(JNIEnv *env, jobjec JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(getSessionIdentifierJni)(JNIEnv *env, jobject thiz); // serialization -JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeDataWithKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aKey, jobject aErrorMsg); -JNIEXPORT jstring OLM_SESSION_FUNC_DEF(initWithSerializedDataJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedData, jbyteArray aKey); +JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKey, jobject aErrorMsg); +JNIEXPORT jstring OLM_SESSION_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedData, jbyteArray aKey); #ifdef __cplusplus } |