Examples with MXSession org.matrix.androidsdk.MXSession used on opensource projects

Example 36 with MXSession

use of org.matrix.androidsdk.MXSession in project matrix-android-sdk by matrix-org.

the class CryptoRestTest method test01_testDeviceKeys.

@Test
public void test01_testDeviceKeys() throws Exception {
    final Context context = InstrumentationRegistry.getContext();
    final SessionTestParams testParams = new SessionTestParams(true);
    final MXSession bobSession = mTestHelper.createAccount(TestConstants.USER_BOB, testParams);
    final Map<String, Object> results = new HashMap<>();
    String ed25519key = "wV5E3EUSHpHuoZLljNzojlabjGdXT3Mz7rugG9zgbkI";
    MXDeviceInfo bobDevice = new MXDeviceInfo("dev1");
    bobDevice.userId = bobSession.getMyUserId();
    bobDevice.algorithms = Arrays.asList(CryptoConstantsKt.MXCRYPTO_ALGORITHM_OLM);
    Map<String, String> keysMap = new HashMap<>();
    keysMap.put("ed25519:" + bobDevice.deviceId, ed25519key);
    bobDevice.keys = keysMap;
    CountDownLatch lock0 = new CountDownLatch(1);
    bobSession.getCryptoRestClientForTest().uploadKeys(bobDevice.JSONDictionary(), null, "dev1", new TestApiCallback<KeysUploadResponse>(lock0) {

        @Override
        public void onSuccess(KeysUploadResponse keysUploadResponse) {
            results.put("keysUploadResponse", keysUploadResponse);
            super.onSuccess(keysUploadResponse);
        }
    });
    mTestHelper.await(lock0);
    KeysUploadResponse keysUploadResponse = (KeysUploadResponse) results.get("keysUploadResponse");
    Assert.assertNotNull(keysUploadResponse);
    Assert.assertNotNull(keysUploadResponse.oneTimeKeyCounts);
    Assert.assertTrue(keysUploadResponse.oneTimeKeyCounts.isEmpty());
    Assert.assertEquals(0, keysUploadResponse.oneTimeKeyCountsForAlgorithm("deded"));
    CountDownLatch lock1 = new CountDownLatch(1);
    bobSession.getCryptoRestClientForTest().downloadKeysForUsers(Arrays.asList(bobSession.getMyUserId()), null, new TestApiCallback<KeysQueryResponse>(lock1) {

        @Override
        public void onSuccess(KeysQueryResponse keysQueryResponse) {
            results.put("keysQueryResponse", keysQueryResponse);
            super.onSuccess(keysQueryResponse);
        }
    });
    mTestHelper.await(lock1);
    KeysQueryResponse keysQueryResponse = (KeysQueryResponse) results.get("keysQueryResponse");
    Assert.assertNotNull(keysQueryResponse);
    Assert.assertNotNull(keysQueryResponse.deviceKeys);
    MXUsersDevicesMap<MXDeviceInfo> deviceInfos = new MXUsersDevicesMap<>(keysQueryResponse.deviceKeys);
    Assert.assertNotNull(deviceInfos.getUserIds());
    Assert.assertEquals(1, deviceInfos.getUserIds().size());
    List<String> deviceIds = deviceInfos.getUserDeviceIds(bobSession.getMyUserId());
    Assert.assertNotNull(deviceIds);
    Assert.assertEquals(1, deviceIds.size());
    MXDeviceInfo bobDevice2 = deviceInfos.getObject("dev1", bobSession.getMyUserId());
    Assert.assertNotNull(bobDevice2);
    Assert.assertEquals("dev1", bobDevice2.deviceId);
    Assert.assertEquals(bobDevice2.userId, bobSession.getMyUserId());
    bobSession.clear(context);
}

Example 37 with MXSession

use of org.matrix.androidsdk.MXSession in project matrix-android-sdk by matrix-org.

the class CryptoRestTest method test02_testOneTimeKeys.

