Examples with CryptoTestData org.matrix.androidsdk.common.CryptoTestData used on opensource projects

Example 21 with CryptoTestData

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

the class CryptoTest method test17_testLateRoomKey.

@Test
public void test17_testLateRoomKey() throws Exception {
    Log.e(LOG_TAG, "test17_testLateRoomKey");
    Context context = InstrumentationRegistry.getContext();
    final Map<String, Object> results = new HashMap<>();
    CryptoTestData cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom(true);
    final MXSession aliceSession = cryptoTestData.getFirstSession();
    final String aliceRoomId = cryptoTestData.getRoomId();
    final MXSession bobSession = cryptoTestData.getSecondSession();
    bobSession.getCrypto().setWarnOnUnknownDevices(false);
    aliceSession.getCrypto().setWarnOnUnknownDevices(false);
    String messageFromAlice = "Hello I'm Alice!";
    final Room roomFromBobPOV = bobSession.getDataHandler().getRoom(aliceRoomId);
    final Room roomFromAlicePOV = aliceSession.getDataHandler().getRoom(aliceRoomId);
    Assert.assertTrue(roomFromBobPOV.isEncrypted());
    Assert.assertTrue(roomFromAlicePOV.isEncrypted());
    final CountDownLatch lock1 = new CountDownLatch(2);
    MXEventListener bobEventListener = new MXEventListener() {

        @Override
        public void onToDeviceEvent(Event event) {
            if (!results.containsKey("onToDeviceEvent")) {
                results.put("onToDeviceEvent", event);
                lock1.countDown();
            }
        }
    };
    bobSession.getDataHandler().addListener(bobEventListener);
    final List<Event> receivedEvents = new ArrayList<>();
    EventTimeline.Listener eventTimelineListener = new EventTimeline.Listener() {

        public void onEvent(Event event, EventTimeline.Direction direction, RoomState roomState) {
            if (TextUtils.equals(event.getType(), Event.EVENT_TYPE_MESSAGE)) {
                receivedEvents.add(event);
                lock1.countDown();
            }
        }
    };
    roomFromBobPOV.getTimeline().addEventTimelineListener(eventTimelineListener);
    roomFromAlicePOV.sendEvent(mCryptoTestHelper.buildTextEvent(messageFromAlice, aliceSession, aliceRoomId), new SimpleApiCallback<Void>() {

        @Override
        public void onSuccess(Void info) {
        // Ignore
        }
    });
    mTestHelper.await(lock1);
    Assert.assertTrue(results.containsKey("onToDeviceEvent"));
    Assert.assertEquals(1, receivedEvents.size());
    Event event = receivedEvents.get(0);
    mCryptoTestHelper.checkEncryptedEvent(event, aliceRoomId, messageFromAlice, aliceSession);
    // Reinject a modified version of the received room_key event from Alice.
    // From Bob pov, that mimics Alice resharing her keys but with an advanced outbound group session.
    Event toDeviceEvent = (Event) results.get("onToDeviceEvent");
    String sessionId = toDeviceEvent.getContentAsJsonObject().get("session_id").getAsString();
    String senderKey = toDeviceEvent.getSenderKey();
    // remove the session
    bobSession.getCrypto().getOlmDevice().removeInboundGroupSession(sessionId, senderKey);
    event.setClearData(null);
    // check that the message cannot be decrypted
    Assert.assertFalse(bobSession.getDataHandler().decryptEvent(event, null));
    // check the error code
    Assert.assertEquals(MXCryptoError.UNKNOWN_INBOUND_SESSION_ID_ERROR_CODE, event.getCryptoError().errcode);
    final String[] decryptedRoomId = new String[1];
    final String[] decryptedEventId = new String[1];
    final CountDownLatch lock2 = new CountDownLatch(1);
    roomFromBobPOV.addEventListener(new MXEventListener() {

        @Override
        public void onEventDecrypted(String roomId, String eventId) {
            results.put("onEventDecrypted", "onEventDecrypted");
            decryptedRoomId[0] = roomId;
            decryptedEventId[0] = eventId;
            lock2.countDown();
        }
    });
    event.setClearData(null);
    // reinject the session key
    bobSession.getDataHandler().onToDeviceEvent(toDeviceEvent);
    // the message should be decrypted later
    mTestHelper.await(lock2);
    Assert.assertTrue(results.containsKey("onEventDecrypted"));
    Assert.assertEquals(event.roomId, decryptedRoomId[0]);
    Assert.assertEquals(event.eventId, decryptedEventId[0]);
    /*
            // We do not have a proper way to get the event for now
            Event decryptedEvent = bobSession.getDataHandler().getStore().getEvent(decryptedRoomId[0], decryptedEventId[0]);

            Assert.assertNotNull(decryptedEvent);

            mCryptoTestHelper.checkEncryptedEvent(decryptedEvent, aliceRoomId, messageFromAlice, aliceSession);
            Assert.assertNull(decryptedEvent.getCryptoError());
         */
    cryptoTestData.clear(context);
}

Example 22 with CryptoTestData

use of org.matrix.androidsdk.common.CryptoTestData 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);
}