Add test for verification started from a request

Author: ftilde

crates/matrix-sdk-crypto/src/machine.rs

@@ -1572,6 +1572,7 @@ pub(crate) mod test {
         event_id,
         events::{
             dummy::ToDeviceDummyEventContent,
+            key::verification::VerificationMethod,
             room::{
                 encrypted::ToDeviceRoomEncryptedEventContent,
                 message::{MessageType, RoomMessageEventContent},
@@ -2170,4 +2171,172 @@ pub(crate) mod test {
         assert!(bob_sas.is_done());
         assert!(alice_device.verified());
     }
+
+    #[tokio::test]
+    async fn interactive_verification_started_from_request() {
+        let (alice, bob) = get_machine_pair_with_setup_sessions().await;
+
+        // ----------------------------------------------------------------------------
+        // On Alice's device:
+        let bob_device = alice.get_device(bob.user_id(), bob.device_id()).await.unwrap().unwrap();
+
+        assert!(!bob_device.verified());
+
+        // Alice sends a verification request with her desired methods to Bob
+        let (alice_ver_req, request) =
+            bob_device.request_verification_with_methods(vec![VerificationMethod::SasV1]).await;
+
+        // ----------------------------------------------------------------------------
+        // On Bobs's device:
+        let event = request_to_event(alice.user_id(), &request);
+        bob.handle_verification_event(&event).await;
+        let flow_id = alice_ver_req.flow_id().as_str();
+
+        let verification_request = bob.get_verification_request(alice.user_id(), flow_id).unwrap();
+
+        // Bob accepts the request, sending a Ready request
+        let accept_request =
+            verification_request.accept_with_methods(vec![VerificationMethod::SasV1]).unwrap();
+        // And also immediately sends a start request
+        let (_, start_request_from_bob) = verification_request.start_sas().await.unwrap().unwrap();
+
+        // ----------------------------------------------------------------------------
+        // On Alice's device:
+
+        // Alice receives the Ready
+        let event = request_to_event(bob.user_id(), &accept_request);
+        alice.handle_verification_event(&event).await;
+
+        let verification_request = alice.get_verification_request(bob.user_id(), flow_id).unwrap();
+
+        // And also immediately sends a start request
+        let (alice_sas, start_request_from_alice) =
+            verification_request.start_sas().await.unwrap().unwrap();
+
+        // Now alice receives Bob's start:
+        let event = request_to_event(bob.user_id(), &start_request_from_bob);
+        alice.handle_verification_event(&event).await;
+
+        // Since Alice's user id is lexicographically smaller than Bob's, Alice does not
+        // do anything with the request, however.
+        assert!(alice.user_id() < bob.user_id());
+
+        // ----------------------------------------------------------------------------
+        // On Bob's device:
+
+        // Bob receives Alice's start:
+        let event = request_to_event(alice.user_id(), &start_request_from_alice);
+        bob.handle_verification_event(&event).await;
+
+        let bob_sas = bob
+            .get_verification(alice.user_id(), alice_sas.flow_id().as_str())
+            .unwrap()
+            .sas_v1()
+            .unwrap();
+
+        assert!(alice_sas.emoji().is_none());
+        assert!(bob_sas.emoji().is_none());
+
+        // ... and accepts it
+        let event = bob_sas.accept().map(|r| request_to_event(bob.user_id(), &r)).unwrap();
+
+        // ----------------------------------------------------------------------------
+        // On Alice's device:
+
+        // Alice receives the Accept request:
+        alice.handle_verification_event(&event).await;
+
+        // Alice sends a key
+        let msgs = alice.verification_machine.outgoing_messages();
+        assert!(msgs.len() == 1);
+        let msg = msgs.first().unwrap();
+        let event = outgoing_request_to_event(alice.user_id(), msg);
+        alice.verification_machine.mark_request_as_sent(&msg.request_id);
+
+        // ----------------------------------------------------------------------------
+        // On Bob's device:
+
+        // And bob receive's it:
+        bob.handle_verification_event(&event).await;
+
+        // Now bob sends a key
+        let msgs = bob.verification_machine.outgoing_messages();
+        assert!(msgs.len() == 1);
+        let msg = msgs.first().unwrap();
+        let event = outgoing_request_to_event(bob.user_id(), msg);
+        bob.verification_machine.mark_request_as_sent(&msg.request_id);
+
+        // ----------------------------------------------------------------------------
+        // On Alice's device:
+
+        // And alice receives it
+        alice.handle_verification_event(&event).await;
+
+        // As a result, both devices now can show emojis/decimals
+        assert!(alice_sas.emoji().is_some());
+        assert!(bob_sas.emoji().is_some());
+
+        // ----------------------------------------------------------------------------
+        // On Bob's device:
+
+        assert_eq!(alice_sas.emoji(), bob_sas.emoji());
+        assert_eq!(alice_sas.decimals(), bob_sas.decimals());
+
+        // Bob first confirms that the emojis match and sends the MAC...
+        let contents = bob_sas.confirm().await.unwrap().0;
+        assert!(contents.len() == 1);
+        let event = request_to_event(bob.user_id(), &contents[0]);
+
+        // ----------------------------------------------------------------------------
+        // On Alice's device:
+
+        // ...which alice receives
+        alice.handle_verification_event(&event).await;
+
+        assert!(!alice_sas.is_done());
+        assert!(!bob_sas.is_done());
+
+        // Now alice confirms that the emojis match and sends...
+        let contents = alice_sas.confirm().await.unwrap().0;
+        assert!(contents.len() == 2);
+        // ... her own MAC...
+        let event_mac = request_to_event(alice.user_id(), &contents[0]);
+        // ... and a Done message
+        let event_done = request_to_event(alice.user_id(), &contents[1]);
+
+        // ----------------------------------------------------------------------------
+        // On Bob's device:
+
+        // Bob receives the MAC message
+        bob.handle_verification_event(&event_mac).await;
+
+        // Bob verifies that the MAC is valid and also sends a "done" message.
+        let msgs = bob.verification_machine.outgoing_messages();
+        eprintln!("{:?}", msgs);
+        assert!(msgs.len() == 1);
+        let event = msgs.first().map(|r| outgoing_request_to_event(bob.user_id(), r)).unwrap();
+
+        let alice_device =
+            bob.get_device(alice.user_id(), alice.device_id()).await.unwrap().unwrap();
+
+        assert!(!bob_sas.is_done());
+        assert!(!alice_device.verified());
+        // And Bob receives the Done message of alice.
+        bob.handle_verification_event(&event_done).await;
+
+        assert!(bob_sas.is_done());
+        assert!(alice_device.verified());
+
+        // ----------------------------------------------------------------------------
+        // On Alice's device:
+
+        assert!(!alice_sas.is_done());
+        assert!(!bob_device.verified());
+        // Alices receives the done message
+        eprintln!("{:?}", event);
+        alice.handle_verification_event(&event).await;
+
+        assert!(alice_sas.is_done());
+        assert!(bob_device.verified());
+    }
 }

crates/matrix-sdk-crypto/src/verification/mod.rs

@@ -719,6 +719,12 @@ pub(crate) mod test {
         let sender = sender.to_owned();
 
         match content {
+            AnyToDeviceEventContent::KeyVerificationRequest(c) => {
+                AnyToDeviceEvent::KeyVerificationRequest(ToDeviceEvent { sender, content: c })
+            }
+            AnyToDeviceEventContent::KeyVerificationReady(c) => {
+                AnyToDeviceEvent::KeyVerificationReady(ToDeviceEvent { sender, content: c })
+            }
             AnyToDeviceEventContent::KeyVerificationKey(c) => {
                 AnyToDeviceEvent::KeyVerificationKey(ToDeviceEvent { sender, content: c })
             }
@@ -731,6 +737,9 @@ pub(crate) mod test {
             AnyToDeviceEventContent::KeyVerificationMac(c) => {
                 AnyToDeviceEvent::KeyVerificationMac(ToDeviceEvent { sender, content: c })
             }
+            AnyToDeviceEventContent::KeyVerificationDone(c) => {
+                AnyToDeviceEvent::KeyVerificationDone(ToDeviceEvent { sender, content: c })
+            }
 
             _ => unreachable!(),
         }