diff options
Diffstat (limited to 'java/android/OlmLibSdk/olm-sdk/src')
6 files changed, 402 insertions, 187 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 e8b2288..ec2582f 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 @@ -131,9 +131,18 @@ public class OlmSessionTest { assertTrue(0!=aliceSession.getOlmSessionId()); // CREATE ALICE OUTBOUND SESSION and encrypt message to bob - assertNotNull(aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey)); + try { + aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } String clearMsg = "Heloo bob , this is alice!"; - OlmMessage encryptedMsgToBob = aliceSession.encryptMessage(clearMsg); + OlmMessage encryptedMsgToBob = null; + try { + encryptedMsgToBob = aliceSession.encryptMessage(clearMsg); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } assertNotNull(encryptedMsgToBob); assertNotNull(encryptedMsgToBob.mCipherText); Log.d(LOG_TAG,"## test01AliceToBob(): encryptedMsg="+encryptedMsgToBob.mCipherText); @@ -153,7 +162,12 @@ public class OlmSessionTest { assertTrue("initInboundSessionWithAccount failed " + e.getMessage(), false); } - String decryptedMsg = bobSession.decryptMessage(encryptedMsgToBob); + String decryptedMsg = null; + try { + decryptedMsg = bobSession.decryptMessage(encryptedMsgToBob); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } assertNotNull(decryptedMsg); // MESSAGE COMPARISON: decrypted vs encrypted @@ -255,10 +269,22 @@ public class OlmSessionTest { assertTrue(0!=aliceSession.getOlmSessionId()); // CREATE ALICE OUTBOUND SESSION and encrypt message to bob - assertNotNull(aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey)); + try { + aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } + String helloClearMsg = "Hello I'm Alice!"; - OlmMessage encryptedAliceToBobMsg1 = aliceSession.encryptMessage(helloClearMsg); + OlmMessage encryptedAliceToBobMsg1 = null; + + try { + encryptedAliceToBobMsg1 = aliceSession.encryptMessage(helloClearMsg); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } + assertNotNull(encryptedAliceToBobMsg1); assertNotNull(encryptedAliceToBobMsg1.mCipherText); @@ -279,7 +305,12 @@ public class OlmSessionTest { } // DECRYPT MESSAGE FROM ALICE - String decryptedMsg01 = bobSession.decryptMessage(encryptedAliceToBobMsg1); + String decryptedMsg01 = null; + try { + decryptedMsg01 = bobSession.decryptMessage(encryptedAliceToBobMsg1); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } assertNotNull(decryptedMsg01); // MESSAGE COMPARISON: decrypted vs encrypted @@ -291,19 +322,54 @@ public class OlmSessionTest { String clearMsg3 = "Let's go to the opera."; // bob encrypts messages - OlmMessage encryptedMsg1 = bobSession.encryptMessage(clearMsg1); + OlmMessage encryptedMsg1 = null; + try { + encryptedMsg1 = bobSession.encryptMessage(clearMsg1); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } assertNotNull(encryptedMsg1); - OlmMessage encryptedMsg2 = bobSession.encryptMessage(clearMsg2); + + OlmMessage encryptedMsg2 = null; + try { + encryptedMsg2 = bobSession.encryptMessage(clearMsg2); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } assertNotNull(encryptedMsg2); - OlmMessage encryptedMsg3 = bobSession.encryptMessage(clearMsg3); + + + OlmMessage encryptedMsg3 = null; + try { + encryptedMsg3 = bobSession.encryptMessage(clearMsg3); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } assertNotNull(encryptedMsg3); // alice decrypts bob's messages - String decryptedMsg1 = aliceSession.decryptMessage(encryptedMsg1); + String decryptedMsg1 = null; + try { + decryptedMsg1 = aliceSession.decryptMessage(encryptedMsg1); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } + assertNotNull(decryptedMsg1); - String decryptedMsg2 = aliceSession.decryptMessage(encryptedMsg2); + String decryptedMsg2 = null; + try { + decryptedMsg2 = aliceSession.decryptMessage(encryptedMsg2); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } + assertNotNull(decryptedMsg2); - String decryptedMsg3 = aliceSession.decryptMessage(encryptedMsg3); + String decryptedMsg3 = null; + try { + decryptedMsg3 = aliceSession.decryptMessage(encryptedMsg3); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } assertNotNull(decryptedMsg3); // comparison tests @@ -313,9 +379,22 @@ public class OlmSessionTest { // and one more from alice to bob clearMsg1 = "another message from Alice to Bob!!"; - encryptedMsg1 = aliceSession.encryptMessage(clearMsg1); + encryptedMsg1 = null; + + try { + encryptedMsg1 = aliceSession.encryptMessage(clearMsg1); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } assertNotNull(encryptedMsg1); - decryptedMsg1 = bobSession.decryptMessage(encryptedMsg1); + + decryptedMsg1 = null; + try { + decryptedMsg1 = bobSession.decryptMessage(encryptedMsg1); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } + assertNotNull(decryptedMsg1); assertTrue(clearMsg1.equals(decryptedMsg1)); @@ -378,10 +457,21 @@ public class OlmSessionTest { } assertTrue(0!=bobSession.getOlmSessionId()); - String aliceSessionId = aliceSession.sessionIdentifier(); + String aliceSessionId = null; + try { + aliceSessionId = aliceSession.sessionIdentifier(); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } + assertNotNull(aliceSessionId); - String bobSessionId = bobSession.sessionIdentifier(); + String bobSessionId = null; + try { + bobSessionId = bobSession.sessionIdentifier(); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } assertNotNull(bobSessionId); // must be the same for both ends of the conversation @@ -463,10 +553,21 @@ public class OlmSessionTest { String bobOneTimeKey1 = TestHelper.getOneTimeKey(bobOneTimeKeys, 1); // create alice inbound session for bob - assertTrue(0==aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey1)); + try { + aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey1); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } String aliceClearMsg = "hello helooo to bob!"; - OlmMessage encryptedAliceToBobMsg1 = aliceSession.encryptMessage(aliceClearMsg); + OlmMessage encryptedAliceToBobMsg1 = null; + + try { + encryptedAliceToBobMsg1 = aliceSession.encryptMessage(aliceClearMsg); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } + assertFalse(bobSession.matchesInboundSession(encryptedAliceToBobMsg1.mCipherText)); // init bob session with alice PRE KEY @@ -571,10 +672,20 @@ public class OlmSessionTest { assertTrue(0!=aliceSession.getOlmSessionId()); // CREATE ALICE OUTBOUND SESSION and encrypt message to bob - assertNotNull(aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey)); + try { + aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } + String helloClearMsg = "Hello I'm Alice!"; - OlmMessage encryptedAliceToBobMsg1 = aliceSession.encryptMessage(helloClearMsg); + OlmMessage encryptedAliceToBobMsg1 = null; + try { + encryptedAliceToBobMsg1 = aliceSession.encryptMessage(helloClearMsg); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } assertNotNull(encryptedAliceToBobMsg1); assertNotNull(encryptedAliceToBobMsg1.mCipherText); @@ -595,7 +706,14 @@ public class OlmSessionTest { } // DECRYPT MESSAGE FROM ALICE - String decryptedMsg01 = bobSession.decryptMessage(encryptedAliceToBobMsg1); + String decryptedMsg01 = null; + + try { + decryptedMsg01 = bobSession.decryptMessage(encryptedAliceToBobMsg1); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } + assertNotNull(decryptedMsg01); // MESSAGE COMPARISON: decrypted vs encrypted @@ -607,11 +725,28 @@ public class OlmSessionTest { String clearMsg3 = "Let's go to the opera."; // bob encrypts messages - OlmMessage encryptedMsg1 = bobSession.encryptMessage(clearMsg1); + OlmMessage encryptedMsg1 = null; + try { + encryptedMsg1 = bobSession.encryptMessage(clearMsg1); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } assertNotNull(encryptedMsg1); - OlmMessage encryptedMsg2 = bobSession.encryptMessage(clearMsg2); + + OlmMessage encryptedMsg2 = null; + try { + encryptedMsg2 = bobSession.encryptMessage(clearMsg2); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } assertNotNull(encryptedMsg2); - OlmMessage encryptedMsg3 = bobSession.encryptMessage(clearMsg3); + + OlmMessage encryptedMsg3 = null; + try { + encryptedMsg3 = bobSession.encryptMessage(clearMsg3); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } assertNotNull(encryptedMsg3); // serialize alice session @@ -742,26 +877,70 @@ public class OlmSessionTest { } // SANITY CHECK TESTS FOR: initOutboundSessionWithAccount() - 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)); + String errorMessage = null; + try { + aliceSession.initOutboundSession(null, bobIdentityKey, bobOneTimeKey); + } catch (Exception e) { + errorMessage = e.getMessage(); + } + assertTrue(null != errorMessage); + + errorMessage = null; + try { + aliceSession.initOutboundSession(aliceAccount, null, bobOneTimeKey); + } catch (Exception e) { + errorMessage = e.getMessage(); + } + assertTrue(null != errorMessage); + + errorMessage = null; + try { + aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, null); + } catch (Exception e) { + errorMessage = e.getMessage(); + } + assertTrue(null != errorMessage); + + errorMessage = null; + try { + aliceSession.initOutboundSession(null, null, null); + } catch (Exception e) { + errorMessage = e.getMessage(); + } + assertTrue(null != errorMessage); // init properly - assertTrue(0==aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey)); + errorMessage = null; + try { + aliceSession.initOutboundSession(aliceAccount, bobIdentityKey, bobOneTimeKey); + } catch (Exception e) { + errorMessage = e.getMessage(); + } + assertTrue(null == errorMessage); // SANITY CHECK TESTS FOR: encryptMessage() - assertTrue(null==aliceSession.encryptMessage(null)); + OlmMessage message = null; + try { + message = aliceSession.encryptMessage(null); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } + assertTrue(null==message); // encrypt properly - OlmMessage encryptedMsgToBob = aliceSession.encryptMessage("A message for bob"); + OlmMessage encryptedMsgToBob = null; + try { + encryptedMsgToBob = aliceSession.encryptMessage("A message for bob"); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } assertNotNull(encryptedMsgToBob); // SANITY CHECK TESTS FOR: initInboundSessionWithAccount() OlmSession bobSession = null; try { bobSession = new OlmSession(); - String errorMessage = null; + errorMessage = null; try { bobSession.initInboundSession(null, encryptedMsgToBob.mCipherText); } catch (Exception e) { @@ -802,7 +981,13 @@ public class OlmSessionTest { } // SANITY CHECK TESTS FOR: decryptMessage() - String decryptedMsg = aliceSession.decryptMessage(null); + String decryptedMsg = null; + try { + decryptedMsg = aliceSession.decryptMessage(null); + } catch (Exception e) { + assertTrue(e.getMessage(), false); + } + assertTrue(null==decryptedMsg); // SANITY CHECK TESTS FOR: matchesInboundSession() diff --git a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmException.java b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmException.java index 1a1b8ab..a6f1805 100644 --- a/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmException.java +++ b/java/android/OlmLibSdk/olm-sdk/src/main/java/org/matrix/olm/OlmException.java @@ -24,41 +24,40 @@ import java.io.IOException; */ public class OlmException extends IOException { // exception codes - public static final int EXCEPTION_CODE_CREATE_OUTBOUND_GROUP_SESSION = 0; - public static final int EXCEPTION_CODE_CREATE_INBOUND_GROUP_SESSION = 1; - public static final int EXCEPTION_CODE_INIT_OUTBOUND_GROUP_SESSION = 2; - public static final int EXCEPTION_CODE_INIT_INBOUND_GROUP_SESSION = 3; - public static final int EXCEPTION_CODE_ACCOUNT_SERIALIZATION = 4; - public static final int EXCEPTION_CODE_ACCOUNT_DESERIALIZATION = 5; - public static final int EXCEPTION_CODE_SESSION_SERIALIZATION = 6; - public static final int EXCEPTION_CODE_SESSION_DESERIALIZATION = 7; - public static final int EXCEPTION_CODE_INIT_ACCOUNT_CREATION = 8; - public static final int EXCEPTION_CODE_INIT_SESSION_CREATION = 9; - public static final int EXCEPTION_CODE_OUTBOUND_GROUP_SESSION_SERIALIZATION = 10; - public static final int EXCEPTION_CODE_OUTBOUND_GROUP_SESSION_DESERIALIZATION = 11; - public static final int EXCEPTION_CODE_INBOUND_GROUP_SESSION_SERIALIZATION = 12; - public static final int EXCEPTION_CODE_INBOUND_GROUP_SESSION_DESERIALIZATION = 13; - public static final int EXCEPTION_CODE_ACCOUNT_IDENTITY_KEYS = 20; - public static final int EXCEPTION_CODE_ACCOUNT_GENERATE_ONE_TIME_KEYS = 21; - public static final int EXCEPTION_CODE_ACCOUNT_ONE_TIME_KEYS = 22; - public static final int EXCEPTION_CODE_ACCOUNT_REMOVE_ONE_TIME_KEYS = 23; - public static final int EXCEPTION_CODE_ACCOUNT_MARK_ONE_KEYS_AS_PUBLISHED = 24; - public static final int EXCEPTION_CODE_ACCOUNT_SIGN_MESSAGE = 25; + public static final int EXCEPTION_CODE_INIT_ACCOUNT_CREATION = 10; - public static final int EXCEPTION_CODE_SESSION_IDENTIFIER = 30; - public static final int EXCEPTION_CODE_SESSION_DECRYPT_SESSION = 31; + public static final int EXCEPTION_CODE_ACCOUNT_SERIALIZATION = 20; + public static final int EXCEPTION_CODE_ACCOUNT_DESERIALIZATION = 21; + public static final int EXCEPTION_CODE_ACCOUNT_IDENTITY_KEYS = 22; + public static final int EXCEPTION_CODE_ACCOUNT_GENERATE_ONE_TIME_KEYS = 23; + public static final int EXCEPTION_CODE_ACCOUNT_ONE_TIME_KEYS = 24; + public static final int EXCEPTION_CODE_ACCOUNT_REMOVE_ONE_TIME_KEYS = 25; + public static final int EXCEPTION_CODE_ACCOUNT_MARK_ONE_KEYS_AS_PUBLISHED = 26; + public static final int EXCEPTION_CODE_ACCOUNT_SIGN_MESSAGE = 27; - public static final int EXCEPTION_CODE_OUTBOUND_GROUP_SESSION_IDENTIFIER = 40; - public static final int EXCEPTION_CODE_OUTBOUND_GROUP_SESSION_KEY = 41; - public static final int EXCEPTION_CODE_OUTBOUND_GROUP_ENCRYPT_MESSAGE = 42; + public static final int EXCEPTION_CODE_CREATE_INBOUND_GROUP_SESSION = 30; + public static final int EXCEPTION_CODE_INIT_INBOUND_GROUP_SESSION = 31; + public static final int EXCEPTION_CODE_INBOUND_GROUP_SESSION_IDENTIFIER = 32; + public static final int EXCEPTION_CODE_INBOUND_GROUP_SESSION_DECRYPT_SESSION = 33; + + public static final int EXCEPTION_CODE_CREATE_OUTBOUND_GROUP_SESSION = 40; + public static final int EXCEPTION_CODE_INIT_OUTBOUND_GROUP_SESSION = 41; + public static final int EXCEPTION_CODE_OUTBOUND_GROUP_SESSION_IDENTIFIER = 42; + public static final int EXCEPTION_CODE_OUTBOUND_GROUP_SESSION_KEY = 43; + public static final int EXCEPTION_CODE_OUTBOUND_GROUP_ENCRYPT_MESSAGE = 44; + + public static final int EXCEPTION_CODE_INIT_SESSION_CREATION = 50; + public static final int EXCEPTION_CODE_SESSION_INIT_OUTBOUND_SESSION = 51; + public static final int EXCEPTION_CODE_SESSION_INIT_INBOUND_SESSION = 52; + public static final int EXCEPTION_CODE_SESSION_INIT_INBOUND_SESSION_FROM = 53; + public static final int EXCEPTION_CODE_SESSION_ENCRYPT_MESSAGE = 54; + public static final int EXCEPTION_CODE_SESSION_DECRYPT_MESSAGE = 55; + public static final int EXCEPTION_CODE_SESSION_SESSION_IDENTIFIER = 56; // exception human readable messages public static final String EXCEPTION_MSG_NEW_OUTBOUND_GROUP_SESSION = "createNewSession() failed"; public static final String EXCEPTION_MSG_NEW_INBOUND_GROUP_SESSION = "createNewSession() failed"; - public static final String EXCEPTION_MSG_INIT_OUTBOUND_GROUP_SESSION = "initOutboundGroupSession() failed"; - public static final String EXCEPTION_MSG_INIT_INBOUND_GROUP_SESSION = " initInboundGroupSessionWithSessionKey() failed"; - public static final String EXCEPTION_MSG_INIT_NEW_ACCOUNT_DESERIALIZATION = "initNewAccount() failure"; public static final String EXCEPTION_MSG_INVALID_PARAMS_DESERIALIZATION = "invalid de-serialized parameters"; public static final String EXCEPTION_MSG_INIT_ACCOUNT_CREATION = "initNewAccount() failed"; public static final String EXCEPTION_MSG_INIT_SESSION_CREATION = "initNewSession() failed"; 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 7ac38b2..41eeba1 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 @@ -141,7 +141,7 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri return new String(sessionIdentifierJni(), "UTF-8"); } catch (Exception e) { Log.e(LOG_TAG, "## sessionIdentifier() failed " + e.getMessage()); - throw new OlmException(OlmException.EXCEPTION_CODE_SESSION_IDENTIFIER, e.getMessage()); + throw new OlmException(OlmException.EXCEPTION_CODE_INBOUND_GROUP_SESSION_IDENTIFIER, e.getMessage()); } } @@ -165,7 +165,7 @@ public class OlmInboundGroupSession extends CommonSerializeUtils implements Seri } } catch (Exception e) { Log.e(LOG_TAG, "## decryptMessage() failed " + e.getMessage()); - throw new OlmException(OlmException.EXCEPTION_CODE_SESSION_DECRYPT_SESSION, e.getMessage()); + throw new OlmException(OlmException.EXCEPTION_CODE_INBOUND_GROUP_SESSION_DECRYPT_SESSION, e.getMessage()); } return result; 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 36a95a1..9138309 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 @@ -124,25 +124,23 @@ public class OlmSession extends CommonSerializeUtils implements Serializable { * @param aAccount the account to associate with this session * @param aTheirIdentityKey the identity key of the recipient * @param aTheirOneTimeKey the one time key of the recipient - * @return 0 if operation succeed, -1 otherwise + * @exception OlmException the failure reason */ - public int initOutboundSession(OlmAccount aAccount, String aTheirIdentityKey, String aTheirOneTimeKey) { - int retCode=-1; - + public void initOutboundSession(OlmAccount aAccount, String aTheirIdentityKey, String aTheirOneTimeKey) throws OlmException { if ((null == aAccount) || TextUtils.isEmpty(aTheirIdentityKey) || TextUtils.isEmpty(aTheirOneTimeKey)) { Log.e(LOG_TAG, "## initOutboundSession(): invalid input parameters"); + throw new OlmException(OlmException.EXCEPTION_CODE_SESSION_INIT_OUTBOUND_SESSION, "invalid input parameters"); } else { try { - retCode = initOutboundSessionJni(aAccount.getOlmAccountId(), aTheirIdentityKey.getBytes("UTF-8"), aTheirOneTimeKey.getBytes("UTF-8")); + initOutboundSessionJni(aAccount.getOlmAccountId(), aTheirIdentityKey.getBytes("UTF-8"), aTheirOneTimeKey.getBytes("UTF-8")); } catch (Exception e) { Log.e(LOG_TAG, "## initOutboundSession(): " + e.getMessage()); + throw new OlmException(OlmException.EXCEPTION_CODE_SESSION_INIT_OUTBOUND_SESSION, e.getMessage()); } } - - return retCode; } - private native int initOutboundSessionJni(long aOlmAccountId, byte[] aTheirIdentityKey, byte[] aTheirOneTimeKey); + private native void initOutboundSessionJni(long aOlmAccountId, byte[] aTheirIdentityKey, byte[] aTheirOneTimeKey); /** * Create a new in-bound session for sending/receiving messages from an @@ -150,29 +148,23 @@ public class OlmSession extends CommonSerializeUtils implements Serializable { * This API may be used to process a "m.room.encrypted" event when type = 1 (PRE_KEY). * @param aAccount the account to associate with this session * @param aPreKeyMsg PRE KEY message - * @exception Exception the failure reason + * @exception OlmException the failure reason */ - public void initInboundSession(OlmAccount aAccount, String aPreKeyMsg) throws Exception { + public void initInboundSession(OlmAccount aAccount, String aPreKeyMsg) throws OlmException { if ((null == aAccount) || TextUtils.isEmpty(aPreKeyMsg)){ Log.e(LOG_TAG, "## initInboundSession(): invalid input parameters"); - throw new Exception("invalid input parameters"); + throw new OlmException(OlmException.EXCEPTION_CODE_SESSION_INIT_INBOUND_SESSION, "invalid input parameters"); } else { - StringBuffer errorMsg = new StringBuffer(); - try { - initInboundSessionJni(aAccount.getOlmAccountId(), aPreKeyMsg.getBytes("UTF-8"), errorMsg); + initInboundSessionJni(aAccount.getOlmAccountId(), aPreKeyMsg.getBytes("UTF-8")); } catch (Exception e) { Log.e(LOG_TAG, "## initInboundSession(): " + e.getMessage()); - errorMsg.append(errorMsg); - } - - if (errorMsg.length() != 0) { - throw new Exception(errorMsg.toString()); + throw new OlmException(OlmException.EXCEPTION_CODE_SESSION_INIT_INBOUND_SESSION, e.getMessage()); } } } - private native int initInboundSessionJni(long aOlmAccountId, byte[] aOneTimeKeyMsg, StringBuffer aErrorMsg); + private native void initInboundSessionJni(long aOlmAccountId, byte[] aOneTimeKeyMsg); /** * Create a new in-bound session for sending/receiving messages from an @@ -183,38 +175,42 @@ public class OlmSession extends CommonSerializeUtils implements Serializable { * @param aAccount the account to associate with this session * @param aTheirIdentityKey the sender identity key * @param aPreKeyMsg PRE KEY message - * @return 0 if operation succeed, -1 otherwise + * @exception OlmException the failure reason */ - public int initInboundSessionFrom(OlmAccount aAccount, String aTheirIdentityKey, String aPreKeyMsg) { - int retCode=-1; - - if((null==aAccount) || TextUtils.isEmpty(aPreKeyMsg)){ + public void initInboundSessionFrom(OlmAccount aAccount, String aTheirIdentityKey, String aPreKeyMsg) throws OlmException { + if ( (null==aAccount) || TextUtils.isEmpty(aPreKeyMsg)){ Log.e(LOG_TAG, "## initInboundSessionFrom(): invalid input parameters"); + throw new OlmException(OlmException.EXCEPTION_CODE_SESSION_INIT_INBOUND_SESSION_FROM, "invalid input parameters"); } else { try { - retCode = initInboundSessionFromIdKeyJni(aAccount.getOlmAccountId(), aTheirIdentityKey.getBytes("UTF-8"), aPreKeyMsg.getBytes("UTF-8")); + initInboundSessionFromIdKeyJni(aAccount.getOlmAccountId(), aTheirIdentityKey.getBytes("UTF-8"), aPreKeyMsg.getBytes("UTF-8")); } catch (Exception e) { Log.e(LOG_TAG, "## initInboundSessionFrom(): " + e.getMessage()); + throw new OlmException(OlmException.EXCEPTION_CODE_SESSION_INIT_INBOUND_SESSION_FROM, e.getMessage()); } } - - return retCode; } - private native int initInboundSessionFromIdKeyJni(long aOlmAccountId, byte[] aTheirIdentityKey, byte[] aOneTimeKeyMsg); + private native void initInboundSessionFromIdKeyJni(long aOlmAccountId, byte[] aTheirIdentityKey, byte[] aOneTimeKeyMsg); /** * Get the session identifier.<br> Will be the same for both ends of the * conversation. The session identifier is returned as a String object. * Session Id sample: "session_id":"M4fOVwD6AABrkTKl" * Public API for {@link #getSessionIdentifierJni()}. - * @return the session ID as a String if operation succeed, null otherwise + * @return the session ID + * @exception OlmException the failure reason */ - public String sessionIdentifier() { + public String sessionIdentifier() throws OlmException { try { - return new String(getSessionIdentifierJni(), "UTF-8"); + byte[] buffer = getSessionIdentifierJni(); + + if (null != buffer) { + return new String(buffer, "UTF-8"); + } } catch (Exception e) { Log.e(LOG_TAG, "## sessionIdentifier(): " + e.getMessage()); + throw new OlmException(OlmException.EXCEPTION_CODE_SESSION_SESSION_IDENTIFIER, e.getMessage()); } return null; @@ -272,39 +268,46 @@ public class OlmSession extends CommonSerializeUtils implements Serializable { * The encrypted message is returned in a OlmMessage object. * Public API for {@link #encryptMessageJni(byte[], OlmMessage)}. * @param aClearMsg message to encrypted - * @return the encrypted message if operation succeed, null otherwise + * @return the encrypted message + * @exception OlmException the failure reason */ - public OlmMessage encryptMessage(String aClearMsg) { + public OlmMessage encryptMessage(String aClearMsg) throws OlmException { + if (null == aClearMsg) { + return null; + } + OlmMessage encryptedMsgRetValue = new OlmMessage(); try { - if (0 != encryptMessageJni(aClearMsg.getBytes("UTF-8"), encryptedMsgRetValue)) { - encryptedMsgRetValue = null; - } + encryptMessageJni(aClearMsg.getBytes("UTF-8"), encryptedMsgRetValue); } catch (Exception e) { Log.e(LOG_TAG, "## encryptMessage(): failed " + e.getMessage()); - encryptedMsgRetValue = null; + throw new OlmException(OlmException.EXCEPTION_CODE_SESSION_ENCRYPT_MESSAGE, e.getMessage()); } return encryptedMsgRetValue; } - private native int encryptMessageJni(byte[] aClearMsg, OlmMessage aEncryptedMsg); + private native void encryptMessageJni(byte[] aClearMsg, OlmMessage aEncryptedMsg); /** * Decrypt a message using the session.<br> * The encrypted message is given as a OlmMessage object. * @param aEncryptedMsg message to decrypt - * @return the decrypted message if operation succeed, null otherwise + * @return the decrypted message + * @exception OlmException the failure reason */ - public String decryptMessage(OlmMessage aEncryptedMsg) { + public String decryptMessage(OlmMessage aEncryptedMsg) throws OlmException { + if (null == aEncryptedMsg) { + return null; + } + try { return new String(decryptMessageJni(aEncryptedMsg), "UTF-8"); } catch (Exception e) { Log.e(LOG_TAG, "## decryptMessage(): failed " + e.getMessage()); + throw new OlmException(OlmException.EXCEPTION_CODE_SESSION_DECRYPT_MESSAGE, e.getMessage()); } - - return null; } private native byte[] decryptMessageJni(OlmMessage aEncryptedMsg); @@ -353,7 +356,7 @@ public class OlmSession extends CommonSerializeUtils implements Serializable { } else { aErrorMsg.setLength(0); try { - pickleRetValue = serializeJni(aKey.getBytes("UTF-8"), aErrorMsg); + pickleRetValue = serializeJni(aKey.getBytes("UTF-8")); } catch (Exception e) { Log.e(LOG_TAG,"## serializeDataWithKey(): failed " + e.getMessage()); aErrorMsg.append(e.getMessage()); @@ -362,7 +365,7 @@ public class OlmSession extends CommonSerializeUtils implements Serializable { return pickleRetValue; } - private native String serializeJni(byte[] aKey, StringBuffer aErrorMsg); + private native String serializeJni(byte[] aKey); /** * Loads an account from a pickled base64 string.<br> 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 4a1717a..f09ace6 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 @@ -105,25 +105,27 @@ JNIEXPORT jlong OLM_SESSION_FUNC_DEF(initNewSessionJni)(JNIEnv *env, jobject thi * @param aOlmAccountId account instance * @param aTheirIdentityKey the identity key of the recipient * @param aTheirOneTimeKey the one time key of the recipient -* @return ERROR_CODE_OK if operation succeed, ERROR_CODE_KO otherwise **/ -JNIEXPORT jint OLM_SESSION_FUNC_DEF(initOutboundSessionJni)(JNIEnv *env, jobject thiz, jlong aOlmAccountId, jbyteArray aTheirIdentityKeyBuffer, jbyteArray aTheirOneTimeKeyBuffer) +JNIEXPORT void OLM_SESSION_FUNC_DEF(initOutboundSessionJni)(JNIEnv *env, jobject thiz, jlong aOlmAccountId, jbyteArray aTheirIdentityKeyBuffer, jbyteArray aTheirOneTimeKeyBuffer) { - jint retCode = ERROR_CODE_KO; + const char* errorMessage = NULL; OlmSession* sessionPtr = NULL; OlmAccount* accountPtr = NULL; if (!(sessionPtr = (OlmSession*)getSessionInstanceId(env,thiz))) { LOGE("## initOutboundSessionJni(): failure - invalid Session ptr=NULL"); + errorMessage = "invalid Session ptr=NULL"; } else if (!(accountPtr = (OlmAccount*)aOlmAccountId)) { LOGE("## initOutboundSessionJni(): failure - invalid Account ptr=NULL"); + errorMessage = "invalid Account ptr=NULL"; } else if (!aTheirIdentityKeyBuffer || !aTheirOneTimeKeyBuffer) { LOGE("## initOutboundSessionJni(): failure - invalid keys"); + errorMessage = "invalid keys"; } else { @@ -135,6 +137,7 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(initOutboundSessionJni)(JNIEnv *env, jobject if ( (0 != randomSize) && !setRandomInBuffer(env, &randomBuffPtr, randomSize)) { LOGE("## initOutboundSessionJni(): failure - random buffer init"); + errorMessage = "random buffer init"; } else { @@ -145,10 +148,12 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(initOutboundSessionJni)(JNIEnv *env, jobject if (!(theirIdentityKeyPtr = env->GetByteArrayElements(aTheirIdentityKeyBuffer, 0))) { LOGE("## initOutboundSessionJni(): failure - identityKey JNI allocation OOM"); + errorMessage = "identityKey JNI allocation OOM"; } else if (!(theirOneTimeKeyPtr = env->GetByteArrayElements(aTheirOneTimeKeyBuffer, 0))) { LOGE("## initOutboundSessionJni(): failure - one time Key JNI allocation OOM"); + errorMessage = "one time Key JNI allocation OOM"; } else { @@ -165,11 +170,11 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(initOutboundSessionJni)(JNIEnv *env, jobject (void*)randomBuffPtr, randomSize); if (sessionResult == olm_error()) { - LOGE("## initOutboundSessionJni(): failure - session creation Msg=%s",(const char *)olm_session_last_error(sessionPtr)); + errorMessage = (const char *)olm_session_last_error(sessionPtr); + LOGE("## initOutboundSessionJni(): failure - session creation Msg=%s", errorMessage); } else { - retCode = ERROR_CODE_OK; LOGD("## initOutboundSessionJni(): success - result=%lu", static_cast<long unsigned int>(sessionResult)); } } @@ -191,7 +196,10 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(initOutboundSessionJni)(JNIEnv *env, jobject } } - return retCode; + if (errorMessage) + { + env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage); + } } @@ -203,40 +211,28 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(initOutboundSessionJni)(JNIEnv *env, jobject * incoming PRE_KEY message.<br> * @param aOlmAccountId account instance * @param aOneTimeKeyMsg PRE_KEY message - * @return ERROR_CODE_OK if operation succeed, ERROR_CODE_KO otherwise */ -JNIEXPORT jint OLM_SESSION_FUNC_DEF(initInboundSessionJni)(JNIEnv *env, jobject thiz, jlong aOlmAccountId, jbyteArray aOneTimeKeyMsgBuffer, jobject aErrorMsg) +JNIEXPORT void OLM_SESSION_FUNC_DEF(initInboundSessionJni)(JNIEnv *env, jobject thiz, jlong aOlmAccountId, jbyteArray aOneTimeKeyMsgBuffer) { - jint retCode = ERROR_CODE_KO; + const char* errorMessage = NULL; OlmSession *sessionPtr = NULL; OlmAccount *accountPtr = NULL; size_t sessionResult; - jclass errorMsgJClass = 0; - jmethodID errorMsgMethodId = 0; if (!(sessionPtr = (OlmSession*)getSessionInstanceId(env,thiz))) { LOGE("## initInboundSessionJni(): failure - invalid Session ptr=NULL"); + errorMessage = "invalid Session ptr=NULL"; } else if (!(accountPtr = (OlmAccount*)aOlmAccountId)) { LOGE("## initInboundSessionJni(): failure - invalid Account ptr=NULL"); + errorMessage = "invalid Account ptr=NULL"; } else if (!aOneTimeKeyMsgBuffer) { LOGE("## initInboundSessionJni(): failure - invalid message"); - } - else if (!aErrorMsg) - { - LOGE(" ## initInboundSessionJni(): failure - invalid error output"); - } - else if (!(errorMsgJClass = env->GetObjectClass(aErrorMsg))) - { - LOGE(" ## initInboundSessionJni(): failure - unable to get error class"); - } - else if (!(errorMsgMethodId = env->GetMethodID(errorMsgJClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;"))) - { - LOGE(" ## initInboundSessionJni(): failure - unable to get error method ID"); + errorMessage = "invalid message"; } else { @@ -245,6 +241,7 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(initInboundSessionJni)(JNIEnv *env, jobject if (!messagePtr) { LOGE("## initInboundSessionJni(): failure - message JNI allocation OOM"); + errorMessage = "message JNI allocation OOM"; } else { @@ -255,19 +252,11 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(initInboundSessionJni)(JNIEnv *env, jobject if (sessionResult == olm_error()) { - const char *errorMsgPtr = olm_session_last_error(sessionPtr); - LOGE("## initInboundSessionJni(): failure - init inbound session creation Msg=%s", errorMsgPtr); - - jstring errorJstring = env->NewStringUTF(errorMsgPtr); - - if (errorJstring) - { - env->CallObjectMethod(aErrorMsg, errorMsgMethodId, errorJstring); - } + errorMessage = olm_session_last_error(sessionPtr); + LOGE("## initInboundSessionJni(): failure - init inbound session creation Msg=%s", errorMessage); } else { - retCode = ERROR_CODE_OK; LOGD("## initInboundSessionJni(): success - result=%lu", static_cast<long unsigned int>(sessionResult)); } @@ -275,7 +264,11 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(initInboundSessionJni)(JNIEnv *env, jobject env->ReleaseByteArrayElements(aOneTimeKeyMsgBuffer, messagePtr, JNI_ABORT); } } - return retCode; + + if (errorMessage) + { + env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage); + } } /** @@ -284,11 +277,11 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(initInboundSessionJni)(JNIEnv *env, jobject * @param aOlmAccountId account instance * @param aTheirIdentityKey the identity key of the recipient * @param aOneTimeKeyMsg encrypted message - * @return ERROR_CODE_OK if operation succeed, ERROR_CODE_KO otherwise */ -JNIEXPORT jint OLM_SESSION_FUNC_DEF(initInboundSessionFromIdKeyJni)(JNIEnv *env, jobject thiz, jlong aOlmAccountId, jbyteArray aTheirIdentityKeyBuffer, jbyteArray aOneTimeKeyMsgBuffer) +JNIEXPORT void OLM_SESSION_FUNC_DEF(initInboundSessionFromIdKeyJni)(JNIEnv *env, jobject thiz, jlong aOlmAccountId, jbyteArray aTheirIdentityKeyBuffer, jbyteArray aOneTimeKeyMsgBuffer) { - jint retCode = ERROR_CODE_KO; + const char* errorMessage = NULL; + OlmSession *sessionPtr = NULL; OlmAccount *accountPtr = NULL; jbyte *messagePtr = NULL; @@ -298,26 +291,32 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(initInboundSessionFromIdKeyJni)(JNIEnv *env, if (!(sessionPtr = (OlmSession*)getSessionInstanceId(env,thiz))) { LOGE("## initInboundSessionFromIdKeyJni(): failure - invalid Session ptr=NULL"); + errorMessage = "invalid Session ptr=NULL"; } else if (!(accountPtr = (OlmAccount*)aOlmAccountId)) { LOGE("## initInboundSessionFromIdKeyJni(): failure - invalid Account ptr=NULL"); + errorMessage = "invalid Account ptr=NULL"; } else if (!aTheirIdentityKeyBuffer) { LOGE("## initInboundSessionFromIdKeyJni(): failure - invalid theirIdentityKey"); + errorMessage = "invalid theirIdentityKey"; } else if (!aOneTimeKeyMsgBuffer) { LOGE("## initInboundSessionJni(): failure - invalid one time key message"); + errorMessage = "invalid invalid one time key message"; } else if (!(messagePtr = env->GetByteArrayElements(aOneTimeKeyMsgBuffer, 0))) { LOGE("## initInboundSessionFromIdKeyJni(): failure - message JNI allocation OOM"); + errorMessage = "message JNI allocation OOM"; } else if(!(theirIdentityKeyPtr = env->GetByteArrayElements(aTheirIdentityKeyBuffer, 0))) { LOGE("## initInboundSessionFromIdKeyJni(): failure - theirIdentityKey JNI allocation OOM"); + errorMessage = "theirIdentityKey JNI allocation OOM"; } else { @@ -329,11 +328,11 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(initInboundSessionFromIdKeyJni)(JNIEnv *env, sessionResult = olm_create_inbound_session_from(sessionPtr, accountPtr, theirIdentityKeyPtr, theirIdentityKeyLength, (void*)messagePtr , messageLength); if (sessionResult == olm_error()) { - LOGE("## initInboundSessionFromIdKeyJni(): failure - init inbound session creation Msg=%s",(const char *)olm_session_last_error(sessionPtr)); + errorMessage = (const char *)olm_session_last_error(sessionPtr); + LOGE("## initInboundSessionFromIdKeyJni(): failure - init inbound session creation Msg=%s", errorMessage); } else { - retCode = ERROR_CODE_OK; LOGD("## initInboundSessionFromIdKeyJni(): success - result=%lu", static_cast<long unsigned int>(sessionResult)); } } @@ -349,7 +348,10 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(initInboundSessionFromIdKeyJni)(JNIEnv *env, env->ReleaseByteArrayElements(aTheirIdentityKeyBuffer, theirIdentityKeyPtr, JNI_ABORT); } - return retCode; + if (errorMessage) + { + env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage); + } } /** @@ -475,11 +477,11 @@ JNIEXPORT jint JNICALL OLM_SESSION_FUNC_DEF(matchesInboundSessionFromIdKeyJni)(J * Encrypt a message using the session.<br> * @param aClearMsg clear text message * @param [out] aEncryptedMsg ciphered message - * @return ERROR_CODE_OK if encrypt operation succeed, ERROR_CODE_KO otherwise */ -JNIEXPORT jint OLM_SESSION_FUNC_DEF(encryptMessageJni)(JNIEnv *env, jobject thiz, jbyteArray aClearMsgBuffer, jobject aEncryptedMsg) +JNIEXPORT void OLM_SESSION_FUNC_DEF(encryptMessageJni)(JNIEnv *env, jobject thiz, jbyteArray aClearMsgBuffer, jobject aEncryptedMsg) { - jint retCode = ERROR_CODE_KO; + const char* errorMessage = NULL; + OlmSession *sessionPtr = NULL; jbyte *clearMsgPtr = NULL; jclass encryptedMsgJClass = 0; @@ -491,10 +493,12 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(encryptMessageJni)(JNIEnv *env, jobject thiz if (!(sessionPtr = (OlmSession*)getSessionInstanceId(env,thiz))) { LOGE("## encryptMessageJni(): failure - invalid Session ptr=NULL"); + errorMessage = "invalid Session ptr=NULL"; } else if (!aClearMsgBuffer) { LOGE("## encryptMessageJni(): failure - invalid clear message"); + errorMessage = "invalid clear message"; } else if (!aEncryptedMsg) { @@ -503,18 +507,22 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(encryptMessageJni)(JNIEnv *env, jobject thiz else if (!(clearMsgPtr = env->GetByteArrayElements(aClearMsgBuffer, 0))) { LOGE("## encryptMessageJni(): failure - clear message JNI allocation OOM"); + errorMessage = "clear message JNI allocation OOM"; } else if (!(encryptedMsgJClass = env->GetObjectClass(aEncryptedMsg))) { LOGE("## encryptMessageJni(): failure - unable to get crypted message class"); + errorMessage = "unable to get crypted message class"; } else if (!(encryptedMsgFieldId = env->GetFieldID(encryptedMsgJClass,"mCipherText","Ljava/lang/String;"))) { LOGE("## encryptMessageJni(): failure - unable to get message field"); + errorMessage = "unable to get message field"; } else if (!(typeMsgFieldId = env->GetFieldID(encryptedMsgJClass,"mType","J"))) { LOGE("## encryptMessageJni(): failure - unable to get message type field"); + errorMessage = "unable to get message type field"; } else { @@ -532,6 +540,7 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(encryptMessageJni)(JNIEnv *env, jobject thiz if ((0 != randomLength) && !setRandomInBuffer(env, &randomBuffPtr, randomLength)) { LOGE("## encryptMessageJni(): failure - random buffer init"); + errorMessage = "random buffer init"; } else { @@ -544,6 +553,7 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(encryptMessageJni)(JNIEnv *env, jobject thiz if (!encryptedMsgPtr) { LOGE("## encryptMessageJni(): failure - encryptedMsgPtr buffer OOM"); + errorMessage = "encryptedMsgPtr buffer OOM"; } else { @@ -563,7 +573,8 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(encryptMessageJni)(JNIEnv *env, jobject thiz encryptedMsgLength); if (result == olm_error()) { - LOGE("## encryptMessageJni(): failure - Msg=%s",(const char *)olm_session_last_error(sessionPtr)); + errorMessage = (const char *)olm_session_last_error(sessionPtr); + LOGE("## encryptMessageJni(): failure - Msg=%s", errorMessage); } else { @@ -577,7 +588,6 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(encryptMessageJni)(JNIEnv *env, jobject thiz jstring encryptedJstring = env->NewStringUTF((const char*)encryptedMsgPtr); env->SetObjectField(aEncryptedMsg, encryptedMsgFieldId, (jobject)encryptedJstring); - retCode = ERROR_CODE_OK; LOGD("## encryptMessageJni(): success - result=%lu Type=%lu utfLength=%lu encryptedMsg=%s", static_cast<long unsigned int>(result), static_cast<long unsigned int>(messageType), static_cast<long unsigned int>((size_t)env->GetStringUTFLength(encryptedJstring)), (const char*)encryptedMsgPtr); } @@ -594,16 +604,21 @@ JNIEXPORT jint OLM_SESSION_FUNC_DEF(encryptMessageJni)(JNIEnv *env, jobject thiz env->ReleaseByteArrayElements(aClearMsgBuffer, clearMsgPtr, JNI_ABORT); } - return retCode; + if (errorMessage) + { + env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage); + } } /** * Decrypt a message using the session.<br> * @param aEncryptedMsg message to decrypt - * @return decrypted message if operation succeed, null otherwise + * @return decrypted message if operation succeed */ JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(decryptMessageJni)(JNIEnv *env, jobject thiz, jobject aEncryptedMsg) { + const char* errorMessage = NULL; + jbyteArray decryptedMsgRet = 0; jclass encryptedMsgJClass = 0; @@ -622,30 +637,37 @@ JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(decryptMessageJni)(JNIEnv *env, jobjec if (!(sessionPtr = (OlmSession*)getSessionInstanceId(env,thiz))) { LOGE("## decryptMessageJni(): failure - invalid Session ptr=NULL"); + errorMessage = "invalid Session ptr=NULL"; } else if (!aEncryptedMsg) { LOGE("## decryptMessageJni(): failure - invalid encrypted message"); + errorMessage = "invalid encrypted message"; } else if (!(encryptedMsgJClass = env->GetObjectClass(aEncryptedMsg))) { LOGE("## decryptMessageJni(): failure - unable to get encrypted message class"); + errorMessage = "unable to get encrypted message class"; } else if (!(encryptedMsgFieldId = env->GetFieldID(encryptedMsgJClass,"mCipherText","Ljava/lang/String;"))) { LOGE("## decryptMessageJni(): failure - unable to get message field"); + errorMessage = "unable to get message field"; } else if (!(typeMsgFieldId = env->GetFieldID(encryptedMsgJClass,"mType","J"))) { LOGE("## decryptMessageJni(): failure - unable to get message type field"); + errorMessage = "unable to get message type field"; } else if (!(encryptedMsgJstring = (jstring)env->GetObjectField(aEncryptedMsg, encryptedMsgFieldId))) { LOGE("## decryptMessageJni(): failure - JNI encrypted object "); + errorMessage = "JNI encrypted object"; } else if (!(encryptedMsgPtr = env->GetStringUTFChars(encryptedMsgJstring, 0))) { LOGE("## decryptMessageJni(): failure - encrypted message JNI allocation OOM"); + errorMessage = "encrypted message JNI allocation OOM"; } else { @@ -668,7 +690,8 @@ JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(decryptMessageJni)(JNIEnv *env, jobjec if (maxPlainTextLength == olm_error()) { - LOGE("## decryptMessageJni(): failure - olm_decrypt_max_plaintext_length Msg=%s",(const char *)olm_session_last_error(sessionPtr)); + errorMessage = (const char *)olm_session_last_error(sessionPtr); + LOGE("## decryptMessageJni(): failure - olm_decrypt_max_plaintext_length Msg=%s", errorMessage); } else { @@ -687,7 +710,8 @@ JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(decryptMessageJni)(JNIEnv *env, jobjec maxPlainTextLength); if (plaintextLength == olm_error()) { - LOGE("## decryptMessageJni(): failure - olm_decrypt Msg=%s",(const char *)olm_session_last_error(sessionPtr)); + errorMessage = (const char *)olm_session_last_error(sessionPtr); + LOGE("## decryptMessageJni(): failure - olm_decrypt Msg=%s", errorMessage); } else { @@ -715,6 +739,11 @@ JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(decryptMessageJni)(JNIEnv *env, jobjec free(plainTextMsgPtr); } + if (errorMessage) + { + env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage); + } + return decryptedMsgRet; } @@ -725,6 +754,7 @@ JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(decryptMessageJni)(JNIEnv *env, jobjec */ JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(getSessionIdentifierJni)(JNIEnv *env, jobject thiz) { + const char* errorMessage = NULL; jbyteArray returnValue = 0; LOGD("## getSessionIdentifierJni(): IN "); @@ -734,6 +764,7 @@ JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(getSessionIdentifierJni)(JNIEnv *env, if (!sessionPtr) { LOGE("## getSessionIdentifierJni(): failure - invalid Session ptr=NULL"); + errorMessage = "invalid Session ptr=NULL"; } else { @@ -746,6 +777,7 @@ JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(getSessionIdentifierJni)(JNIEnv *env, if (!sessionIdPtr) { LOGE("## getSessionIdentifierJni(): failure - identifier allocation OOM"); + errorMessage = "identifier allocation OOM"; } else { @@ -753,7 +785,8 @@ JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(getSessionIdentifierJni)(JNIEnv *env, if (result == olm_error()) { - LOGE("## getSessionIdentifierJni(): failure - get session identifier failure Msg=%s",(const char *)olm_session_last_error(sessionPtr)); + errorMessage = (const char *)olm_session_last_error(sessionPtr); + LOGE("## getSessionIdentifierJni(): failure - get session identifier failure Msg=%s", errorMessage); } else { @@ -770,6 +803,11 @@ JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(getSessionIdentifierJni)(JNIEnv *env, } } + if (errorMessage) + { + env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage); + } + return returnValue; } @@ -777,15 +815,13 @@ JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(getSessionIdentifierJni)(JNIEnv *env, /** * Serialize and encrypt session instance into a base64 string.<br> * @param aKey key used to encrypt the serialized session data -* @param[out] aErrorMsg error message set if operation failed * @return a base64 string if operation succeed, null otherwise **/ -JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer, jobject aErrorMsg) +JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKeyBuffer) { + const char* errorMessage = NULL; + jstring pickledDataRetValue = 0; - jclass errorMsgJClass = 0; - jmethodID errorMsgMethodId = 0; - jstring errorJstring = 0; jbyte* keyPtr = NULL; OlmSession* sessionPtr = NULL; @@ -794,26 +830,17 @@ JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, if (!(sessionPtr = (OlmSession*)getSessionInstanceId(env,thiz))) { LOGE(" ## serializeJni(): failure - invalid session ptr"); + errorMessage = "invalid session ptr"; } else if (!aKeyBuffer) { LOGE(" ## serializeJni(): failure - invalid key"); - } - else if (!aErrorMsg) - { - LOGE(" ## serializeJni(): failure - invalid error object"); - } - else if (!(errorMsgJClass = env->GetObjectClass(aErrorMsg))) - { - LOGE(" ## serializeJni(): failure - unable to get error class"); - } - else if (!(errorMsgMethodId = env->GetMethodID(errorMsgJClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;"))) - { - LOGE(" ## serializeJni(): failure - unable to get error method ID"); + errorMessage = "invalid key"; } else if (!(keyPtr = env->GetByteArrayElements(aKeyBuffer, 0))) { LOGE(" ## serializeJni(): failure - keyPtr JNI allocation OOM"); + errorMessage = "ikeyPtr JNI allocation OOM"; } else { @@ -827,6 +854,7 @@ JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, if (!pickledPtr) { LOGE(" ## serializeJni(): failure - pickledPtr buffer OOM"); + errorMessage = "pickledPtr buffer OOM"; } else { @@ -837,13 +865,8 @@ JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, pickledLength); if (result == olm_error()) { - const char *errorMsgPtr = olm_session_last_error(sessionPtr); - LOGE(" ## serializeJni(): failure - olm_pickle_session() Msg=%s",errorMsgPtr); - - if ((errorJstring = env->NewStringUTF(errorMsgPtr))) - { - env->CallObjectMethod(aErrorMsg, errorMsgMethodId, errorJstring); - } + errorMessage = olm_session_last_error(sessionPtr); + LOGE(" ## serializeJni(): failure - olm_pickle_session() Msg=%s", errorMessage); } else { @@ -863,6 +886,11 @@ JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, env->ReleaseByteArrayElements(aKeyBuffer, keyPtr, JNI_ABORT); } + if (errorMessage) + { + env->ThrowNew(env->FindClass("java/lang/Exception"), errorMessage); + } + return pickledDataRetValue; } 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 95b421b..004031e 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 @@ -33,24 +33,24 @@ JNIEXPORT jlong OLM_SESSION_FUNC_DEF(initNewSessionJni)(JNIEnv *env, jobject thi JNIEXPORT jlong OLM_SESSION_FUNC_DEF(createNewSessionJni)(JNIEnv *env, jobject thiz); // outbound session -JNIEXPORT jint OLM_SESSION_FUNC_DEF(initOutboundSessionJni)(JNIEnv *env, jobject thiz, jlong aOlmAccountId, jbyteArray aTheirIdentityKey, jbyteArray aTheirOneTimeKey); +JNIEXPORT void OLM_SESSION_FUNC_DEF(initOutboundSessionJni)(JNIEnv *env, jobject thiz, jlong aOlmAccountId, jbyteArray aTheirIdentityKey, jbyteArray aTheirOneTimeKey); // inbound sessions: establishment based on PRE KEY message -JNIEXPORT jint OLM_SESSION_FUNC_DEF(initInboundSessionJni)(JNIEnv *env, jobject thiz, jlong aOlmAccountId, jbyteArray aOneTimeKeyMsg, jobject aErrorMsg); -JNIEXPORT jint OLM_SESSION_FUNC_DEF(initInboundSessionFromIdKeyJni)(JNIEnv *env, jobject thiz, jlong aOlmAccountId, jbyteArray aTheirIdentityKey, jbyteArray aOneTimeKeyMsg); +JNIEXPORT void OLM_SESSION_FUNC_DEF(initInboundSessionJni)(JNIEnv *env, jobject thiz, jlong aOlmAccountId, jbyteArray aOneTimeKeyMsg); +JNIEXPORT void OLM_SESSION_FUNC_DEF(initInboundSessionFromIdKeyJni)(JNIEnv *env, jobject thiz, jlong aOlmAccountId, jbyteArray aTheirIdentityKey, jbyteArray aOneTimeKeyMsg); // match inbound sessions: based on PRE KEY message JNIEXPORT jint OLM_SESSION_FUNC_DEF(matchesInboundSessionJni)(JNIEnv *env, jobject thiz, jbyteArray aOneTimeKeyMsg); JNIEXPORT jint OLM_SESSION_FUNC_DEF(matchesInboundSessionFromIdKeyJni)(JNIEnv *env, jobject thiz, jbyteArray aTheirIdentityKey, jbyteArray aOneTimeKeyMsg); // encrypt/decrypt -JNIEXPORT jint OLM_SESSION_FUNC_DEF(encryptMessageJni)(JNIEnv *env, jobject thiz, jbyteArray aClearMsg, jobject aEncryptedMsg); +JNIEXPORT void OLM_SESSION_FUNC_DEF(encryptMessageJni)(JNIEnv *env, jobject thiz, jbyteArray aClearMsg, jobject aEncryptedMsg); JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(decryptMessageJni)(JNIEnv *env, jobject thiz, jobject aEncryptedMsg); JNIEXPORT jbyteArray OLM_SESSION_FUNC_DEF(getSessionIdentifierJni)(JNIEnv *env, jobject thiz); // serialization -JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKey, jobject aErrorMsg); +JNIEXPORT jstring OLM_SESSION_FUNC_DEF(serializeJni)(JNIEnv *env, jobject thiz, jbyteArray aKey); JNIEXPORT jstring OLM_SESSION_FUNC_DEF(deserializeJni)(JNIEnv *env, jobject thiz, jbyteArray aSerializedData, jbyteArray aKey); #ifdef __cplusplus |