Correcting errors message_4

.gitignore

@@ -22,7 +22,4 @@ cscope*
 
 *.log
 
-color-map-gpi
-memory/
-old_results/
-plots/
+results/

examples/coap/src/bin/coapclient.rs

@@ -65,14 +65,14 @@ fn client_handshake() -> Result<(), EDHOCError> {
     msg_3.extend_from_slice(message_3.as_slice());
     println!("message_3 len = {}", msg_3.len());
 
-    let _response = CoAPClient::post_with_timeout(url, msg_3, timeout).unwrap();
-    // if response.get_status() != &ResponseType::Changed {
-    //     panic!("Message 3 response error: {:?}", response.get_status());
-    // }
-    // println!("response_vec = {:02x?}", response.message.payload);
-    // println!("message_3 len = {}", response.message.payload.len());
-    // let message_4 = EdhocMessageBuffer::new_from_slice(&response.message.payload[..]).unwrap();
-    // let (mut initiator, ead_4) = initiator.process_message_4(&message_4).unwrap();
+    let response = CoAPClient::post_with_timeout(url, msg_3, timeout).unwrap();
+    if response.get_status() != &ResponseType::Changed {
+        panic!("Message 3 response error: {:?}", response.get_status());
+    }
+    println!("response_vec = {:02x?}", response.message.payload);
+    println!("message_3 len = {}", response.message.payload.len());
+    let message_4 = EdhocMessageBuffer::new_from_slice(&response.message.payload[..]).unwrap();
+    let (mut initiator, ead_4) = initiator.process_message_4(&message_4).unwrap();
 
     println!("EDHOC exchange successfully completed");
     println!("PRK_out: {:02x?}", i_prk_out);

examples/coap/src/bin/coapserver-coaphandler.rs

@@ -180,14 +180,14 @@ impl coap_handler::Handler for EdhocHandler {
             let cred_i =
                 Credential::parse_ccs(CRED_I.try_into().expect("Static credential is too large"))
                     .expect("Static credential is not processable");
-                let valid_cred_i =
+            let valid_cred_i =
                 credential_check_or_fetch(Some(cred_i), id_cred_i).map_err(render_error)?;
             let (responder, prk_out, prk_exporter) =
                 responder.verify_message_3(valid_cred_i).map_err(|e| {
                     println!("EDHOC processing error: {:?}", e);
                     render_error(e)
                 })?;
-            
+
             let ead_4 = None;
             let (mut responder, message_4) = responder.prepare_message_4(&ead_4).unwrap();
             println!("EDHOC exchange successfully completed");

examples/coap/src/bin/coapserver.rs

@@ -108,12 +108,14 @@ fn main() {
                 };
                 let cred_i = Credential::parse_ccs(CRED_I.try_into().unwrap()).unwrap();
                 let valid_cred_i = credential_check_or_fetch(Some(cred_i), id_cred_i).unwrap();
-                let Ok((mut responder, r_prk_out, r_prk_exporter)) = responder.verify_message_3(valid_cred_i) else {
+                let Ok((mut responder, r_prk_out, r_prk_exporter)) =
+                    responder.verify_message_3(valid_cred_i)
+                else {
                     println!("EDHOC error at verify_message_3: {:?}", valid_cred_i);
                     continue;
                 };
-                // let ead_4 = None;
-                // let (mut responder, message_4) = responder.prepare_message_4(&ead_4).unwrap();
+                let ead_4 = None;
+                let (mut responder, message_4) = responder.prepare_message_4(&ead_4).unwrap();
                 // send empty ack back
                 response.message.payload = b"".to_vec();
 

examples/lakers-nrf52840/src/bin/initiator.rs

@@ -91,37 +91,33 @@ async fn main(spawner: Spawner) {
                 pckt_2.pdu[1..pckt_2.len].try_into().expect("wrong length");
             let (initiator, c_r, id_cred_r, ead_2) = initiator.parse_message_2(&message_2).unwrap();
             let valid_cred_r = credential_check_or_fetch(Some(cred_r), id_cred_r).unwrap();
-            let initiator = initiator
-                .verify_message_2(valid_cred_r)
-                .unwrap();
+            let initiator = initiator.verify_message_2(valid_cred_r).unwrap();
 
             let (mut initiator, message_3, i_prk_out, i_prk_out_exporter) = initiator
                 .prepare_message_3(CredentialTransfer::ByReference, &None)
                 .unwrap();
-            let pckt_3 = common::Packet::new_from_slice(message_3.as_slice(), Some(c_r.as_slice()[0]))
-            .expect("Buffer not long enough");
+            let pckt_3 =
+                common::Packet::new_from_slice(message_3.as_slice(), Some(c_r.as_slice()[0]))
+                    .expect("Buffer not long enough");
             info!("Send message_3 and wait message_4");
-            let rcvd = common::transmit_and_wait_response(
-                &mut radio, 
-                pckt_3,
-                Some(c_r.as_slice()[0]),
-            ).await;
-
+            let rcvd =
+                common::transmit_and_wait_response(&mut radio, pckt_3, Some(c_r.as_slice()[0]))
+                    .await;
+
             info!("Sent message_3");
             match rcvd {
                 Ok(pckt_4) => {
                     info!("Received message_4");
                     let message_4: EdhocMessageBuffer =
                         pckt_4.pdu[1..pckt_4.len].try_into().expect("wrong length");
-        
+
                     let (initiator, ead_4) = initiator.process_message_4(&message_4).unwrap();
-                    
+
                     info!("Handshake completed. prk_out = {:X}", i_prk_out);
-                }  
+                }
                 Err(_) => panic!("parsing error"),
             }
         }
         Err(_) => panic!("parsing error"),
     }
-
-}
+}