@Test
public void test02_testOneTimeKeys() throws Exception {
    Context context = InstrumentationRegistry.getContext();
    final SessionTestParams testParams = new SessionTestParams(true);
    final MXSession bobSession = mTestHelper.createAccount(TestConstants.USER_BOB, testParams);
    final Map<String, Object> results = new HashMap<>();
    final Map<String, Object> otks = new HashMap<>();
    otks.put("curve25519:AAAABQ", "ueuHES/Q0P1MZ4J3IUpC8iQTkgQNX66ZpxVLUaTDuB8");
    otks.put("curve25519:AAAABA", "PmyaaB68Any+za9CuZXzFsQZW31s/TW6XbAB9akEpQs");
    CountDownLatch lock1 = new CountDownLatch(1);
    bobSession.getCryptoRestClientForTest().uploadKeys(null, otks, "dev1", new TestApiCallback<KeysUploadResponse>(lock1) {

        @Override
        public void onSuccess(KeysUploadResponse keysUploadResponse) {
            results.put("keysUploadResponse", keysUploadResponse);
            super.onSuccess(keysUploadResponse);
        }
    });
    mTestHelper.await(lock1);
    KeysUploadResponse keysUploadResponse = (KeysUploadResponse) results.get("keysUploadResponse");
    Assert.assertNotNull(keysUploadResponse);
    Assert.assertNotNull(keysUploadResponse.oneTimeKeyCounts);
    Assert.assertEquals(1, keysUploadResponse.oneTimeKeyCounts.size());
    Assert.assertEquals(2, keysUploadResponse.oneTimeKeyCountsForAlgorithm("curve25519"));
    Assert.assertEquals(0, keysUploadResponse.oneTimeKeyCountsForAlgorithm("deded"));
    bobSession.clear(context);
}

Example 38 with MXSession

use of org.matrix.androidsdk.MXSession in project matrix-android-sdk by matrix-org.

the class CryptoTest method test03_testKeysUploadAndDownload.

