]> git.ipfire.org Git - thirdparty/linux.git/commitdiff
lib/crypto: sha256: Propagate sha256_block_state type to implementations
authorEric Biggers <ebiggers@kernel.org>
Mon, 30 Jun 2025 16:06:38 +0000 (09:06 -0700)
committerEric Biggers <ebiggers@kernel.org>
Fri, 4 Jul 2025 17:22:57 +0000 (10:22 -0700)
The previous commit made the SHA-256 compression function state be
strongly typed, but it wasn't propagated all the way down to the
implementations of it.  Do that now.

Acked-by: Ard Biesheuvel <ardb@kernel.org>
Link: https://lore.kernel.org/r/20250630160645.3198-8-ebiggers@kernel.org
Signed-off-by: Eric Biggers <ebiggers@kernel.org>
17 files changed:
arch/mips/cavium-octeon/crypto/octeon-sha256.c
include/crypto/internal/sha2.h
lib/crypto/arm/sha256-ce.S
lib/crypto/arm/sha256.c
lib/crypto/arm64/sha256-ce.S
lib/crypto/arm64/sha256.c
lib/crypto/powerpc/sha256.c
lib/crypto/riscv/sha256-riscv64-zvknha_or_zvknhb-zvkb.S
lib/crypto/riscv/sha256.c
lib/crypto/s390/sha256.c
lib/crypto/sha256-generic.c
lib/crypto/sparc/sha256.c
lib/crypto/x86/sha256-avx-asm.S
lib/crypto/x86/sha256-avx2-asm.S
lib/crypto/x86/sha256-ni-asm.S
lib/crypto/x86/sha256-ssse3-asm.S
lib/crypto/x86/sha256.c

index c20038239cb6b78d0f72417871e530f253cc1e4e..f8664818d04ece8f642cc48b7bc8647e0ef4d6c4 100644 (file)
@@ -22,7 +22,7 @@
  * We pass everything as 64-bit. OCTEON can handle misaligned data.
  */
 
