Rename decrypted_payload, modify its format (#173)

* Keep breaking change on decrypted payload format

Signed-off-by: Patrik Stas <patrik.stas@absa.africa>

* Add messaging tests + JS fixes

Signed-off-by: Patrik Stas <patrik.stas@absa.africa>

* Fix compile error in test

Signed-off-by: Patrik Stas <patrik.stas@absa.africa>

* Fix test

Signed-off-by: Patrik Stas <patrik.stas@absa.africa>

* Rename decrypted_payload to decrypted_msg

Signed-off-by: Patrik Stas <patrik.stas@absa.africa>

* Fixes for nodejs tests

Signed-off-by: Patrik Stas <patrik.stas@absa.africa>

* Decrypt download_messages_v2 payload (#172)

* Decrypt download_messages_v2 payload

Signed-off-by: Miroslav Kovar <miroslavkovar@protonmail.com>

* Add downloadReceivedMessagesV2 test to agent-core

Signed-off-by: Miroslav Kovar <miroslavkovar@protonmail.com>

Co-authored-by: Miroslav Kovar <miroslavkovar@protonmail.com>

Author: Patrik-Stas

agents/node/vcxagent-cli/vcxclient-interactive.js

@@ -33,7 +33,7 @@ async function createInteractiveClient (agentName, seed, acceptTaa, rustLogLevel
     14: 'CONNECTIONS_INFO',
     20: 'GET_CREDENTIAL_OFFERS',
     30: 'SEND_MESSAGE',
-    31: 'GET_MESSAGE'
+    31: 'GET_MESSAGE',
     32: 'GET_MESSAGE_V2'
   }
 

agents/node/vcxagent-core/demo/alice.js

@@ -78,9 +78,18 @@ async function runAlice (options) {
   await vcxAgent.serviceProver.sendDisclosedProofAndProgress(disclosedProofId, connectionId)
   logger.info('Faber received the proof')
 
-  const msgs = await vcxAgent.serviceConnections.getMessagesV2(connectionId)
-  logger.debug(`Alice received messages: ${JSON.stringify(msgs, null, 2)}`)
+  const msgs = await vcxAgent.serviceConnections.getMessages(connectionId)
   assert(msgs.length === 5)
+  assert(msgs[0].uid)
+  assert(msgs[0].statusCode)
+  assert(msgs[0].decryptedMsg)
+  const payload = JSON.parse(msgs[0].decryptedMsg)
+  assert(payload["@id"])
+  assert(payload["@type"])
+
+  const msgs2 = await vcxAgent.serviceConnections.getMessagesV2(connectionId)
+  logger.debug(`Alice received messages: ${JSON.stringify(msgs2, null, 2)}`)
+  assert(msgs2.length === 5)
 
   await vcxAgent.agentShutdownVcx()
   process.exit(0)

agents/node/vcxagent-core/package.json

@@ -35,9 +35,10 @@
     "demo:faber:verify": "node demo/faber-verify-signature.js",
     "test:legacy:integration": "node demo/integration-test.js",
     "test:legacy:integration:revocation": "REVOCATION=true node demo/integration-test.js",
-    "test:integration": "npm run test:integration:update-state && npm run test:integration:signing",
+    "test:integration": "npm run test:integration:update-state && npm run test:integration:signing && npm run test:integration:messaging",
     "test:integration:update-state": "jest --forceExit --env=node --runInBand test/update-state-v2.spec.js",
-    "test:integration:signing": "jest --forceExit --env=node --runInBand test/sign-verify.spec.js"
+    "test:integration:signing": "jest --forceExit --env=node --runInBand test/sign-verify.spec.js",
+    "test:integration:messaging": "jest --forceExit --env=node --runInBand test/sign-messaging.spec.js"
   },
   "dependencies": {
     "ffi-napi": "^2.4.7",

agents/node/vcxagent-core/src/services/service-connections.js

@@ -111,7 +111,7 @@ module.exports.createServiceConnections = function createServiceConnections ({ l
 
   async function getMessages (connectionId, filterStatuses = [], filterUids = []) {
     const pwDid = await getConnectionPwDid(connectionId)
-    return getMessagesForPwDid(pwDid, [], filterStatuses, filterUids)
+    return getMessagesForPwDid(pwDid, filterStatuses, filterUids)
   }
 
   async function getState (connectionId) {
@@ -137,7 +137,7 @@ module.exports.createServiceConnections = function createServiceConnections ({ l
 
   async function getMessagesV2 (connectionId, filterStatuses = [], filterUids = []) {
     const connection = await getVcxConnection(connectionId)
-    return getMessagesForConnection([connection], [], [])
+    return getMessagesForConnection([connection], filterStatuses, filterUids)
   }
 
   return {

agents/node/vcxagent-core/test/sign-messaging.spec.js

@@ -0,0 +1,37 @@
+/* eslint-env jest */
+require('jest')
+const { createPairedAliceAndFaber } = require('./utils/utils')
+const { initRustapi } = require('../src/index')
+
+beforeAll(async () => {
+  jest.setTimeout(1000 * 60 * 4)
+  await initRustapi(process.env.VCX_LOG_LEVEL || 'vcx=error')
+})
+
+describe('test messaging', () => {
+  it('downloadReceivedMessages: Alice should send message and Faber download it', async () => {
+    const { alice, faber } = await createPairedAliceAndFaber()
+    await alice.sendMessage('Hello Faber')
+    const msgs = await faber.downloadReceivedMessages()
+    expect(msgs.length).toBe(1)
+    expect(msgs[0].uid).toBeDefined()
+    expect(msgs[0].statusCode).toBe('MS-103')
+    const payload = JSON.parse(msgs[0].decryptedMsg)
+    expect(payload['@id']).toBeDefined()
+    expect(payload['@type']).toBeDefined()
+    expect(payload.content).toBe('Hello Faber')
+  })
+
+  it('downloadReceivedMessagesV2: Alice should send message and Faber download it ', async () => {
+    const { alice, faber } = await createPairedAliceAndFaber()
+    await alice.sendMessage('Hello Faber')
+    const msgs = await faber.downloadReceivedMessagesV2()
+    expect(msgs.length).toBe(1)
+    expect(msgs[0].uid).toBeDefined()
+    expect(msgs[0].statusCode).toBe('MS-103')
+    const payload = JSON.parse(msgs[0].decryptedMsg)
+    expect(payload['@id']).toBeDefined()
+    expect(payload['@type']).toBeDefined()
+    expect(payload.content).toBe('Hello Faber')
+  })
+})

agents/node/vcxagent-core/test/utils/alice.js

@@ -91,7 +91,15 @@ module.exports.createAlice = async function createAlice () {
     return signatureBase64
   }
 
+  async function sendMessage (message) {
+    logger.info('Alice is going to send message')
+    await vcxAgent.agentInitVcx()
+    await vcxAgent.serviceConnections.sendMessage(connectionId, message)
+    await vcxAgent.agentShutdownVcx()
+  }
+
   return {
+    sendMessage,
     signData,
     acceptInvite,
     updateConnection,

agents/node/vcxagent-core/test/utils/faber.js

@@ -135,7 +135,25 @@ module.exports.createFaber = async function createFaber () {
     return isValid
   }
 
+  async function downloadReceivedMessages () {
+    logger.info('Faber is going to download messages using getMessages')
+    await vcxAgent.agentInitVcx()
+    const agencyMessages = await vcxAgent.serviceConnections.getMessages(connectionId, ["MS-103"])
+    await vcxAgent.agentShutdownVcx()
+    return agencyMessages
+  }
+
+  async function downloadReceivedMessagesV2 () {
+    logger.info('Faber is going to download messages using getMessagesV2')
+    await vcxAgent.agentInitVcx()
+    const agencyMessages = await vcxAgent.serviceConnections.getMessagesV2(connectionId, ["MS-103"])
+    await vcxAgent.agentShutdownVcx()
+    return agencyMessages
+  }
+
   return {
+    downloadReceivedMessages,
+    downloadReceivedMessagesV2,
     verifySignature,
     createInvite,
     updateConnection,

libvcx/src/aries/handlers/connection/mod.rs

@@ -31,7 +31,6 @@ pub mod tests {
         use aries::test::{Alice, Faber};
 
         use super::*;
-        use serde_json::Value;
 
         #[test]
         #[cfg(feature = "aries")]
@@ -148,9 +147,8 @@ pub mod tests {
 
                 let messages: Vec<MessageByConnection> = download_messages_noauth(None, Some(vec!["MS-103".to_string()]), None).unwrap();
                 let message: Message = messages[0].msgs[0].clone();
-                let msg_wrapper: Value = ::serde_json::from_str(&message.decrypted_payload.unwrap()).unwrap();
-                let msg_aries = msg_wrapper["@msg"].as_str().unwrap();
-                let _payload: aries::messages::issuance::credential_offer::CredentialOffer = ::serde_json::from_str(msg_aries).unwrap();
+                let decrypted_msg = message.decrypted_msg.unwrap();
+                let _payload: aries::messages::issuance::credential_offer::CredentialOffer = ::serde_json::from_str(&decrypted_msg).unwrap();
 
                 ::connection::update_message_status(alice.connection_handle, message.uid).unwrap();
             }

libvcx/src/aries/mod.rs

@@ -112,7 +112,7 @@ pub mod test {
     #[derive(Debug)]
     pub struct VcxAgencyMessage {
         uid: String,
-        decrypted_payload: String,
+        decrypted_msg: String,
     }
 
     fn determine_message_type(a2a_message: A2AMessage) -> PayloadKinds {
@@ -132,21 +132,23 @@ pub mod test {
         )
     }
 
+    fn str_message_to_payload_type(message: &str) -> VcxResult<PayloadKinds> {
+        let a2a_message = str_message_to_a2a_message(message)?;
+        Ok(determine_message_type(a2a_message))
+    }
+
     fn download_message(did: String, filter_msg_type: PayloadKinds) -> VcxAgencyMessage {
         let mut messages = ::messages::get_message::download_messages_noauth(Some(vec![did]), Some(vec![String::from("MS-103")]), None).unwrap();
         assert_eq!(1, messages.len());
         let messages = messages.pop().unwrap();
 
         for message in messages.msgs.into_iter() {
-            let decrypted_payload = &message.decrypted_payload.unwrap();
-            let msg_wrapper: Value = serde_json::from_str(decrypted_payload).unwrap();
-            let msg_content = msg_wrapper["@msg"].as_str().unwrap();
-            let a2a_message = str_message_to_a2a_message(msg_content).unwrap();
-            let msg_type = determine_message_type(a2a_message);
+            let decrypted_msg = &message.decrypted_msg.unwrap();
+            let msg_type = str_message_to_payload_type(decrypted_msg).unwrap();
             if filter_msg_type == msg_type {
                 return VcxAgencyMessage {
                     uid: message.uid,
-                    decrypted_payload: msg_content.into(),
+                    decrypted_msg: decrypted_msg.clone(),
                 };
             }
         }
@@ -694,7 +696,7 @@ pub mod test {
         {
             let message = alice.download_message(PayloadKinds::CredOffer);
 
-            alice.credential_handle = ::credential::credential_create_with_offer("test", &message.decrypted_payload).unwrap();
+            alice.credential_handle = ::credential::credential_create_with_offer("test", &message.decrypted_msg).unwrap();
 
             ::connection::update_message_status(alice.connection_handle, message.uid).unwrap();
 
@@ -712,7 +714,7 @@ pub mod test {
         {
             let agency_msg = alice.download_message(PayloadKinds::ProofRequest);
 
-            alice.presentation_handle = ::disclosed_proof::create_proof("test", &agency_msg.decrypted_payload).unwrap();
+            alice.presentation_handle = ::disclosed_proof::create_proof("test", &agency_msg.decrypted_msg).unwrap();
 
             ::connection::update_message_status(alice.connection_handle, agency_msg.uid).unwrap();
 

libvcx/src/connection.rs

@@ -290,9 +290,13 @@ pub fn download_messages(conn_handles: Vec<u32>, status_codes: Option<Vec<Messag
     for conn_handle in conn_handles {
         let msg_by_conn = CONNECTION_MAP.get(
             conn_handle, |connection| {
+                let expected_sender_vk = connection.remote_vk()?;
                 let msgs = connection
                    .agent_info()
-                   .download_encrypted_messages(uids.clone(), status_codes.clone())?;
+                   .download_encrypted_messages(uids.clone(), status_codes.clone())?
+                   .iter()
+                   .map(|msg| msg.decrypt_auth(&expected_sender_vk))
+                   .collect::<VcxResult<Vec<Message>>>()?;
                 Ok(MessageByConnection{ pairwise_did: connection.agent_info().clone().pw_did, msgs })
             }
         )?;
@@ -637,21 +641,21 @@ pub mod tests {
         let all_messages = download_messages_noauth(None, None, None).unwrap();
         assert_eq!(all_messages.len(), 1);
         assert_eq!(all_messages[0].msgs.len(), 3);
-        assert!(all_messages[0].msgs[0].decrypted_payload.is_some());
-        assert!(all_messages[0].msgs[1].decrypted_payload.is_some());
+        assert!(all_messages[0].msgs[0].decrypted_msg.is_some());
+        assert!(all_messages[0].msgs[1].decrypted_msg.is_some());
 
         let received = download_messages_noauth(None, Some(vec![MessageStatusCode::Received.to_string()]), None).unwrap();
         assert_eq!(received.len(), 1);
         assert_eq!(received[0].msgs.len(), 2);
-        assert!(received[0].msgs[0].decrypted_payload.is_some());
+        assert!(received[0].msgs[0].decrypted_msg.is_some());
         assert_eq!(received[0].msgs[0].status_code, MessageStatusCode::Received);
-        assert!(received[0].msgs[1].decrypted_payload.is_some());
+        assert!(received[0].msgs[1].decrypted_msg.is_some());
 
         // there should be messages in "Reviewed" status connections/1.0/response from Aries-Faber connection protocol
         let reviewed = download_messages_noauth(None, Some(vec![MessageStatusCode::Reviewed.to_string()]), None).unwrap();
         assert_eq!(reviewed.len(), 1);
         assert_eq!(reviewed[0].msgs.len(), 1);
-        assert!(reviewed[0].msgs[0].decrypted_payload.is_some());
+        assert!(reviewed[0].msgs[0].decrypted_msg.is_some());
         assert_eq!(reviewed[0].msgs[0].status_code, MessageStatusCode::Reviewed);
 
         let rejected = download_messages_noauth(None, Some(vec![MessageStatusCode::Rejected.to_string()]), None).unwrap();
@@ -661,10 +665,8 @@ pub mod tests {
         let specific = download_messages_noauth(None, None, Some(vec![received[0].msgs[0].uid.clone()])).unwrap();
         assert_eq!(specific.len(), 1);
         assert_eq!(specific[0].msgs.len(), 1);
-        let msg = specific[0].msgs[0].decrypted_payload.clone().unwrap();
-        let msg_wrapper_value: Value = serde_json::from_str(&msg).unwrap();
-        assert!(msg_wrapper_value["@msg"].is_string());
-        let msg_aries_value: Value = serde_json::from_str(&msg_wrapper_value["@msg"].as_str().unwrap()).unwrap();
+        let msg = specific[0].msgs[0].decrypted_msg.clone().unwrap();
+        let msg_aries_value: Value = serde_json::from_str(&msg).unwrap();
         assert!(msg_aries_value.is_object());
         assert!(msg_aries_value["@id"].is_string());
         assert!(msg_aries_value["@type"].is_string());
@@ -712,11 +714,11 @@ pub mod tests {
         let consumer1_received_msgs = download_messages([institution_to_consumer1].to_vec(), Some(vec![MessageStatusCode::Received]), None).unwrap();
         assert_eq!(consumer1_received_msgs.len(), 1);
         assert_eq!(consumer1_received_msgs[0].msgs.len(), 1);
-        assert!(consumer1_received_msgs[0].msgs[0].payload.is_some());
+        assert!(consumer1_received_msgs[0].msgs[0].decrypted_msg.is_some());
 
         let consumer1_reviewed_msgs = download_messages([institution_to_consumer1].to_vec(), Some(vec![MessageStatusCode::Reviewed]), None).unwrap();
         assert_eq!(consumer1_reviewed_msgs.len(), 1);
         assert_eq!(consumer1_reviewed_msgs[0].msgs.len(), 1);
-        assert!(consumer1_reviewed_msgs[0].msgs[0].payload.is_some());
+        assert!(consumer1_reviewed_msgs[0].msgs[0].decrypted_msg.is_some());
     }
 }

libvcx/src/messages/get_message.rs

@@ -268,7 +268,7 @@ pub struct Message {
     #[serde(skip_deserializing)]
     pub delivery_details: Vec<DeliveryDetails>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub decrypted_payload: Option<String>,
+    pub decrypted_msg: Option<String>,
 }
 
 #[macro_export]
@@ -288,20 +288,31 @@ impl Message {
 
     pub fn decrypt_noauth(&self) -> Message {
         let mut new_message = self.clone();
-        if let Ok(decrypted_msg) = self._decrypt_v3_message() {
-            new_message.decrypted_payload = Some(decrypted_msg);
+        if let Ok(decrypted_msg) = self._noauth_decrypt_v3_message() {
+            new_message.decrypted_msg = Some(decrypted_msg);
         } else {
-            new_message.decrypted_payload = None;
+            new_message.decrypted_msg = None;
         }
         new_message.payload = None;
         new_message
     }
 
-    fn _decrypt_v3_message(&self) -> VcxResult<String> {
+    pub fn decrypt_auth(&self, expected_sender_vk: &str) -> VcxResult<Message> {
+        let mut new_message = self.clone();
+        let decrypted_msg = self._auth_decrypt_v3_message(expected_sender_vk)?;
+        new_message.decrypted_msg = Some(decrypted_msg);
+        new_message.payload = None;
+        Ok(new_message)
+    }
+
+    fn _noauth_decrypt_v3_message(&self) -> VcxResult<String> {
         let a2a_message = EncryptionEnvelope::anon_unpack(self.payload()?)?;
-        // todo: this awkward return value is here just to keep backwards comptability
-        // todo: we should make breaking change and simplify content of Message.decrypted_payload
-        Ok(json!({"@msg": json!(a2a_message).to_string()}).to_string())
+        Ok(json!(&a2a_message).to_string())
+    }
+
+    fn _auth_decrypt_v3_message(&self, expected_sender_vk: &str) -> VcxResult<String> {
+        let a2a_message = EncryptionEnvelope::auth_unpack(self.payload()?, &expected_sender_vk)?;
+        Ok(json!(&a2a_message).to_string())
     }
 }