@Test
public void test03_testKeysUploadAndDownload() throws Exception {
    Log.e(LOG_TAG, "test03_testKeysUploadAndDownload");
    Context context = InstrumentationRegistry.getContext();
    final Map<String, Object> results = new HashMap<>();
    MXSession aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, mCryptoTestHelper.getDefaultSessionParams());
    aliceSession.getCredentials().deviceId = "AliceDevice";
    CountDownLatch lock0 = new CountDownLatch(1);
    aliceSession.enableCrypto(true, new TestApiCallback<Void>(lock0) {

        @Override
        public void onSuccess(Void info) {
            results.put("enableCrypto", "enableCrypto");
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock0);
    Assert.assertTrue(results.containsKey("enableCrypto"));
    MXSession bobSession = mTestHelper.createAccount(TestConstants.USER_BOB, mCryptoTestHelper.getDefaultSessionParams());
    CountDownLatch lock2 = new CountDownLatch(1);
    bobSession.getCredentials().deviceId = "BobDevice";
    bobSession.enableCrypto(true, new TestApiCallback<Void>(lock2) {

        @Override
        public void onSuccess(Void info) {
            results.put("enableCrypto2", "enableCrypto2");
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock2);
    Assert.assertTrue(results.containsKey("enableCrypto2"));
    CountDownLatch lock3 = new CountDownLatch(1);
    bobSession.getCrypto().getDeviceList().downloadKeys(Arrays.asList(bobSession.getMyUserId(), aliceSession.getMyUserId()), false, new TestApiCallback<MXUsersDevicesMap<MXDeviceInfo>>(lock3) {

        @Override
        public void onSuccess(MXUsersDevicesMap<MXDeviceInfo> info) {
            results.put("downloadKeys", info);
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock3);
    Assert.assertTrue(results.containsKey("downloadKeys"));
    MXUsersDevicesMap<MXDeviceInfo> usersDevicesInfoMap = (MXUsersDevicesMap<MXDeviceInfo>) results.get("downloadKeys");
    Assert.assertEquals(2, usersDevicesInfoMap.getUserIds().size());
    Assert.assertEquals(1, usersDevicesInfoMap.getUserDeviceIds(aliceSession.getMyUserId()).size());
    MXDeviceInfo aliceDeviceFromBobPOV = usersDevicesInfoMap.getObject("AliceDevice", aliceSession.getMyUserId());
    Assert.assertNotNull(aliceDeviceFromBobPOV);
    Assert.assertEquals(aliceDeviceFromBobPOV.fingerprint(), aliceSession.getCrypto().getOlmDevice().getDeviceEd25519Key());
    // Continue testing other methods
    Assert.assertNotNull(bobSession.getCrypto().deviceWithIdentityKey(aliceSession.getCrypto().getOlmDevice().getDeviceCurve25519Key(), CryptoConstantsKt.MXCRYPTO_ALGORITHM_OLM));
    Assert.assertTrue(aliceDeviceFromBobPOV.isUnknown());
    CountDownLatch lock3a = new CountDownLatch(1);
    bobSession.getCrypto().setDevicesKnown(Arrays.asList(aliceDeviceFromBobPOV), new TestApiCallback<Void>(lock3a) {

        @Override
        public void onSuccess(Void info) {
            results.put("setDevicesKnown", info);
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock3a);
    Assert.assertTrue(results.containsKey("setDevicesKnown"));
    // Read again from the store
    aliceDeviceFromBobPOV = bobSession.getCrypto().getCryptoStore().getUserDevice(aliceDeviceFromBobPOV.deviceId, aliceDeviceFromBobPOV.userId);
    Assert.assertTrue(aliceDeviceFromBobPOV.isUnverified());
    CountDownLatch lock3b = new CountDownLatch(1);
    bobSession.getCrypto().setDeviceVerification(MXDeviceInfo.DEVICE_VERIFICATION_BLOCKED, aliceDeviceFromBobPOV.deviceId, aliceSession.getMyUserId(), new TestApiCallback<Void>(lock3b) {

        @Override
        public void onSuccess(Void info) {
            results.put("setDeviceVerification1", info);
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock3b);
    Assert.assertTrue(results.containsKey("setDeviceVerification1"));
    // Read again from the store
    aliceDeviceFromBobPOV = bobSession.getCrypto().getCryptoStore().getUserDevice(aliceDeviceFromBobPOV.deviceId, aliceDeviceFromBobPOV.userId);
    Assert.assertTrue(aliceDeviceFromBobPOV.isBlocked());
    MXSession bobSession2 = mTestHelper.createNewSession(bobSession, mCryptoTestHelper.getDefaultSessionParams());
    final CountDownLatch lock4 = new CountDownLatch(1);
    MXStoreListener listener = new MXStoreListener() {

        @Override
        public void postProcess(String accountId) {
        }

        @Override
        public void onStoreReady(String accountId) {
            results.put("onStoreReady", "onStoreReady");
            lock4.countDown();
        }

        @Override
        public void onStoreCorrupted(String accountId, String description) {
            lock4.countDown();
        }

        @Override
        public void onStoreOOM(String accountId, String description) {
            lock4.countDown();
        }
    };
    bobSession2.getDataHandler().getStore().addMXStoreListener(listener);
    bobSession2.getDataHandler().getStore().open();
    mTestHelper.await(lock4);
    Assert.assertTrue(results.containsKey("onStoreReady"));
    final CountDownLatch lock4b = new CountDownLatch(2);
    MXEventListener eventListener = new MXEventListener() {

        @Override
        public void onInitialSyncComplete(String toToken) {
            results.put("onInitialSyncComplete", "onInitialSyncComplete");
            lock4b.countDown();
        }

        @Override
        public void onCryptoSyncComplete() {
            results.put("onCryptoSyncComplete", "onCryptoSyncComplete");
            lock4b.countDown();
        }
    };
    bobSession2.getDataHandler().addListener(eventListener);
    bobSession2.startEventStream(null);
    mTestHelper.await(lock4b);
    Assert.assertTrue(results.containsKey("onInitialSyncComplete"));
    Assert.assertTrue(results.containsKey("onCryptoSyncComplete"));
    MXDeviceInfo aliceDeviceFromBobPOV2 = bobSession2.getCrypto().deviceWithIdentityKey(aliceSession.getCrypto().getOlmDevice().getDeviceCurve25519Key(), CryptoConstantsKt.MXCRYPTO_ALGORITHM_OLM);
    Assert.assertNotNull(aliceDeviceFromBobPOV2);
    Assert.assertEquals(aliceDeviceFromBobPOV2.fingerprint(), aliceSession.getCrypto().getOlmDevice().getDeviceEd25519Key());
    Assert.assertTrue(aliceDeviceFromBobPOV2.mVerified + " instead of " + MXDeviceInfo.DEVICE_VERIFICATION_BLOCKED, aliceDeviceFromBobPOV2.mVerified == MXDeviceInfo.DEVICE_VERIFICATION_BLOCKED);
    // Download again alice device
    CountDownLatch lock5 = new CountDownLatch(1);
    bobSession2.getCrypto().getDeviceList().downloadKeys(Arrays.asList(aliceSession.getMyUserId()), true, new TestApiCallback<MXUsersDevicesMap<MXDeviceInfo>>(lock5) {

        @Override
        public void onSuccess(MXUsersDevicesMap<MXDeviceInfo> info) {
            results.put("downloadKeys2", info);
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock5);
    Assert.assertTrue(results.containsKey("downloadKeys2"));
    MXDeviceInfo aliceDeviceFromBobPOV3 = bobSession2.getCrypto().deviceWithIdentityKey(aliceSession.getCrypto().getOlmDevice().getDeviceCurve25519Key(), CryptoConstantsKt.MXCRYPTO_ALGORITHM_OLM);
    Assert.assertNotNull(aliceDeviceFromBobPOV3);
    Assert.assertEquals(aliceDeviceFromBobPOV3.fingerprint(), aliceSession.getCrypto().getOlmDevice().getDeviceEd25519Key());
    Assert.assertTrue(aliceDeviceFromBobPOV3.isBlocked());
    aliceSession.clear(context);
    bobSession.clear(context);
    bobSession2.clear(context);
}

Example 39 with MXSession

use of org.matrix.androidsdk.MXSession in project matrix-android-sdk by matrix-org.

the class CryptoTest method test14_testCryptoDeviceBlockAndLeave.

@Test
public void test14_testCryptoDeviceBlockAndLeave() throws Exception {
    Log.e(LOG_TAG, "test14_testCryptoDeviceBlockAndLeave");
    Context context = InstrumentationRegistry.getContext();
    final Map<String, Object> results = new HashMap<>();
    CryptoTestData cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobAndSamInARoom();
    final MXSession aliceSession = cryptoTestData.getFirstSession();
    final String aliceRoomId = cryptoTestData.getRoomId();
    final MXSession bobSession = cryptoTestData.getSecondSession();
    final MXSession samSession = cryptoTestData.getThirdSession();
    bobSession.getCrypto().setWarnOnUnknownDevices(false);
    aliceSession.getCrypto().setWarnOnUnknownDevices(false);
    samSession.getCrypto().setWarnOnUnknownDevices(false);
    final Room roomFromBobPOV = bobSession.getDataHandler().getRoom(aliceRoomId);
    final Room roomFromAlicePOV = aliceSession.getDataHandler().getRoom(aliceRoomId);
    final Room roomFromSamPOV = samSession.getDataHandler().getRoom(aliceRoomId);
    Assert.assertNotNull(roomFromBobPOV);
    Assert.assertNotNull(roomFromAlicePOV);
    Assert.assertNotNull(roomFromSamPOV);
    final CountDownLatch lock0 = new CountDownLatch(3);
    MXEventListener aliceEventsListener0 = new MXEventListener() {

        @Override
        public void onLiveEvent(Event event, RoomState roomState) {
            if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_MESSAGE)) {
                results.put("alice0", "alice0");
                lock0.countDown();
            }
        }
    };
    roomFromAlicePOV.addEventListener(aliceEventsListener0);
    MXEventListener samEventsListener0 = new MXEventListener() {

        @Override
        public void onLiveEvent(Event event, RoomState roomState) {
            if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_MESSAGE)) {
                results.put("sam0", "sam0");
                lock0.countDown();
            }
        }
    };
    roomFromSamPOV.addEventListener(samEventsListener0);
    // even if the device blocked, the message must be decrypted until there is a session id rolling
    roomFromBobPOV.sendEvent(mCryptoTestHelper.buildTextEvent("msg1", bobSession, aliceRoomId), new TestApiCallback<Void>(lock0) {

        @Override
        public void onSuccess(Void info) {
            results.put("send0", "send0");
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock0);
    Assert.assertTrue(results + "", results.containsKey("send0") && results.containsKey("alice0") && results.containsKey("sam0"));
    roomFromAlicePOV.removeEventListener(aliceEventsListener0);
    roomFromSamPOV.removeEventListener(samEventsListener0);
    final CountDownLatch lock1 = new CountDownLatch(3);
    MXEventListener bobEventsListener1 = new MXEventListener() {

        @Override
        public void onLiveEvent(Event event, RoomState roomState) {
            if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_MESSAGE)) {
                results.put("bob1", "bob1");
                lock1.countDown();
            }
        }
    };
    roomFromBobPOV.addEventListener(bobEventsListener1);
    MXEventListener samEventsListener1 = new MXEventListener() {

        @Override
        public void onLiveEvent(Event event, RoomState roomState) {
            if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_MESSAGE)) {
                results.put("sam1", "sam1");
                lock1.countDown();
            } else if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_MESSAGE_ENCRYPTED)) {
                lock1.countDown();
            }
        }
    };
    roomFromSamPOV.addEventListener(samEventsListener1);
    roomFromAlicePOV.sendEvent(mCryptoTestHelper.buildTextEvent("msg1", aliceSession, aliceRoomId), new TestApiCallback<Void>(lock1) {

        @Override
        public void onSuccess(Void info) {
            results.put("send1", "send1");
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock1);
    Assert.assertTrue(results + "", results.containsKey("send1") && results.containsKey("bob1") && results.containsKey("sam1"));
    List<MXDeviceInfo> list = bobSession.getCrypto().getUserDevices(aliceSession.getMyUserId());
    Assert.assertNotNull(list);
    Assert.assertTrue(list.size() > 0);
    CountDownLatch lock1b = new CountDownLatch(1);
    bobSession.getCrypto().setDeviceVerification(MXDeviceInfo.DEVICE_VERIFICATION_BLOCKED, list.get(0).deviceId, aliceSession.getMyUserId(), new TestApiCallback<Void>(lock1b) {

        @Override
        public void onSuccess(Void info) {
            results.put("setDeviceVerification10", "setDeviceVerification10");
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock1b);
    Assert.assertTrue(results.containsKey("setDeviceVerification10"));
    final CountDownLatch lock2 = new CountDownLatch(3);
    MXEventListener aliceEventsListener2 = new MXEventListener() {

        @Override
        public void onLiveEvent(Event event, RoomState roomState) {
            if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_MESSAGE_ENCRYPTED)) {
                results.put("alice2", "alice2");
                lock2.countDown();
            }
        }
    };
    roomFromAlicePOV.addEventListener(aliceEventsListener2);
    MXEventListener samEventsListener2 = new MXEventListener() {

        @Override
        public void onLiveEvent(Event event, RoomState roomState) {
            if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_MESSAGE)) {
                results.put("sam2", "sam2");
                lock2.countDown();
            }
        }
    };
    roomFromSamPOV.addEventListener(samEventsListener2);
    // even if the device blocked, the message must be decrypted until there is a session id rolling
    roomFromBobPOV.sendEvent(mCryptoTestHelper.buildTextEvent("msg2", bobSession, aliceRoomId), new TestApiCallback<Void>(lock2) {

        @Override
        public void onSuccess(Void info) {
            results.put("send2", "send2");
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock2);
    Assert.assertTrue(results.containsKey("send2") && results.containsKey("alice2") && results.containsKey("sam2"));
    roomFromAlicePOV.removeEventListener(aliceEventsListener2);
    final CountDownLatch lock3 = new CountDownLatch(2);
    MXEventListener bobLeaveEventsListener = new MXEventListener() {

        @Override
        public void onLiveEvent(Event event, RoomState roomState) {
            if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_STATE_ROOM_MEMBER)) {
                results.put("bobleave", "bobleave");
                lock3.countDown();
            }
        }
    };
    roomFromBobPOV.addEventListener(bobLeaveEventsListener);
    roomFromSamPOV.leave(new TestApiCallback<Void>(lock3) {

        @Override
        public void onSuccess(Void info) {
            results.put("leave", "leave");
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock3);
    Assert.assertTrue(results.containsKey("leave") && results.containsKey("bobleave"));
    final CountDownLatch lock4 = new CountDownLatch(2);
    MXEventListener aliceEventsListener3 = new MXEventListener() {

        @Override
        public void onLiveEvent(Event event, RoomState roomState) {
            if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_MESSAGE_ENCRYPTED)) {
                results.put("alice3", "alice3");
                lock4.countDown();
            }
        }
    };
    roomFromAlicePOV.addEventListener(aliceEventsListener3);
    // even if the device blocked, the message must be decrypted until there is a session id rolling
    roomFromBobPOV.sendEvent(mCryptoTestHelper.buildTextEvent("msg3", bobSession, aliceRoomId), new TestApiCallback<Void>(lock4) {

        @Override
        public void onSuccess(Void info) {
            results.put("send3", "send3");
            super.onSuccess(info);
        }
    });
    mTestHelper.await(lock4);
    Assert.assertTrue(results.containsKey("send3") && results.containsKey("alice3"));
    cryptoTestData.clear(context);
}