crypto: riscv/ghash - Use API partial block handling

Use the Crypto API partial block handling.

As this was the last user relying on crypto/ghash.h for gf128mul.h,
remove the unnecessary inclusion of gf128mul.h from crypto/ghash.h.

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

diff --git a/arch/riscv/crypto/ghash-riscv64-glue.c b/arch/riscv/crypto/ghash-riscv64-glue.c
index 312e7891fd0a36ceee68de31d90f6b1918e684f8..d86073d253872b4d73bb87ff98d244c470c55594 100644 (file)
--- a/arch/riscv/crypto/ghash-riscv64-glue.c
+++ b/arch/riscv/crypto/ghash-riscv64-glue.c
@@ -11,11 +11,16 @@
 
 #include <asm/simd.h>
 #include <asm/vector.h>
+#include <crypto/b128ops.h>
+#include <crypto/gf128mul.h>
 #include <crypto/ghash.h>
 #include <crypto/internal/hash.h>
 #include <crypto/internal/simd.h>
-#include <linux/linkage.h>
+#include <crypto/utils.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/string.h>
 
 asmlinkage void ghash_zvkg(be128 *accumulator, const be128 *key, const u8 *data,
                           size_t len);
@@ -26,8 +31,6 @@ struct riscv64_ghash_tfm_ctx {
 
 struct riscv64_ghash_desc_ctx {
        be128 accumulator;
-       u8 buffer[GHASH_BLOCK_SIZE];
-       u32 bytes;
 };
 
 static int riscv64_ghash_setkey(struct crypto_shash *tfm, const u8 *key,
@@ -78,50 +81,24 @@ static int riscv64_ghash_update(struct shash_desc *desc, const u8 *src,
 {
        const struct riscv64_ghash_tfm_ctx *tctx = crypto_shash_ctx(desc->tfm);
        struct riscv64_ghash_desc_ctx *dctx = shash_desc_ctx(desc);
-       unsigned int len;
-
-       if (dctx->bytes) {
-               if (dctx->bytes + srclen < GHASH_BLOCK_SIZE) {
-                       memcpy(dctx->buffer + dctx->bytes, src, srclen);
-                       dctx->bytes += srclen;
-                       return 0;
-               }
-               memcpy(dctx->buffer + dctx->bytes, src,
-                      GHASH_BLOCK_SIZE - dctx->bytes);
-               riscv64_ghash_blocks(tctx, dctx, dctx->buffer,
-                                    GHASH_BLOCK_SIZE);
-               src += GHASH_BLOCK_SIZE - dctx->bytes;
-               srclen -= GHASH_BLOCK_SIZE - dctx->bytes;
-               dctx->bytes = 0;
-       }
-
-       len = round_down(srclen, GHASH_BLOCK_SIZE);
-       if (len) {
-               riscv64_ghash_blocks(tctx, dctx, src, len);
-               src += len;
-               srclen -= len;
-       }
 
-       if (srclen) {
-               memcpy(dctx->buffer, src, srclen);
-               dctx->bytes = srclen;
-       }
-
-       return 0;
+       riscv64_ghash_blocks(tctx, dctx, src,
+                            round_down(srclen, GHASH_BLOCK_SIZE));
+       return srclen - round_down(srclen, GHASH_BLOCK_SIZE);
 }
 
-static int riscv64_ghash_final(struct shash_desc *desc, u8 *out)
+static int riscv64_ghash_finup(struct shash_desc *desc, const u8 *src,
+                              unsigned int len, u8 *out)
 {
        const struct riscv64_ghash_tfm_ctx *tctx = crypto_shash_ctx(desc->tfm);
        struct riscv64_ghash_desc_ctx *dctx = shash_desc_ctx(desc);
-       int i;
 
-       if (dctx->bytes) {
-               for (i = dctx->bytes; i < GHASH_BLOCK_SIZE; i++)
-                       dctx->buffer[i] = 0;
+       if (len) {
+               u8 buf[GHASH_BLOCK_SIZE] = {};
 
-               riscv64_ghash_blocks(tctx, dctx, dctx->buffer,
-                                    GHASH_BLOCK_SIZE);
+               memcpy(buf, src, len);
+               riscv64_ghash_blocks(tctx, dctx, buf, GHASH_BLOCK_SIZE);
+               memzero_explicit(buf, sizeof(buf));
        }
 
        memcpy(out, &dctx->accumulator, GHASH_DIGEST_SIZE);
@@ -131,7 +108,7 @@ static int riscv64_ghash_final(struct shash_desc *desc, u8 *out)
 static struct shash_alg riscv64_ghash_alg = {
        .init = riscv64_ghash_init,
        .update = riscv64_ghash_update,
-       .final = riscv64_ghash_final,
+       .finup = riscv64_ghash_finup,
        .setkey = riscv64_ghash_setkey,
        .descsize = sizeof(struct riscv64_ghash_desc_ctx),
        .digestsize = GHASH_DIGEST_SIZE,
@@ -139,6 +116,7 @@ static struct shash_alg riscv64_ghash_alg = {
                .cra_blocksize = GHASH_BLOCK_SIZE,
                .cra_ctxsize = sizeof(struct riscv64_ghash_tfm_ctx),
                .cra_priority = 300,
+               .cra_flags = CRYPTO_AHASH_ALG_BLOCK_ONLY,
                .cra_name = "ghash",
                .cra_driver_name = "ghash-riscv64-zvkg",
                .cra_module = THIS_MODULE,

diff --git a/include/crypto/ghash.h b/include/crypto/ghash.h
index 16904f2b51840251d8d6ab0fc0c0dd7bae5a155a..043d938e9a2c3c4b616975f610067d905eba7d91 100644 (file)
--- a/include/crypto/ghash.h
+++ b/include/crypto/ghash.h
@@ -7,7 +7,6 @@
 #define __CRYPTO_GHASH_H__
 
 #include <linux/types.h>
-#include <crypto/gf128mul.h>
 
 #define GHASH_BLOCK_SIZE       16
 #define GHASH_DIGEST_SIZE      16