examples/lakers-nrf52840/src/bin/responder.rs

@@ -117,11 +117,12 @@ async fn main(spawner: Spawner) {
                             // anyway legally
                             continue;
                         };
-                        let cred_i: Credential = 
-                        Credential::parse_ccs(common::CRED_I.try_into().unwrap()).unwrap();
+                        let cred_i: Credential =
+                            Credential::parse_ccs(common::CRED_I.try_into().unwrap()).unwrap();
                         let valid_cred_i =
                             credential_check_or_fetch(Some(cred_i), id_cred_i).unwrap();
-                        let Ok((responder, r_prk_out, r_prk_exporter)) = responder.verify_message_3(valid_cred_i)
+                        let Ok((responder, r_prk_out, r_prk_exporter)) =
+                            responder.verify_message_3(valid_cred_i)
                         else {
                             info!("EDHOC error at parse_message_3");
                             continue;
@@ -134,9 +135,13 @@ async fn main(spawner: Spawner) {
                         info!("Send message_4");
                         common::transmit_without_response(
                             &mut radio,
-                            common::Packet::new_from_slice(message_4.as_slice(),Some(c_r.unwrap().as_slice()[0]))
-                                .unwrap(),
-                        ).await;
+                            common::Packet::new_from_slice(
+                                message_4.as_slice(),
+                                Some(c_r.unwrap().as_slice()[0]),
+                            )
+                            .unwrap(),
+                        )
+                        .await;
 
                         info!("Handshake completed. prk_out = {:X}", r_prk_out);
                     } else {
@@ -150,8 +155,6 @@ async fn main(spawner: Spawner) {
     }
 }
 
