crypto: lib/sha256 - Use generic block helper

Use the BLOCK_HASH_UPDATE_BLOCKS helper instead of duplicating
partial block handling.

Also remove the unused lib/sha256 force-generic interface.

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/include/crypto/internal/sha2.h b/include/crypto/internal/sha2.h
index fff156f66edc31b27228efd9cbb37a25477daa5a..b9bccd3ff57fc0f39f0e6a8cd55b0864eaabe4ea 100644 (file)
--- a/include/crypto/internal/sha2.h
+++ b/include/crypto/internal/sha2.h
@@ -10,13 +10,6 @@
 #include <linux/types.h>
 #include <linux/unaligned.h>
 
-void sha256_update_generic(struct sha256_state *sctx,
-                          const u8 *data, size_t len);
-void sha256_final_generic(struct sha256_state *sctx,
-                         u8 out[SHA256_DIGEST_SIZE]);
-void sha224_final_generic(struct sha256_state *sctx,
-                         u8 out[SHA224_DIGEST_SIZE]);
-
 #if IS_ENABLED(CONFIG_CRYPTO_ARCH_HAVE_LIB_SHA256)
 bool sha256_is_arch_optimized(void);
 #else

diff --git a/lib/crypto/sha256.c b/lib/crypto/sha256.c
index 2ced29efa181c2116c987aac555de281ef51e489..107e5162507a7f1db171ba28f9fbc2faeb73c8d4 100644 (file)
--- a/lib/crypto/sha256.c
+++ b/lib/crypto/sha256.c
@@ -11,6 +11,7 @@
  * Copyright (c) 2014 Red Hat Inc.
  */
 
+#include <crypto/internal/blockhash.h>
 #include <crypto/internal/sha2.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
@@ -31,71 +32,40 @@ static inline bool sha256_purgatory(void)
 }
 
 static inline void sha256_blocks(u32 state[SHA256_STATE_WORDS], const u8 *data,
-                                size_t nblocks, bool force_generic)
+                                size_t nblocks)
 {
-       sha256_choose_blocks(state, data, nblocks,
-                            force_generic || sha256_purgatory(), false);
+       sha256_choose_blocks(state, data, nblocks, sha256_purgatory(), false);
 }
 
-static inline void __sha256_update(struct sha256_state *sctx, const u8 *data,
-                                  size_t len, bool force_generic)
+void sha256_update(struct sha256_state *sctx, const u8 *data, size_t len)
 {
        size_t partial = sctx->count % SHA256_BLOCK_SIZE;
 
        sctx->count += len;
-
-       if (partial + len >= SHA256_BLOCK_SIZE) {
-               size_t nblocks;
-
-               if (partial) {
-                       size_t l = SHA256_BLOCK_SIZE - partial;
-
-                       memcpy(&sctx->buf[partial], data, l);
-                       data += l;
-                       len -= l;
-
-                       sha256_blocks(sctx->state, sctx->buf, 1, force_generic);
-               }
-
-               nblocks = len / SHA256_BLOCK_SIZE;
-               len %= SHA256_BLOCK_SIZE;
-
-               if (nblocks) {
-                       sha256_blocks(sctx->state, data, nblocks,
-                                     force_generic);
-                       data += nblocks * SHA256_BLOCK_SIZE;
-               }
-               partial = 0;
-       }
-       if (len)
-               memcpy(&sctx->buf[partial], data, len);
-}
-
-void sha256_update(struct sha256_state *sctx, const u8 *data, size_t len)
-{
-       __sha256_update(sctx, data, len, false);
+       BLOCK_HASH_UPDATE_BLOCKS(sha256_blocks, sctx->ctx.state, data, len,
+                                SHA256_BLOCK_SIZE, sctx->buf, partial);
 }
 EXPORT_SYMBOL(sha256_update);
 
 static inline void __sha256_final(struct sha256_state *sctx, u8 *out,
-                                 size_t digest_size, bool force_generic)
+                                 size_t digest_size)
 {
        size_t partial = sctx->count % SHA256_BLOCK_SIZE;
 
        sha256_finup(&sctx->ctx, sctx->buf, partial, out, digest_size,
-                    force_generic || sha256_purgatory(), false);
+                    sha256_purgatory(), false);
        memzero_explicit(sctx, sizeof(*sctx));
 }
 
 void sha256_final(struct sha256_state *sctx, u8 out[SHA256_DIGEST_SIZE])
 {
-       __sha256_final(sctx, out, SHA256_DIGEST_SIZE, false);
+       __sha256_final(sctx, out, SHA256_DIGEST_SIZE);
 }
 EXPORT_SYMBOL(sha256_final);
 
 void sha224_final(struct sha256_state *sctx, u8 out[SHA224_DIGEST_SIZE])
 {
-       __sha256_final(sctx, out, SHA224_DIGEST_SIZE, false);
+       __sha256_final(sctx, out, SHA224_DIGEST_SIZE);
 }
 EXPORT_SYMBOL(sha224_final);
 
@@ -109,26 +79,5 @@ void sha256(const u8 *data, size_t len, u8 out[SHA256_DIGEST_SIZE])
 }
 EXPORT_SYMBOL(sha256);
 
-#if IS_ENABLED(CONFIG_CRYPTO_SHA256) && !defined(__DISABLE_EXPORTS)
-void sha256_update_generic(struct sha256_state *sctx,
-                          const u8 *data, size_t len)
-{
-       __sha256_update(sctx, data, len, true);
-}
-EXPORT_SYMBOL(sha256_update_generic);
-
-void sha256_final_generic(struct sha256_state *sctx, u8 out[SHA256_DIGEST_SIZE])
-{
-       __sha256_final(sctx, out, SHA256_DIGEST_SIZE, true);
-}
-EXPORT_SYMBOL(sha256_final_generic);
-
-void sha224_final_generic(struct sha256_state *sctx, u8 out[SHA224_DIGEST_SIZE])
-{
-       __sha256_final(sctx, out, SHA224_DIGEST_SIZE, true);
-}
-EXPORT_SYMBOL(sha224_final_generic);
-#endif
-
 MODULE_DESCRIPTION("SHA-256 Algorithm");
 MODULE_LICENSE("GPL");