-void sha256_blocks_arch(u32 state[SHA256_STATE_WORDS],
+void sha256_blocks_arch(struct sha256_block_state *state,
                        const u8 *data, size_t nblocks)
 {
        struct octeon_cop2_state cop2_state;
index 5a25ccc493886ccaca4b0b858824f9baa238bb15..f0f455477bbd7b6e33efdb71a0c315699da26441 100644 (file)
@@ -17,9 +17,9 @@ static inline bool sha256_is_arch_optimized(void)
        return false;
 }
 #endif
-void sha256_blocks_generic(u32 state[SHA256_STATE_WORDS],
+void sha256_blocks_generic(struct sha256_block_state *state,
                           const u8 *data, size_t nblocks);
-void sha256_blocks_arch(u32 state[SHA256_STATE_WORDS],
+void sha256_blocks_arch(struct sha256_block_state *state,
                        const u8 *data, size_t nblocks);
 
 static __always_inline void sha256_choose_blocks(
@@ -27,9 +27,9 @@ static __always_inline void sha256_choose_blocks(
        bool force_generic, bool force_simd)
 {
        if (!IS_ENABLED(CONFIG_CRYPTO_ARCH_HAVE_LIB_SHA256) || force_generic)
-               sha256_blocks_generic(state, data, nblocks);
+               sha256_blocks_generic((struct sha256_block_state *)state, data, nblocks);
        else
-               sha256_blocks_arch(state, data, nblocks);
+               sha256_blocks_arch((struct sha256_block_state *)state, data, nblocks);
 }
 
 static __always_inline void sha256_finup(
index ac2c9b01b22d27d7e5f1148dc0528a720d5c506e..7481ac8e6c0d9f565f1801ce90c5183e139c0a2f 100644 (file)
@@ -67,7 +67,7 @@
        .word           0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 
        /*
-        * void sha256_ce_transform(u32 state[SHA256_STATE_WORDS],
+        * void sha256_ce_transform(struct sha256_block_state *state,
         *                          const u8 *data, size_t nblocks);
         */
 ENTRY(sha256_ce_transform)
index 2c9cfdaaa0691ad334dfeb9fd360cc24368503af..7d90823586952fd659fd06ee1a01faa147cb3617 100644 (file)
 #include <linux/kernel.h>
 #include <linux/module.h>
 
-asmlinkage void sha256_block_data_order(u32 state[SHA256_STATE_WORDS],
+asmlinkage void sha256_block_data_order(struct sha256_block_state *state,
                                        const u8 *data, size_t nblocks);
-asmlinkage void sha256_block_data_order_neon(u32 state[SHA256_STATE_WORDS],
+asmlinkage void sha256_block_data_order_neon(struct sha256_block_state *state,
                                             const u8 *data, size_t nblocks);
-asmlinkage void sha256_ce_transform(u32 state[SHA256_STATE_WORDS],
+asmlinkage void sha256_ce_transform(struct sha256_block_state *state,
                                    const u8 *data, size_t nblocks);
 
 static __ro_after_init DEFINE_STATIC_KEY_FALSE(have_neon);
 static __ro_after_init DEFINE_STATIC_KEY_FALSE(have_ce);
 
-void sha256_blocks_arch(u32 state[SHA256_STATE_WORDS],
+void sha256_blocks_arch(struct sha256_block_state *state,
                        const u8 *data, size_t nblocks)
 {
        if (IS_ENABLED(CONFIG_KERNEL_MODE_NEON) &&
index f3e21c6d87d2e09fe3e3ffb5fc999b9d55029ed6..b99d9589c421753b03020a582dc4e0e32f5d65c0 100644 (file)
@@ -71,7 +71,7 @@
        .word           0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 
        /*
-        * size_t __sha256_ce_transform(u32 state[SHA256_STATE_WORDS],
+        * size_t __sha256_ce_transform(struct sha256_block_state *state,
         *                              const u8 *data, size_t nblocks);
         */
        .text
index fb9bff40357be20eb912a64afce2e1c6875a060b..609ffb8151987092b31fd2600b38ae8fcf354ed4 100644 (file)
 #include <linux/kernel.h>
 #include <linux/module.h>
 
-asmlinkage void sha256_block_data_order(u32 state[SHA256_STATE_WORDS],
+asmlinkage void sha256_block_data_order(struct sha256_block_state *state,
                                        const u8 *data, size_t nblocks);
-asmlinkage void sha256_block_neon(u32 state[SHA256_STATE_WORDS],
+asmlinkage void sha256_block_neon(struct sha256_block_state *state,
                                  const u8 *data, size_t nblocks);
-asmlinkage size_t __sha256_ce_transform(u32 state[SHA256_STATE_WORDS],
+asmlinkage size_t __sha256_ce_transform(struct sha256_block_state *state,
                                        const u8 *data, size_t nblocks);
 
 static __ro_after_init DEFINE_STATIC_KEY_FALSE(have_neon);
 static __ro_after_init DEFINE_STATIC_KEY_FALSE(have_ce);
 
-void sha256_blocks_arch(u32 state[SHA256_STATE_WORDS],
+void sha256_blocks_arch(struct sha256_block_state *state,
                        const u8 *data, size_t nblocks)
 {
        if (IS_ENABLED(CONFIG_KERNEL_MODE_NEON) &&
index 6b0f079587eb6180aa9128005f7bdb7e3ff73b81..55f42403d572a2730ba4850932343d9fe6ffbe99 100644 (file)
@@ -26,7 +26,8 @@
  */
 #define MAX_BYTES 1024
 
-extern void ppc_spe_sha256_transform(u32 *state, const u8 *src, u32 blocks);
+extern void ppc_spe_sha256_transform(struct sha256_block_state *state,
+                                    const u8 *src, u32 blocks);
 
 static void spe_begin(void)
 {
@@ -42,7 +43,7 @@ static void spe_end(void)
        preempt_enable();
 }
 
-void sha256_blocks_arch(u32 state[SHA256_STATE_WORDS],
+void sha256_blocks_arch(struct sha256_block_state *state,
                        const u8 *data, size_t nblocks)
 {
        do {
index fad501ad0617186c034133120f5efd234d8899ca..1618d1220a6e7825566a1eaf6af2089b16478a01 100644 (file)
        sha256_4rounds  \last, \k3, W3, W0, W1, W2
 .endm
 
-// void sha256_transform_zvknha_or_zvknhb_zvkb(u32 state[SHA256_STATE_WORDS],
+// void sha256_transform_zvknha_or_zvknhb_zvkb(struct sha256_block_state *state,
 //                                            const u8 *data, size_t nblocks);
 SYM_FUNC_START(sha256_transform_zvknha_or_zvknhb_zvkb)
 
index aa77349d08f300d397c00f9b26dbe53903326249..a2079aa3ae9253d566ee45447c5d3ae8baedc493 100644 (file)
 #include <linux/kernel.h>
 #include <linux/module.h>
 
-asmlinkage void sha256_transform_zvknha_or_zvknhb_zvkb(
-       u32 state[SHA256_STATE_WORDS], const u8 *data, size_t nblocks);
+asmlinkage void
+sha256_transform_zvknha_or_zvknhb_zvkb(struct sha256_block_state *state,
+                                      const u8 *data, size_t nblocks);
 
 static __ro_after_init DEFINE_STATIC_KEY_FALSE(have_extensions);
 
-void sha256_blocks_arch(u32 state[SHA256_STATE_WORDS],
+void sha256_blocks_arch(struct sha256_block_state *state,
                        const u8 *data, size_t nblocks)
 {
        if (static_branch_likely(&have_extensions) && crypto_simd_usable()) {
index 7dfe120fafaba33f84977b2cb638f75f50cb283e..fb565718f7539ec12e865f1ba1a0e4eded5b9124 100644 (file)
@@ -12,7 +12,7 @@
 
 static __ro_after_init DEFINE_STATIC_KEY_FALSE(have_cpacf_sha256);
 
-void sha256_blocks_arch(u32 state[SHA256_STATE_WORDS],
+void sha256_blocks_arch(struct sha256_block_state *state,
                        const u8 *data, size_t nblocks)
 {
        if (static_branch_likely(&have_cpacf_sha256))
index 2968d95d04038aabc8f2cddf578e0547c14417e3..99f904033c261e9a49d4cc460c092b391aced040 100644 (file)
@@ -70,7 +70,7 @@ static inline void BLEND_OP(int I, u32 *W)
        h = t1 + t2;                                            \
 } while (0)
 
-static void sha256_block_generic(u32 state[SHA256_STATE_WORDS],
+static void sha256_block_generic(struct sha256_block_state *state,
                                 const u8 *input, u32 W[64])
 {
        u32 a, b, c, d, e, f, g, h;
@@ -101,8 +101,14 @@ static void sha256_block_generic(u32 state[SHA256_STATE_WORDS],
        }
 
        /* load the state into our registers */
-       a = state[0];  b = state[1];  c = state[2];  d = state[3];
-       e = state[4];  f = state[5];  g = state[6];  h = state[7];
+       a = state->h[0];
+       b = state->h[1];
+       c = state->h[2];
+       d = state->h[3];
+       e = state->h[4];
+       f = state->h[5];
+       g = state->h[6];
+       h = state->h[7];
 
        /* now iterate */
        for (i = 0; i < 64; i += 8) {
@@ -116,11 +122,17 @@ static void sha256_block_generic(u32 state[SHA256_STATE_WORDS],
                SHA256_ROUND(i + 7, b, c, d, e, f, g, h, a);
        }
 
-       state[0] += a; state[1] += b; state[2] += c; state[3] += d;
-       state[4] += e; state[5] += f; state[6] += g; state[7] += h;
+       state->h[0] += a;
+       state->h[1] += b;
+       state->h[2] += c;
+       state->h[3] += d;
+       state->h[4] += e;
+       state->h[5] += f;
+       state->h[6] += g;
+       state->h[7] += h;
 }
 
-void sha256_blocks_generic(u32 state[SHA256_STATE_WORDS],
+void sha256_blocks_generic(struct sha256_block_state *state,
                           const u8 *data, size_t nblocks)
 {
        u32 W[64];
index 8bdec2db08b3077da1edb1567eba996c9ea9f0a6..060664b88a6d3ed70566135d7d7c146d44633f87 100644 (file)
 
 static __ro_after_init DEFINE_STATIC_KEY_FALSE(have_sha256_opcodes);
 
-asmlinkage void sha256_sparc64_transform(u32 state[SHA256_STATE_WORDS],
+asmlinkage void sha256_sparc64_transform(struct sha256_block_state *state,
                                         const u8 *data, size_t nblocks);
 
-void sha256_blocks_arch(u32 state[SHA256_STATE_WORDS],
+void sha256_blocks_arch(struct sha256_block_state *state,
                        const u8 *data, size_t nblocks)
 {
        if (static_branch_likely(&have_sha256_opcodes))
index 0d7b2c3e45d9ad9c62fd891ed0a9318ee8b695ad..73bcff2b548f4af24408ec05b8d70dc1bbcdee5a 100644 (file)
@@ -341,7 +341,7 @@ a = TMP_
 .endm
 
 ########################################################################
-## void sha256_transform_avx(u32 state[SHA256_STATE_WORDS],
+## void sha256_transform_avx(struct sha256_block_state *state,
 ##                          const u8 *data, size_t nblocks);
 ########################################################################
 .text
index 25d3380321ec309c2a3e400c029abc535cb3bf42..45787570387f235167149d7cf7cfd7a62da15511 100644 (file)
@@ -518,7 +518,7 @@ STACK_SIZE  = _CTX      + _CTX_SIZE
 .endm
 
 ########################################################################
-## void sha256_transform_rorx(u32 state[SHA256_STATE_WORDS],
+## void sha256_transform_rorx(struct sha256_block_state *state,
 ##                           const u8 *data, size_t nblocks);
 ########################################################################
 .text
index d3548206cf3d4746c6f82d52596d427943a0686e..4af7d22e29e47ee814c6c74884c65b29836d88a0 100644 (file)
  * only processes complete blocks.  State initialization, buffering of partial
  * blocks, and digest finalization is expected to be handled elsewhere.
  *
- * void sha256_ni_transform(u32 state[SHA256_STATE_WORDS],
+ * void sha256_ni_transform(struct sha256_block_state *state,
  *                         const u8 *data, size_t nblocks);
  */
 .text
index 7f24a4cdcb257e794d930b8f38a9a17713b6949e..407b30adcd37f33d36ac99eef37609f7c971fb18 100644 (file)
@@ -348,7 +348,7 @@ a = TMP_
 .endm
 
 ########################################################################
-## void sha256_transform_ssse3(u32 state[SHA256_STATE_WORDS],
+## void sha256_transform_ssse3(struct sha256_block_state *state,
 ##                            const u8 *data, size_t nblocks);
 ########################################################################
 .text
index baba74d7d26f2e440e423526db80ff77cd32d051..cbb45defbefab1130ea335c7de67bb549f22b2cb 100644 (file)
 #include <linux/module.h>
 #include <linux/static_call.h>
 
-asmlinkage void sha256_transform_ssse3(u32 state[SHA256_STATE_WORDS],
+asmlinkage void sha256_transform_ssse3(struct sha256_block_state *state,
                                       const u8 *data, size_t nblocks);
-asmlinkage void sha256_transform_avx(u32 state[SHA256_STATE_WORDS],
+asmlinkage void sha256_transform_avx(struct sha256_block_state *state,
                                     const u8 *data, size_t nblocks);
-asmlinkage void sha256_transform_rorx(u32 state[SHA256_STATE_WORDS],
+asmlinkage void sha256_transform_rorx(struct sha256_block_state *state,
                                      const u8 *data, size_t nblocks);
-asmlinkage void sha256_ni_transform(u32 state[SHA256_STATE_WORDS],
+asmlinkage void sha256_ni_transform(struct sha256_block_state *state,
                                    const u8 *data, size_t nblocks);
 
 static __ro_after_init DEFINE_STATIC_KEY_FALSE(have_sha256_x86);
 
 DEFINE_STATIC_CALL(sha256_blocks_x86, sha256_transform_ssse3);
 
-void sha256_blocks_arch(u32 state[SHA256_STATE_WORDS],
+void sha256_blocks_arch(struct sha256_block_state *state,
                        const u8 *data, size_t nblocks)
 {
        if (static_branch_likely(&have_sha256_x86) && crypto_simd_usable()) {