Refactoring adding psk method

crypto/lakers-crypto-cryptocell310-sys/src/lib.rs

@@ -80,6 +80,14 @@ impl CryptoTrait for Crypto {
         output
     }
 
+    fn hkdf_extract_psk(&mut self, salt: &BytesHashLen, ikm: &BytesElemLenPSK) -> BytesHashLen {
+        // TODO
+        // TODO generalize if salt is not provided
+        let output = self.hmac_sha256(&mut ikm.clone()[..], *salt);
+
+        output
+    }
+
     fn aes_ccm_encrypt<const N: usize, Tag: CcmTagLen>(
         &mut self,
         key: &BytesCcmKeyLen,

crypto/lakers-crypto-psa/src/lib.rs

@@ -88,6 +88,15 @@ impl CryptoTrait for Crypto {
         output
     }
 
+    // added for PSK
+    fn hkdf_extract_psk(&mut self, salt: &BytesHashLen, ikm: &BytesElemLenPSK) -> BytesHashLen {
+        // TODO
+        // TODO generalize if salt is not provided
+        let output = self.hmac_sha256(&mut ikm.clone()[..], salt);
+
+        output
+    }
+
     fn aes_ccm_encrypt<const N: usize, Tag: CcmTagLen>(
         &mut self,
         key: &BytesCcmKeyLen,
@@ -208,7 +217,9 @@ impl CryptoTrait for Crypto {
 
         key_agreement::raw_key_agreement(alg, my_key, &peer_public_key, &mut output_buffer)
             .unwrap();
-
+        // SAFETY: The function demands that the Id is not used while destroyed.
+        // We did not hand out the Id `my_key` in the last few lines, so we can destroy it.
+        unsafe { key_management::destroy(my_key).unwrap() };
         output_buffer
     }
 

crypto/lakers-crypto-rustcrypto/src/lib.rs

@@ -2,8 +2,8 @@
 
 use lakers_shared::CcmTagLen;
 use lakers_shared::{
-    BytesCcmIvLen, BytesCcmKeyLen, BytesHashLen, BytesP256ElemLen, Crypto as CryptoTrait,
-    EDHOCError, EDHOCSuite, EdhocBuffer, MAX_SUITES_LEN,
+    BytesCcmIvLen, BytesCcmKeyLen, BytesElemLenPSK, BytesHashLen, BytesP256ElemLen,
+    Crypto as CryptoTrait, EDHOCError, EDHOCSuite, EdhocBuffer, MAX_SUITES_LEN,
 };
 
 use ccm::AeadInPlace;
@@ -74,6 +74,14 @@ impl<Rng: rand_core::RngCore + rand_core::CryptoRng> CryptoTrait for Crypto<Rng>
         extracted.finalize().0.into()
     }
 
+    fn hkdf_extract_psk(&mut self, salt: &BytesHashLen, ikm: &BytesElemLenPSK) -> BytesHashLen {
+        // While it'd be nice to just pass around an Hkdf, the extract output is not a type generic
+        // of this trait (yet?).
+        let mut extracted = hkdf::HkdfExtract::<sha2::Sha256>::new(Some(salt));
+        extracted.input_ikm(ikm);
+        extracted.finalize().0.into()
+    }
+
     fn aes_ccm_encrypt<const N: usize, Tag: CcmTagLen>(
         &mut self,
         key: &BytesCcmKeyLen,

examples/coap/src/bin/coapclient.rs

@@ -54,10 +54,18 @@ fn client_handshake() -> Result<(), EDHOCError> {
     println!("message_2 len = {}", response.message.payload.len());
 
     let message_2 = EdhocBuffer::new_from_slice(&response.message.payload[..]).unwrap();
-    let (mut initiator, c_r, id_cred_r, ead_2) = initiator.parse_message_2(&message_2)?;
+    let (mut initiator, c_r, details, ead_2) = initiator.parse_message_2(&message_2)?;
+    let ParsedMessage2Details::StatStat { id_cred_r } = details else {
+        return Err(EDHOCError::UnsupportedMethod);
+    };
     ead_2.processed_critical_items().unwrap();
     let valid_cred_r = credential_check_or_fetch(Some(cred_r), id_cred_r).unwrap();
-    initiator.set_identity(I.try_into().unwrap(), cred_i)?;
+    initiator.set_identity(
+        InitiatorIdentity::StatStat {
+            i: I.try_into().unwrap(),
+        },
+        cred_i,
+    )?;
     let initiator = initiator.verify_message_2(valid_cred_r)?;
 
     let mut msg_3 = Vec::from(c_r.as_cbor());

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

@@ -116,7 +116,9 @@ impl coap_handler::Handler for EdhocHandler {
 
             let (responder, _c_i, mut ead_1) = EdhocResponder::new(
                 lakers_crypto::default_crypto(),
-                R.try_into().expect("Wrong length of responder private key"),
+                ResponderIdentity::StatStat {
+                    r: R.try_into().expect("Wrong length of responder private key"),
+                },
                 cred_r,
             )
             .process_message_1(message_1)

examples/coap/src/bin/coapserver.rs

@@ -47,7 +47,9 @@ fn main() {
                 let cred_r: Credential = Credential::parse_ccs(CRED_R.try_into().unwrap()).unwrap();
                 let responder = EdhocResponder::new(
                     lakers_crypto::default_crypto(),
-                    R.try_into().unwrap(),
+                    ResponderIdentity::StatStat {
+                        r: R.try_into().unwrap(),
+                    },
                     cred_r,
                 );
 

examples/lakers-no_std/src/main.rs

@@ -108,7 +108,9 @@ fn main() -> ! {
         );
         let responder = EdhocResponder::new(
             lakers_crypto::default_crypto(),
-            R.try_into().expect("Wrong length of responder private key"),
+            ResponderIdentity::StatStat {
+                r: R.try_into().expect("Wrong length of responder private key"),
+            },
             cred_r.clone(),
         );
 
@@ -119,12 +121,16 @@ fn main() -> ! {
             .prepare_message_2(CredentialTransfer::ByReference, None, &EadItems::new())
             .unwrap();
 
-        let (mut initiator, _c_r, id_cred_r, _ead_2) =
-            initiator.parse_message_2(&message_2).unwrap();
+        let (mut initiator, _c_r, details, _ead_2) = initiator.parse_message_2(&message_2).unwrap();
+        let ParsedMessage2Details::StatStat { id_cred_r } = details else {
+            panic!("Expected StatStat details");
+        };
         let valid_cred_r = credential_check_or_fetch(Some(cred_r), id_cred_r).unwrap();
         initiator
             .set_identity(
-                I.try_into().expect("Wrong length of initiator private key"),
+                InitiatorIdentity::StatStat {
+                    i: I.try_into().expect("Wrong length of initiator private key"),
+                },
                 cred_i.clone(),
             )
             .unwrap(); // exposing own identity only after validating cred_r

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

@@ -92,7 +92,10 @@ async fn main(spawner: Spawner) {
                 // starts in 1 to consider only the content and not the metadata
                 pckt_2.pdu[1..pckt_2.len].try_into().expect("wrong length");
             info!("message_2 :{:?}", message_2.content);
-            let (initiator, c_r, id_cred_r, ead_2) = initiator.parse_message_2(&message_2).unwrap();
+            let (initiator, c_r, details) = initiator.parse_message_2(&message_2).unwrap();
+            let ParsedMessage2Details::StatStat { id_cred_r, ead_2 } = details else {
+                panic!("Expected stat-stat details");
+            };
             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();
 

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

@@ -74,7 +74,9 @@ async fn main(spawner: Spawner) {
         let cred_r = Credential::parse_ccs(common::CRED_R.try_into().unwrap()).unwrap();
         let responder = EdhocResponder::new(
             lakers_crypto::default_crypto(),
-            common::R.try_into().unwrap(),
+            ResponderIdentity::StatStat {
+                r: common::R.try_into().unwrap(),
+            },
             cred_r,
         );
 

lakers-c/src/initiator.rs

@@ -8,13 +8,12 @@ use crate::*;
 
 /// structs compatible with the C FFI
 
-#[derive(Debug)]
 #[repr(C)]
 pub struct EdhocInitiator {
     pub start: InitiatorStart,
     pub wait_m2: WaitM2,
     pub processing_m2: ProcessingM2C,
-    pub processed_m2: ProcessedM2,
+    pub processed_m2: ProcessedM2C,
     pub wait_m4: WaitM4,
     pub cred_i: *mut CredentialC,
     pub completed: Completed,
@@ -106,11 +105,15 @@ pub unsafe extern "C" fn initiator_parse_message_2(
     let state = core::ptr::read(&(*initiator_c).wait_m2);
 
     let result = match i_parse_message_2(&state, crypto, &(*message_2)) {
-        Ok((state, c_r, id_cred_r, ead_2)) => {
+        Ok((state, c_r, details, ead_2)) => {
             ProcessingM2C::copy_into_c(state, &mut (*initiator_c).processing_m2);
             let c_r = c_r.as_slice();
             assert_eq!(c_r.len(), 1, "C API only supports short C_R");
             *c_r_out = c_r[0];
+            let id_cred_r = match details {
+                ParsedMessage2Details::StatStat { id_cred_r } => id_cred_r,
+                ParsedMessage2Details::Psk {} => IdCred::new(),
+            };
             *id_cred_r_out = id_cred_r;
 
             EadItemsC::copy_into_c(ead_2, ead_2_c_out);
@@ -140,9 +143,15 @@ pub unsafe extern "C" fn initiator_verify_message_2(
 
     let state = core::ptr::read(&(*initiator_c).processing_m2).to_rust();
 
-    match i_verify_message_2(&state, crypto, (*valid_cred_r).to_rust(), &(*i)) {
+    // FIXME
+    match i_verify_message_2(
+        &state,
+        crypto,
+        (*valid_cred_r).to_rust(),
+        InitiatorIdentity::StatStat { i: *i },
+    ) {
         Ok(state) => {
-            (*initiator_c).processed_m2 = state;
+            ProcessedM2C::copy_into_c(state, &mut (*initiator_c).processed_m2);
             (*initiator_c).cred_i = cred_i;
             0
         }
@@ -165,7 +174,7 @@ pub unsafe extern "C" fn initiator_prepare_message_3(
     }
     let crypto = &mut default_crypto();
 
-    let state = core::ptr::read(&(*initiator_c).processed_m2);
+    let state = core::ptr::read(&(*initiator_c).processed_m2).to_rust();
 
     let ead_3 = if ead_3_c.is_null() {
         EadItems::new()