-
-
 #[embassy_executor::task]
 async fn example_application_task(secret: BytesHashLen) {
     info!(

lib/src/edhoc.rs

@@ -1,13 +1,13 @@
 use lakers_shared::{Crypto as CryptoTrait, *};
 
 // Implementation of edhoc_exporter for 3 or 4 messages
-pub trait StateDone {
+pub trait Done {
     fn get_prk_exporter(&self) -> &[u8; SHA256_DIGEST_LEN];
     fn get_prk_out_mut(&mut self) -> &mut [u8; SHA256_DIGEST_LEN];
     fn get_prk_out(&self) -> &[u8; SHA256_DIGEST_LEN];
 }
 // Implement for different states
-impl StateDone for WaitM4 {
+impl Done for WaitM4 {
     fn get_prk_exporter(&self) -> &[u8; SHA256_DIGEST_LEN] {
         &self.prk_exporter
     }
@@ -20,7 +20,7 @@ impl StateDone for WaitM4 {
 }
 
 // Implement for both state types
-impl StateDone for Completed {
+impl Done for Completed {
     fn get_prk_exporter(&self) -> &[u8; SHA256_DIGEST_LEN] {
         &self.prk_exporter
     }
@@ -32,7 +32,7 @@ impl StateDone for Completed {
     }
 }
 
-impl StateDone for ProcessedM3 {
+impl Done for ProcessedM3 {
     fn get_prk_exporter(&self) -> &[u8; SHA256_DIGEST_LEN] {
         &self.prk_exporter
     }
@@ -45,7 +45,7 @@ impl StateDone for ProcessedM3 {
 }
 
 pub fn edhoc_exporter(
-    state: &impl StateDone,
+    state: &impl Done,
     crypto: &mut impl CryptoTrait,
     label: u8,
     context: &BytesMaxContextBuffer,
@@ -63,7 +63,7 @@ pub fn edhoc_exporter(
 }
 
 pub fn edhoc_key_update(
-    state: &mut impl StateDone,
+    state: &mut impl Done,
     crypto: &mut impl CryptoTrait,
     context: &BytesMaxContextBuffer,
     context_len: usize,
@@ -79,7 +79,6 @@ pub fn edhoc_key_update(
         context_len,
         SHA256_DIGEST_LEN,
     );
-    // state.get_prk_out_mut()[..SHA256_DIGEST_LEN].copy_from_slice(&prk_new_buf[..SHA256_DIGEST_LEN]);
     prk_out.copy_from_slice(&prk_new_buf[..SHA256_DIGEST_LEN]);
 
     // new PRK_exporter
@@ -91,12 +90,13 @@ pub fn edhoc_key_update(
         0,
         SHA256_DIGEST_LEN,
     );
-    // state.get_prk_exporter()[..SHA256_DIGEST_LEN].copy_from_slice(&prk_new_buf[..SHA256_DIGEST_LEN]);
     prk_exporter.copy_from_slice(&prk_new_buf[..SHA256_DIGEST_LEN]);
 
     // Update state
     state.get_prk_out_mut().copy_from_slice(&prk_out);
-    state.get_prk_out_mut().copy_from_slice(&prk_new_buf[..SHA256_DIGEST_LEN]);
+    state
+        .get_prk_out_mut()
+        .copy_from_slice(&prk_new_buf[..SHA256_DIGEST_LEN]);
 
     prk_out
 }
@@ -299,7 +299,7 @@ pub fn r_verify_message_3(
                 prk_4e3m: prk_4e3m,
                 th_4: th_4,
                 prk_out: prk_out,
-                prk_exporter: prk_exporter
+                prk_exporter: prk_exporter,
             },
             prk_out,
             prk_exporter,
@@ -517,7 +517,6 @@ pub fn i_process_message_4(
     crypto: &mut impl CryptoTrait,
     message_4: &BufferMessage4,
 ) -> Result<(Completed, Option<EADItem>), EDHOCError> {
-
     let plaintext_4 = decrypt_message_4(crypto, &state.prk_4e3m, &state.th_4, &message_4)?;
     let decoded_p4_res = decode_plaintext_4(&plaintext_4);
 
@@ -740,9 +739,7 @@ fn encode_plaintext_3(
     }
 }
 
-fn encode_plaintext_4(
-    ead_4: &Option<EADItem>,
-) -> Result<BufferPlaintext4, EDHOCError> {
+fn encode_plaintext_4(ead_4: &Option<EADItem>) -> Result<BufferPlaintext4, EDHOCError> {
     let mut plaintext_4: BufferPlaintext4 = BufferPlaintext4::new();
 
     if let Some(ead_4) = ead_4 {
@@ -1280,7 +1277,7 @@ mod tests {
     const MESSAGE_3_TV: &str = "52e562097bc417dd5919485ac7891ffd90a9fc";
     const PRK_4E3M_TV: BytesP256ElemLen =
         hex!("81cc8a298e357044e3c466bb5c0a1e507e01d49238aeba138df94635407c0ff7");
-        const MESSAGE_4_TV: &str = "4828c966b7ca304f83";
+    const MESSAGE_4_TV: &str = "4828c966b7ca304f83";
     const CIPHERTEXT_4_TV: &str = "28c966b7ca304f83";
     const PLAINTEXT_4_TV: &str = "";
     const K_4_TV: BytesCcmKeyLen = hex!("d3c77872b6eeb508911bdbd308b2e6a0");
@@ -1690,7 +1687,7 @@ mod tests {
         assert_eq!(k_4, K_4_TV);
         assert_eq!(iv_4, IV_4_TV);
     }
-    
+
     #[test]
     fn test_compute_prk_4e3m() {
         let prk_4e3m = compute_prk_4e3m(&mut default_crypto(), &SALT_4E3M_TV, &SK_I_TV, &G_Y_TV);

lib/src/lib.rs

@@ -209,7 +209,14 @@ impl<'a, Crypto: CryptoTrait> EdhocResponderProcessingM3<Crypto> {
     pub fn verify_message_3(
         mut self,
         cred_i: Credential,
-    ) -> Result<(EdhocResponderProcessedM3<Crypto>, [u8; SHA256_DIGEST_LEN], [u8; SHA256_DIGEST_LEN]), EDHOCError> {
+    ) -> Result<
+        (
+            EdhocResponderProcessedM3<Crypto>,
+            [u8; SHA256_DIGEST_LEN],
+            [u8; SHA256_DIGEST_LEN],
+        ),
+        EDHOCError,
+    > {
         trace!("Enter verify_message_3");
         match r_verify_message_3(&mut self.state, &mut self.crypto, cred_i) {
             Ok((state, prk_out, prk_exporter)) => Ok((
@@ -229,16 +236,9 @@ impl<Crypto: CryptoTrait> EdhocResponderProcessedM3<Crypto> {
     pub fn prepare_message_4(
         mut self,
         ead_4: &Option<EADItem>,
-    ) -> Result<(
-        EdhocResponderDone<Crypto>, 
-        BufferMessage4
-    ), EDHOCError> {
+    ) -> Result<(EdhocResponderDone<Crypto>, BufferMessage4), EDHOCError> {
         trace!("Enter prepare_message_4");
-        match r_prepare_message_4(
-            &self.state,
-            &mut self.crypto,
-            ead_4,
-        ) {
+        match r_prepare_message_4(&self.state, &mut self.crypto, ead_4) {
             Ok((state, message_4)) => Ok((
                 EdhocResponderDone {
                     state,
@@ -478,16 +478,10 @@ impl<'a, Crypto: CryptoTrait> EdhocInitiatorWaitM4<Crypto> {
     pub fn process_message_4(
         mut self,
         message_4: &'a BufferMessage4,
-    ) -> Result<
-        (
-            EdhocInitiatorDone<Crypto>,
-            Option<EADItem>,
-        ),
-        EDHOCError,
-    > {
+    ) -> Result<(EdhocInitiatorDone<Crypto>, Option<EADItem>), EDHOCError> {
         trace!("Enter parse_message_4");
         match i_process_message_4(&mut self.state, &mut self.crypto, message_4) {
-            Ok((state, ead_4)) => Ok ((
+            Ok((state, ead_4)) => Ok((
                 EdhocInitiatorDone {
                     state: state,
                     crypto: self.crypto,
@@ -781,7 +775,8 @@ mod test {
         // ---- begin responder handling
         let (responder, id_cred_i, _ead_3) = responder.parse_message_3(&message_3).unwrap();
         let valid_cred_i = credential_check_or_fetch(Some(cred_i), id_cred_i).unwrap();
-        let (mut responder, r_prk_out, r_prk_exporter) = responder.verify_message_3(valid_cred_i).unwrap();
+        let (mut responder, r_prk_out, r_prk_exporter) =
+            responder.verify_message_3(valid_cred_i).unwrap();
 
         // Send message_4
         let (mut responder, message_4) = responder.prepare_message_4(&None).unwrap();

shared/src/lib.rs

@@ -816,7 +816,7 @@ mod edhoc_parser {
     ) -> Result<Option<EADItem>, EDHOCError> {
         trace!("Enter decode_plaintext_4");
         let decoder = CBORDecoder::new(plaintext_4.as_slice());
-    
+
         if plaintext_4.len > decoder.position() {
             // assume only one EAD item
             let ead_res = parse_ead(decoder.remaining_buffer()?);