nucleo_u545 hash driver

Author: frihetselsker

boards/components/src/hmac.rs

@@ -62,6 +62,9 @@ impl<
         A: kernel::hil::digest::HmacSha256
             + digest::HmacSha384
             + digest::HmacSha512
+            + digest::HmacMd5
+            + digest::HmacSha224
+            + digest::HmacSha1
             + 'static
             + digest::Digest<'static, L>,
         const L: usize,

boards/components/src/sha.rs

@@ -67,6 +67,9 @@ impl<
         A: kernel::hil::digest::Sha256
             + digest::Sha384
             + digest::Sha512
+            + digest::Md5
+            + digest::Sha1
+            + digest::Sha224
             + 'static
             + digest::Digest<'static, L>,
         const L: usize,

boards/configurations/nrf52840dk/nrf52840dk-test-kernel/src/test/hmac_sha256_test.rs

@@ -30,7 +30,7 @@ pub static mut WIKI_HMAC: [u8; 32] = [
 
 unsafe fn static_init_test_hmacsha256(
     client: &'static dyn CapsuleTestClient,
-) -> &'static TestHmacSha256 {
+) -> &'static TestHmacSha256<'static, HmacSha256Software<'static, Sha256Software<'static>>> {
     let sha256_hash_buf = static_init!([u8; 64], [0; 64]);
 
     let sha256 = static_init!(Sha256Software<'static>, Sha256Software::new());
@@ -45,7 +45,7 @@ unsafe fn static_init_test_hmacsha256(
     kernel::hil::digest::Digest::set_client(sha256, hmacsha256);
 
     let test = static_init!(
-        TestHmacSha256,
+        TestHmacSha256<'static, HmacSha256Software<'static, Sha256Software<'static>>>,
         TestHmacSha256::new(
             hmacsha256,
             &mut *addr_of_mut!(WIKI_KEY),

boards/configurations/nrf52840dk/nrf52840dk-test-kernel/src/test/sha256_test.rs

@@ -45,7 +45,9 @@ pub static mut LHASH: [u8; 32] = [
     0x45, 0x94, 0xd5, 0xee, 0x15, 0xcb, 0x8a, 0x1e, 0x28, 0x7c, 0x20, 0x12, 0xc2, 0xce, 0xb5, 0xa9,
 ];
 
-unsafe fn static_init_test_sha256(client: &'static dyn CapsuleTestClient) -> &'static TestSha256 {
+unsafe fn static_init_test_sha256(
+    client: &'static dyn CapsuleTestClient,
+) -> &'static TestSha256<'static, Sha256Software<'static>> {
     let sha = static_init!(Sha256Software<'static>, Sha256Software::new());
     kernel::deferred_call::DeferredCallClient::register(sha);
     let bytes = b"hello ";
@@ -56,7 +58,7 @@ unsafe fn static_init_test_sha256(client: &'static dyn CapsuleTestClient) -> &'s
     }
     // We expect LSTRING to hash to LHASH, so final argument is true
     let test = static_init!(
-        TestSha256,
+        TestSha256<Sha256Software>,
         TestSha256::new(
             sha,
             &mut *addr_of_mut!(LSTRING),

boards/imix/src/test/sha256_test.rs

@@ -47,7 +47,7 @@ pub static mut LHASH: [u8; 32] = [
     0x45, 0x94, 0xd5, 0xee, 0x15, 0xcb, 0x8a, 0x1e, 0x28, 0x7c, 0x20, 0x12, 0xc2, 0xce, 0xb5, 0xa9,
 ];
 
-unsafe fn static_init_test_sha256() -> &'static TestSha256 {
+unsafe fn static_init_test_sha256() -> &'static TestSha256<'static, Sha256Software<'static>> {
     let sha = static_init!(Sha256Software<'static>, Sha256Software::new());
     kernel::deferred_call::DeferredCallClient::register(sha);
     let bytes = b"hello ";
@@ -58,7 +58,7 @@ unsafe fn static_init_test_sha256() -> &'static TestSha256 {
     }
     // We expect LSTRING to hash to LHASH, so final argument is true
     let test = static_init!(
-        TestSha256,
+        TestSha256<'static, Sha256Software<'static>>,
         TestSha256::new(
             sha,
             &mut *addr_of_mut!(LSTRING),

boards/nucleo_u545re_q/Makefile

@@ -22,6 +22,11 @@ flash-debug: $(TOCK_ROOT_DIRECTORY)target/$(TARGET)/debug/$(PLATFORM).elf
 flash: $(TOCK_ROOT_DIRECTORY)target/$(TARGET)/release/$(PLATFORM).elf
 	$(OPENOCD) $(OPENOCD_OPTIONS) -c "init; halt; stm32l4x mass_erase 0; program $< verify reset exit"
 
+.PHONY: flash-probe-rs
+flash-probe-rs: $(TOCK_ROOT_DIRECTORY)target/$(TARGET)/release/$(PLATFORM).elf
+	$(Q)probe-rs download --chip STM32U545RETx --allow-erase-all $(TOCK_ROOT_DIRECTORY)target/$(TARGET)/release/$(PLATFORM).elf
+	$(Q)probe-rs reset --chip STM32U545RETx
+
 .PHONY: program
 program:
 	tockloader install --openocd --board nucleo_u545re_q $(APP)

boards/nucleo_u545re_q/src/main.rs

@@ -6,6 +6,7 @@
 #![no_std]
 #![no_main]
 
+use capsules_extra::test::hmac_sha256::TestHmacSha256;
 use kernel::capabilities;
 use kernel::component::Component;
 use kernel::debug::PanicResources;
@@ -51,6 +52,10 @@ struct NucleoU545RE {
             stm32u545::tim::Tim2<'static>,
         >,
     >,
+    test_hmac_sha256: &'static capsules_extra::test::hmac_sha256::TestHmacSha256<
+        'static,
+        stm32u545::hash::sha256::Sha256Adapter<'static>,
+    >,
 }
 
 impl SyscallDriverLookup for NucleoU545RE {
@@ -151,10 +156,17 @@ unsafe fn start() -> (
     );
     usart1.register();
 
+    let hash = static_init!(
+        stm32u545::hash::core_unit::Hash<'static>,
+        stm32u545::hash::core_unit::Hash::new(stm32u545::hash::regs::HASH_BASE)
+    );
+
+    hash.register();
+
     // Load Peripherals Bundle
     let periphs = static_init!(
         stm32u545::chip::Stm32u5xxDefaultPeripherals<'static>,
-        stm32u545::chip::Stm32u5xxDefaultPeripherals::new(usart1, exti, dma1)
+        stm32u545::chip::Stm32u5xxDefaultPeripherals::new(usart1, exti, dma1, hash)
     );
 
     // Initialize wiring (DMA, clocks)
@@ -164,6 +176,16 @@ unsafe fn start() -> (
     periphs.tim2.start();
     set_pin_primary_functions(periphs);
 
+    // Create an adapter for the HASH peripheral.
+    // In this way it is ensured that only one mode is used by the peripheral.
+    let sha256 = static_init!(
+        stm32u545::hash::sha256::Sha256Adapter<'static>,
+        stm32u545::hash::sha256::Sha256Adapter::new(hash)
+    );
+
+    // Adapter receives callbacks from the peripheral
+    let _ = hash.set_sha256_adapter(sha256);
+
     // Kernel and Muxes
     let processes = components::process_array::ProcessArrayComponent::new()
         .finalize(components::process_array_component_static!(NUM_PROCS));
@@ -232,6 +254,50 @@ unsafe fn start() -> (
     )
     .finalize(components::button_component_static!(stm32u545::gpio::Pin));
 
+    let hmac_key = static_init!(
+        [u8; 64],
+        [
+            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
+            0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B,
+            0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29,
+            0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+            0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F
+        ]
+    );
+
+    // An example from STM32 RM0456 Reference manual
+    //
+    // “Sample message for keylen = blocklen”
+    let hash_data_buffer = static_init!(
+        [u8; 34],
+        [
+            0x53, 0x61, 0x6d, 0x70, 0x6C, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+            0x20, 0x66, 0x6f, 0x72, 0x20, 0x6b, 0x65, 0x79, 0x6C, 0x65, 0x6e, 0x3d, 0x62, 0x6c,
+            0x6f, 0x63, 0x6b, 0x6c, 0x65, 0x6e
+        ]
+    );
+
+    let hash_digest_buffer = static_init!([u8; 32], [0u8; 32]);
+    let correct = static_init!(
+        [u8; 32],
+        [
+            0x8b, 0xb9, 0xa1, 0xdb, 0x98, 0x06, 0xf2, 0x0d, 0xf7, 0xf7, 0x7b, 0x82, 0x13, 0x8c,
+            0x79, 0x14, 0xd1, 0x74, 0xd5, 0x9e, 0x13, 0xdc, 0x4d, 0x01, 0x69, 0xc9, 0x05, 0x7b,
+            0x13, 0x3e, 0x1d, 0x62
+        ]
+    );
+
+    let test_hmac_sha256 = static_init!(
+        TestHmacSha256<'static, stm32u545::hash::sha256::Sha256Adapter<'static>>,
+        TestHmacSha256::new(
+            sha256,
+            hmac_key,
+            hash_data_buffer,
+            hash_digest_buffer,
+            correct
+        )
+    );
+
     // Platform and Interrupts
     let platform = static_init!(
         NucleoU545RE,
@@ -243,6 +309,7 @@ unsafe fn start() -> (
             led,
             button,
             alarm,
+            test_hmac_sha256
         }
     );
 
@@ -291,6 +358,7 @@ pub unsafe fn main() {
     let main_loop_capability = create_capability!(capabilities::MainLoopCapability);
 
     let (board_kernel, platform, chip) = start();
+    platform.test_hmac_sha256.run();
     // Hand over control to the Tock Kernel Loop
     board_kernel.kernel_loop::<NucleoU545RE, ChipHw, { NUM_PROCS as u8 }>(
         platform,

boards/opentitan/earlgrey-cw310/src/tests/sha256soft_test.rs

@@ -6,6 +6,7 @@
 
 use crate::tests::run_kernel_op;
 use crate::SHA256SOFT;
+use capsules_extra::sha256::Sha256Software;
 use capsules_extra::test::sha256::TestSha256;
 use kernel::debug;
 use kernel::static_init;
@@ -36,7 +37,12 @@ fn sha256software_verify() {
         )
     };
 
-    let test = unsafe { static_init!(TestSha256, TestSha256::new(sha, lstring, lhash, true)) };
+    let test = unsafe {
+        static_init!(
+            TestSha256<'static, Sha256Software<'static>>,
+            TestSha256::new(sha, lstring, lhash, true)
+        )
+    };
     test.run();
 
     run_kernel_op(1000);

capsules/extra/src/hmac.rs

@@ -60,6 +60,9 @@ use kernel::utilities::leasable_buffer::SubSliceMut;
 use kernel::{ErrorCode, ProcessId};
 
 enum ShaOperation {
+    Md5,
+    Sha1,
+    Sha224,
     Sha256,
     Sha384,
     Sha512,
@@ -91,6 +94,9 @@ pub struct HmacDriver<'a, H: digest::Digest<'a, DIGEST_LEN>, const DIGEST_LEN: u
 impl<
         'a,
         H: digest::Digest<'a, DIGEST_LEN>
+            + digest::HmacMd5
+            + digest::HmacSha1
+            + digest::HmacSha224
             + digest::HmacSha256
             + digest::HmacSha384
             + digest::HmacSha512,
@@ -131,9 +137,19 @@ impl<
                                     let mut tmp_key_buffer: [u8; TMP_KEY_BUFFER_SIZE] =
                                         [0; TMP_KEY_BUFFER_SIZE];
                                     let key_len = core::cmp::min(k.len(), TMP_KEY_BUFFER_SIZE);
+
                                     k[..key_len].copy_to_slice(&mut tmp_key_buffer[..key_len]);
 
                                     match op {
+                                        ShaOperation::Md5 => {
+                                            self.hmac.set_mode_hmacmd5(&tmp_key_buffer[..key_len])
+                                        }
+                                        ShaOperation::Sha1 => {
+                                            self.hmac.set_mode_hmacsha1(&tmp_key_buffer[..key_len])
+                                        }
+                                        ShaOperation::Sha224 => self
+                                            .hmac
+                                            .set_mode_hmacsha224(&tmp_key_buffer[..key_len]),
                                         ShaOperation::Sha256 => self
                                             .hmac
                                             .set_mode_hmacsha256(&tmp_key_buffer[..key_len]),
@@ -251,6 +267,9 @@ impl<
 impl<
         'a,
         H: digest::Digest<'a, DIGEST_LEN>
+            + digest::HmacMd5
+            + digest::HmacSha1
+            + digest::HmacSha224
             + digest::HmacSha256
             + digest::HmacSha384
             + digest::HmacSha512,
@@ -389,6 +408,9 @@ impl<
 impl<
         'a,
         H: digest::Digest<'a, DIGEST_LEN>
+            + digest::HmacMd5
+            + digest::HmacSha1
+            + digest::HmacSha224
             + digest::HmacSha256
             + digest::HmacSha384
             + digest::HmacSha512,
@@ -443,6 +465,9 @@ impl<
 impl<
         'a,
         H: digest::Digest<'a, DIGEST_LEN>
+            + digest::HmacMd5
+            + digest::HmacSha1
+            + digest::HmacSha224
             + digest::HmacSha256
             + digest::HmacSha384
             + digest::HmacSha512,
@@ -496,6 +521,9 @@ impl<
 impl<
         'a,
         H: digest::Digest<'a, DIGEST_LEN>
+            + digest::HmacMd5
+            + digest::HmacSha1
+            + digest::HmacSha224
             + digest::HmacSha256
             + digest::HmacSha384
             + digest::HmacSha512,
@@ -642,6 +670,21 @@ impl<
                                 app.sha_operation = Some(ShaOperation::Sha512);
                                 CommandReturn::success()
                             }
+                            // SHA224
+                            3 => {
+                                app.sha_operation = Some(ShaOperation::Sha224);
+                                CommandReturn::success()
+                            }
+                            // SHA1
+                            4 => {
+                                app.sha_operation = Some(ShaOperation::Sha1);
+                                CommandReturn::success()
+                            }
+                            // Md5
+                            5 => {
+                                app.sha_operation = Some(ShaOperation::Md5);
+                                CommandReturn::success()
+                            }
                             _ => CommandReturn::failure(ErrorCode::NOSUPPORT),
                         }
                     }

capsules/extra/src/hmac_sha256.rs

@@ -548,3 +548,27 @@ impl<'a, S: hil::digest::Sha256 + hil::digest::DigestDataHash<'a, 32>> hil::dige
         Err(ErrorCode::NOSUPPORT)
     }
 }
+
+impl<'a, S: hil::digest::Sha256 + hil::digest::DigestDataHash<'a, 32>> hil::digest::HmacSha224
+    for HmacSha256Software<'a, S>
+{
+    fn set_mode_hmacsha224(&self, _key: &[u8]) -> Result<(), ErrorCode> {
+        Err(ErrorCode::NOSUPPORT)
+    }
+}
+
+impl<'a, S: hil::digest::Sha256 + hil::digest::DigestDataHash<'a, 32>> hil::digest::HmacSha1
+    for HmacSha256Software<'a, S>
+{
+    fn set_mode_hmacsha1(&self, _key: &[u8]) -> Result<(), ErrorCode> {
+        Err(ErrorCode::NOSUPPORT)
+    }
+}
+
+impl<'a, S: hil::digest::Sha256 + hil::digest::DigestDataHash<'a, 32>> hil::digest::HmacMd5
+    for HmacSha256Software<'a, S>
+{
+    fn set_mode_hmacmd5(&self, _key: &[u8]) -> Result<(), ErrorCode> {
+        Err(ErrorCode::NOSUPPORT)
+    }
+}