stm32u5xx: 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

@@ -45,6 +45,6 @@ flash: $(TOCK_ROOT_DIRECTORY)target/$(TARGET)/release/$(PLATFORM).elf
 
 .PHONY: program
 program:
-	# Note: tockloader does not natively wrap probe-rs yet. 
+	# Note: tockloader does not natively wrap probe-rs yet.
 	# The --openocd flag was removed; tockloader will use its default method (usually serial/jlink).
 	tockloader install --board nucleo_u545re_q $(APP)

boards/nucleo_u545re_q/src/main.rs

@@ -6,6 +6,7 @@
 #![no_std]
 #![no_main]
 
+use components::hmac_component_static;
 use kernel::capabilities;
 use kernel::component::Component;
 use kernel::debug::PanicResources;
@@ -52,6 +53,11 @@ struct NucleoU545RE {
             stm32u545::tim::Tim2<'static>,
         >,
     >,
+    hmac: &'static capsules_extra::hmac::HmacDriver<
+        'static,
+        stm32u545::hash::sha256::Sha256Adapter<'static>,
+        32,
+    >,
 }
 
 impl SyscallDriverLookup for NucleoU545RE {
@@ -64,6 +70,7 @@ impl SyscallDriverLookup for NucleoU545RE {
             capsules_core::led::DRIVER_NUM => f(Some(self.led)),
             capsules_core::button::DRIVER_NUM => f(Some(self.button)),
             capsules_core::alarm::DRIVER_NUM => f(Some(self.alarm)),
+            capsules_extra::hmac::DRIVER_NUM => f(Some(self.hmac)),
             _ => f(None),
         }
     }
@@ -152,10 +159,17 @@ unsafe fn start() -> (
     );
     usart1.register();
 
+    let hash = static_init!(
+        stm32u545::hash::hash::Hash<'static>,
+        stm32u545::hash::hash::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)
@@ -165,6 +179,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));
@@ -233,6 +257,16 @@ unsafe fn start() -> (
     )
     .finalize(components::button_component_static!(stm32u545::gpio::Pin));
 
+    let hmac = components::hmac::HmacComponent::new(
+        board_kernel,
+        capsules_extra::hmac::DRIVER_NUM,
+        sha256,
+    )
+    .finalize(hmac_component_static!(
+        stm32u545::hash::sha256::Sha256Adapter<'static>,
+        32
+    ));
+
     // Platform and Interrupts
     let platform = static_init!(
         NucleoU545RE,
@@ -244,6 +278,7 @@ unsafe fn start() -> (
             led,
             button,
             alarm,
+            hmac
         }
     );
 

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)
+    }
+}