crypto: chacha - move existing library code into lib/crypto
authorArd Biesheuvel <ardb@kernel.org>
Fri, 8 Nov 2019 12:22:08 +0000 (13:22 +0100)
committerHerbert Xu <herbert@gondor.apana.org.au>
Sun, 17 Nov 2019 01:02:39 +0000 (09:02 +0800)
Currently, our generic ChaCha implementation consists of a permute
function in lib/chacha.c that operates on the 64-byte ChaCha state
directly [and which is always included into the core kernel since it
is used by the /dev/random driver], and the crypto API plumbing to
expose it as a skcipher.

In order to support in-kernel users that need the ChaCha streamcipher
but have no need [or tolerance] for going through the abstractions of
the crypto API, let's expose the streamcipher bits via a library API
as well, in a way that permits the implementation to be superseded by
an architecture specific one if provided.

So move the streamcipher code into a separate module in lib/crypto,
and expose the init() and crypt() routines to users of the library.

Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
13 files changed:
arch/arm/crypto/chacha-neon-glue.c
arch/arm64/crypto/chacha-neon-glue.c
arch/x86/crypto/chacha_glue.c
crypto/Kconfig
crypto/chacha_generic.c
include/crypto/chacha.h
include/crypto/internal/chacha.h [new file with mode: 0644]
lib/Makefile
lib/chacha.c [deleted file]
lib/crypto/Kconfig
lib/crypto/Makefile
lib/crypto/chacha.c [new file with mode: 0644]
lib/crypto/libchacha.c [new file with mode: 0644]

index a8e9b534c8da5ec01eb64cd75de9769e84ad7821..26576772f18bb85eb29221fe53a023f28f8580db 100644 (file)
@@ -20,7 +20,7 @@
  */
 
 #include <crypto/algapi.h>
-#include <crypto/chacha.h>
+#include <crypto/internal/chacha.h>
 #include <crypto/internal/simd.h>
 #include <crypto/internal/skcipher.h>
 #include <linux/kernel.h>
index 1495d2b18518d4886f88e6ac8010754136381c68..d4cc61bfe79dfdfe46f9525c5cccc2b922a1a464 100644 (file)
@@ -20,7 +20,7 @@
  */
 
 #include <crypto/algapi.h>
-#include <crypto/chacha.h>
+#include <crypto/internal/chacha.h>
 #include <crypto/internal/simd.h>
 #include <crypto/internal/skcipher.h>
 #include <linux/kernel.h>
index 388f95a4ec2402d43b55c9cfdc88e92a7e5ffaa8..bc62daa8dafd3d4cbf9a7448b27905584a52f349 100644 (file)
@@ -7,7 +7,7 @@
  */
 
 #include <crypto/algapi.h>
-#include <crypto/chacha.h>
+#include <crypto/internal/chacha.h>
 #include <crypto/internal/simd.h>
 #include <crypto/internal/skcipher.h>
 #include <linux/kernel.h>
index 9def945e9549c6e60d2b1e836d0bff699e5ddf66..ae4495ae003f3260294670e57ca4263b15420c4c 100644 (file)
@@ -1412,6 +1412,7 @@ config CRYPTO_SALSA20
 
 config CRYPTO_CHACHA20
        tristate "ChaCha stream cipher algorithms"
+       select CRYPTO_LIB_CHACHA_GENERIC
        select CRYPTO_SKCIPHER
        help
          The ChaCha20, XChaCha20, and XChaCha12 stream cipher algorithms.
index 085d8d219987a18d8b6fd419c480202d75a94d93..ebae6d9d9b320968c193746e5706e4877f75ea49 100644 (file)
@@ -8,29 +8,10 @@
 
 #include <asm/unaligned.h>
 #include <crypto/algapi.h>
-#include <crypto/chacha.h>
+#include <crypto/internal/chacha.h>
 #include <crypto/internal/skcipher.h>
 #include <linux/module.h>
 
-static void chacha_docrypt(u32 *state, u8 *dst, const u8 *src,
-                          unsigned int bytes, int nrounds)
-{
-       /* aligned to potentially speed up crypto_xor() */
-       u8 stream[CHACHA_BLOCK_SIZE] __aligned(sizeof(long));
-
-       while (bytes >= CHACHA_BLOCK_SIZE) {
-               chacha_block(state, stream, nrounds);
-               crypto_xor_cpy(dst, src, stream, CHACHA_BLOCK_SIZE);
-               bytes -= CHACHA_BLOCK_SIZE;
-               dst += CHACHA_BLOCK_SIZE;
-               src += CHACHA_BLOCK_SIZE;
-       }
-       if (bytes) {
-               chacha_block(state, stream, nrounds);
-               crypto_xor_cpy(dst, src, stream, bytes);
-       }
-}
-
 static int chacha_stream_xor(struct skcipher_request *req,
                             const struct chacha_ctx *ctx, const u8 *iv)
 {
@@ -48,8 +29,8 @@ static int chacha_stream_xor(struct skcipher_request *req,
                if (nbytes < walk.total)
                        nbytes = round_down(nbytes, CHACHA_BLOCK_SIZE);
 
-               chacha_docrypt(state, walk.dst.virt.addr, walk.src.virt.addr,
-                              nbytes, ctx->nrounds);
+               chacha_crypt_generic(state, walk.dst.virt.addr,
+                                    walk.src.virt.addr, nbytes, ctx->nrounds);
                err = skcipher_walk_done(&walk, walk.nbytes - nbytes);
        }
 
@@ -58,41 +39,10 @@ static int chacha_stream_xor(struct skcipher_request *req,
 
 void crypto_chacha_init(u32 *state, const struct chacha_ctx *ctx, const u8 *iv)
 {
-       state[0]  = 0x61707865; /* "expa" */
-       state[1]  = 0x3320646e; /* "nd 3" */
-       state[2]  = 0x79622d32; /* "2-by" */
-       state[3]  = 0x6b206574; /* "te k" */
-       state[4]  = ctx->key[0];
-       state[5]  = ctx->key[1];
-       state[6]  = ctx->key[2];
-       state[7]  = ctx->key[3];
-       state[8]  = ctx->key[4];
-       state[9]  = ctx->key[5];
-       state[10] = ctx->key[6];
-       state[11] = ctx->key[7];
-       state[12] = get_unaligned_le32(iv +  0);
-       state[13] = get_unaligned_le32(iv +  4);
-       state[14] = get_unaligned_le32(iv +  8);
-       state[15] = get_unaligned_le32(iv + 12);
+       chacha_init_generic(state, ctx->key, iv);
 }
 EXPORT_SYMBOL_GPL(crypto_chacha_init);
 
-static int chacha_setkey(struct crypto_skcipher *tfm, const u8 *key,
-                        unsigned int keysize, int nrounds)
-{
-       struct chacha_ctx *ctx = crypto_skcipher_ctx(tfm);
-       int i;
-
-       if (keysize != CHACHA_KEY_SIZE)
-               return -EINVAL;
-
-       for (i = 0; i < ARRAY_SIZE(ctx->key); i++)
-               ctx->key[i] = get_unaligned_le32(key + i * sizeof(u32));
-
-       ctx->nrounds = nrounds;
-       return 0;
-}
-
 int crypto_chacha20_setkey(struct crypto_skcipher *tfm, const u8 *key,
                           unsigned int keysize)
 {
@@ -126,7 +76,7 @@ int crypto_xchacha_crypt(struct skcipher_request *req)
 
        /* Compute the subkey given the original key and first 128 nonce bits */
        crypto_chacha_init(state, ctx, req->iv);
-       hchacha_block(state, subctx.key, ctx->nrounds);
+       hchacha_block_generic(state, subctx.key, ctx->nrounds);
        subctx.nrounds = ctx->nrounds;
 
        /* Build the real IV */
index d1e723c6a37dd9e3faac1452e1e28d9cca2eef3b..5c662f8fecac0472c777fbf02b795a1dd245f561 100644 (file)
@@ -15,9 +15,8 @@
 #ifndef _CRYPTO_CHACHA_H
 #define _CRYPTO_CHACHA_H
 
-#include <crypto/skcipher.h>
+#include <asm/unaligned.h>
 #include <linux/types.h>
-#include <linux/crypto.h>
 
 /* 32-bit stream position, then 96-bit nonce (RFC7539 convention) */
 #define CHACHA_IV_SIZE         16
 /* 192-bit nonce, then 64-bit stream position */
 #define XCHACHA_IV_SIZE                32
 
-struct chacha_ctx {
-       u32 key[8];
-       int nrounds;
-};
-
-void chacha_block(u32 *state, u8 *stream, int nrounds);
+void chacha_block_generic(u32 *state, u8 *stream, int nrounds);
 static inline void chacha20_block(u32 *state, u8 *stream)
 {
-       chacha_block(state, stream, 20);
+       chacha_block_generic(state, stream, 20);
 }
-void hchacha_block(const u32 *in, u32 *out, int nrounds);
 
-void crypto_chacha_init(u32 *state, const struct chacha_ctx *ctx, const u8 *iv);
+void hchacha_block_arch(const u32 *state, u32 *out, int nrounds);
+void hchacha_block_generic(const u32 *state, u32 *out, int nrounds);
+
+static inline void hchacha_block(const u32 *state, u32 *out, int nrounds)
+{
+       if (IS_ENABLED(CONFIG_CRYPTO_ARCH_HAVE_LIB_CHACHA))
+               hchacha_block_arch(state, out, nrounds);
+       else
+               hchacha_block_generic(state, out, nrounds);
+}
 
-int crypto_chacha20_setkey(struct crypto_skcipher *tfm, const u8 *key,
-                          unsigned int keysize);
-int crypto_chacha12_setkey(struct crypto_skcipher *tfm, const u8 *key,
-                          unsigned int keysize);
+void chacha_init_arch(u32 *state, const u32 *key, const u8 *iv);
+static inline void chacha_init_generic(u32 *state, const u32 *key, const u8 *iv)
+{
+       state[0]  = 0x61707865; /* "expa" */
+       state[1]  = 0x3320646e; /* "nd 3" */
+       state[2]  = 0x79622d32; /* "2-by" */
+       state[3]  = 0x6b206574; /* "te k" */
+       state[4]  = key[0];
+       state[5]  = key[1];
+       state[6]  = key[2];
+       state[7]  = key[3];
+       state[8]  = key[4];
+       state[9]  = key[5];
+       state[10] = key[6];
+       state[11] = key[7];
+       state[12] = get_unaligned_le32(iv +  0);
+       state[13] = get_unaligned_le32(iv +  4);
+       state[14] = get_unaligned_le32(iv +  8);
+       state[15] = get_unaligned_le32(iv + 12);
+}
 
-int crypto_chacha_crypt(struct skcipher_request *req);
-int crypto_xchacha_crypt(struct skcipher_request *req);
+static inline void chacha_init(u32 *state, const u32 *key, const u8 *iv)
+{
+       if (IS_ENABLED(CONFIG_CRYPTO_ARCH_HAVE_LIB_CHACHA))
+               chacha_init_arch(state, key, iv);
+       else
+               chacha_init_generic(state, key, iv);
+}
+
+void chacha_crypt_arch(u32 *state, u8 *dst, const u8 *src,
+                      unsigned int bytes, int nrounds);
+void chacha_crypt_generic(u32 *state, u8 *dst, const u8 *src,
+                         unsigned int bytes, int nrounds);
+
+static inline void chacha_crypt(u32 *state, u8 *dst, const u8 *src,
+                               unsigned int bytes, int nrounds)
+{
+       if (IS_ENABLED(CONFIG_CRYPTO_ARCH_HAVE_LIB_CHACHA))
+               chacha_crypt_arch(state, dst, src, bytes, nrounds);
+       else
+               chacha_crypt_generic(state, dst, src, bytes, nrounds);
+}
+
+static inline void chacha20_crypt(u32 *state, u8 *dst, const u8 *src,
+                                 unsigned int bytes)
+{
+       chacha_crypt(state, dst, src, bytes, 20);
+}
 
 #endif /* _CRYPTO_CHACHA_H */
diff --git a/include/crypto/internal/chacha.h b/include/crypto/internal/chacha.h
new file mode 100644 (file)
index 0000000..c0e40b2
--- /dev/null
@@ -0,0 +1,53 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#ifndef _CRYPTO_INTERNAL_CHACHA_H
+#define _CRYPTO_INTERNAL_CHACHA_H
+
+#include <crypto/chacha.h>
+#include <crypto/internal/skcipher.h>
+#include <linux/crypto.h>
+
+struct chacha_ctx {
+       u32 key[8];
+       int nrounds;
+};
+
+void crypto_chacha_init(u32 *state, const struct chacha_ctx *ctx, const u8 *iv);
+
+static inline int chacha_setkey(struct crypto_skcipher *tfm, const u8 *key,
+                               unsigned int keysize, int nrounds)
+{
+       struct chacha_ctx *ctx = crypto_skcipher_ctx(tfm);
+       int i;
+
+       if (keysize != CHACHA_KEY_SIZE)
+               return -EINVAL;
+
+       for (i = 0; i < ARRAY_SIZE(ctx->key); i++)
+               ctx->key[i] = get_unaligned_le32(key + i * sizeof(u32));
+
+       ctx->nrounds = nrounds;
+       return 0;
+}
+
+static inline int chacha20_setkey(struct crypto_skcipher *tfm, const u8 *key,
+                                 unsigned int keysize)
+{
+       return chacha_setkey(tfm, key, keysize, 20);
+}
+
+static int inline chacha12_setkey(struct crypto_skcipher *tfm, const u8 *key,
+                                 unsigned int keysize)
+{
+       return chacha_setkey(tfm, key, keysize, 12);
+}
+
+int crypto_chacha20_setkey(struct crypto_skcipher *tfm, const u8 *key,
+                          unsigned int keysize);
+int crypto_chacha12_setkey(struct crypto_skcipher *tfm, const u8 *key,
+                          unsigned int keysize);
+
+int crypto_chacha_crypt(struct skcipher_request *req);
+int crypto_xchacha_crypt(struct skcipher_request *req);
+
+#endif /* _CRYPTO_CHACHA_H */
index c5892807e06fa2c940103947d9272c66bcb4982d..5af38fd5cc603db7a151bced774bb6c6af5c4774 100644 (file)
@@ -26,8 +26,7 @@ endif
 
 lib-y := ctype.o string.o vsprintf.o cmdline.o \
         rbtree.o radix-tree.o timerqueue.o xarray.o \
-        idr.o extable.o \
-        sha1.o chacha.o irq_regs.o argv_split.o \
+        idr.o extable.o sha1.o irq_regs.o argv_split.o \
         flex_proportions.o ratelimit.o show_mem.o \
         is_single_threaded.o plist.o decompress.o kobject_uevent.o \
         earlycpio.o seq_buf.o siphash.o dec_and_lock.o \
diff --git a/lib/chacha.c b/lib/chacha.c
deleted file mode 100644 (file)
index c7c9826..0000000
+++ /dev/null
@@ -1,113 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * The "hash function" used as the core of the ChaCha stream cipher (RFC7539)
- *
- * Copyright (C) 2015 Martin Willi
- */
-
-#include <linux/kernel.h>
-#include <linux/export.h>
-#include <linux/bitops.h>
-#include <linux/cryptohash.h>
-#include <asm/unaligned.h>
-#include <crypto/chacha.h>
-
-static void chacha_permute(u32 *x, int nrounds)
-{
-       int i;
-
-       /* whitelist the allowed round counts */
-       WARN_ON_ONCE(nrounds != 20 && nrounds != 12);
-
-       for (i = 0; i < nrounds; i += 2) {
-               x[0]  += x[4];    x[12] = rol32(x[12] ^ x[0],  16);
-               x[1]  += x[5];    x[13] = rol32(x[13] ^ x[1],  16);
-               x[2]  += x[6];    x[14] = rol32(x[14] ^ x[2],  16);
-               x[3]  += x[7];    x[15] = rol32(x[15] ^ x[3],  16);
-
-               x[8]  += x[12];   x[4]  = rol32(x[4]  ^ x[8],  12);
-               x[9]  += x[13];   x[5]  = rol32(x[5]  ^ x[9],  12);
-               x[10] += x[14];   x[6]  = rol32(x[6]  ^ x[10], 12);
-               x[11] += x[15];   x[7]  = rol32(x[7]  ^ x[11], 12);
-
-               x[0]  += x[4];    x[12] = rol32(x[12] ^ x[0],   8);
-               x[1]  += x[5];    x[13] = rol32(x[13] ^ x[1],   8);
-               x[2]  += x[6];    x[14] = rol32(x[14] ^ x[2],   8);
-               x[3]  += x[7];    x[15] = rol32(x[15] ^ x[3],   8);
-
-               x[8]  += x[12];   x[4]  = rol32(x[4]  ^ x[8],   7);
-               x[9]  += x[13];   x[5]  = rol32(x[5]  ^ x[9],   7);
-               x[10] += x[14];   x[6]  = rol32(x[6]  ^ x[10],  7);
-               x[11] += x[15];   x[7]  = rol32(x[7]  ^ x[11],  7);
-
-               x[0]  += x[5];    x[15] = rol32(x[15] ^ x[0],  16);
-               x[1]  += x[6];    x[12] = rol32(x[12] ^ x[1],  16);
-               x[2]  += x[7];    x[13] = rol32(x[13] ^ x[2],  16);
-               x[3]  += x[4];    x[14] = rol32(x[14] ^ x[3],  16);
-
-               x[10] += x[15];   x[5]  = rol32(x[5]  ^ x[10], 12);
-               x[11] += x[12];   x[6]  = rol32(x[6]  ^ x[11], 12);
-               x[8]  += x[13];   x[7]  = rol32(x[7]  ^ x[8],  12);
-               x[9]  += x[14];   x[4]  = rol32(x[4]  ^ x[9],  12);
-
-               x[0]  += x[5];    x[15] = rol32(x[15] ^ x[0],   8);
-               x[1]  += x[6];    x[12] = rol32(x[12] ^ x[1],   8);
-               x[2]  += x[7];    x[13] = rol32(x[13] ^ x[2],   8);
-               x[3]  += x[4];    x[14] = rol32(x[14] ^ x[3],   8);
-
-               x[10] += x[15];   x[5]  = rol32(x[5]  ^ x[10],  7);
-               x[11] += x[12];   x[6]  = rol32(x[6]  ^ x[11],  7);
-               x[8]  += x[13];   x[7]  = rol32(x[7]  ^ x[8],   7);
-               x[9]  += x[14];   x[4]  = rol32(x[4]  ^ x[9],   7);
-       }
-}
-
-/**
- * chacha_block - generate one keystream block and increment block counter
- * @state: input state matrix (16 32-bit words)
- * @stream: output keystream block (64 bytes)
- * @nrounds: number of rounds (20 or 12; 20 is recommended)
- *
- * This is the ChaCha core, a function from 64-byte strings to 64-byte strings.
- * The caller has already converted the endianness of the input.  This function
- * also handles incrementing the block counter in the input matrix.
- */
-void chacha_block(u32 *state, u8 *stream, int nrounds)
-{
-       u32 x[16];
-       int i;
-
-       memcpy(x, state, 64);
-
-       chacha_permute(x, nrounds);
-
-       for (i = 0; i < ARRAY_SIZE(x); i++)
-               put_unaligned_le32(x[i] + state[i], &stream[i * sizeof(u32)]);
-
-       state[12]++;
-}
-EXPORT_SYMBOL(chacha_block);
-
-/**
- * hchacha_block - abbreviated ChaCha core, for XChaCha
- * @in: input state matrix (16 32-bit words)
- * @out: output (8 32-bit words)
- * @nrounds: number of rounds (20 or 12; 20 is recommended)
- *
- * HChaCha is the ChaCha equivalent of HSalsa and is an intermediate step
- * towards XChaCha (see https://cr.yp.to/snuffle/xsalsa-20081128.pdf).  HChaCha
- * skips the final addition of the initial state, and outputs only certain words
- * of the state.  It should not be used for streaming directly.
- */
-void hchacha_block(const u32 *in, u32 *out, int nrounds)
-{
-       u32 x[16];
-
-       memcpy(x, in, 64);
-
-       chacha_permute(x, nrounds);
-
-       memcpy(&out[0], &x[0], 16);
-       memcpy(&out[4], &x[12], 16);
-}
-EXPORT_SYMBOL(hchacha_block);
index 26143005159523c46fb559ee9df2cf58bedee91f..6a11931ae105234776bc866250537b545f7ebae9 100644 (file)
@@ -8,6 +8,32 @@ config CRYPTO_LIB_AES
 config CRYPTO_LIB_ARC4
        tristate
 
+config CRYPTO_ARCH_HAVE_LIB_CHACHA
+       tristate
+       help
+         Declares whether the architecture provides an arch-specific
+         accelerated implementation of the ChaCha library interface,
+         either builtin or as a module.
+
+config CRYPTO_LIB_CHACHA_GENERIC
+       tristate
+       select CRYPTO_ALGAPI
+       help
+         This symbol can be depended upon by arch implementations of the
+         ChaCha library interface that require the generic code as a
+         fallback, e.g., for SIMD implementations. If no arch specific
+         implementation is enabled, this implementation serves the users
+         of CRYPTO_LIB_CHACHA.
+
+config CRYPTO_LIB_CHACHA
+       tristate "ChaCha library interface"
+       depends on CRYPTO_ARCH_HAVE_LIB_CHACHA || !CRYPTO_ARCH_HAVE_LIB_CHACHA
+       select CRYPTO_LIB_CHACHA_GENERIC if CRYPTO_ARCH_HAVE_LIB_CHACHA=n
+       help
+         Enable the ChaCha library interface. This interface may be fulfilled
+         by either the generic implementation or an arch-specific one, if one
+         is available and enabled.
+
 config CRYPTO_LIB_DES
        tristate
 
index 63de4cb3fcf8255e35c4e7918c9fccd04823536c..0ce40604e104ce1b9f6b096dbe82f2026ca85d6b 100644 (file)
@@ -1,5 +1,9 @@
 # SPDX-License-Identifier: GPL-2.0
 
+# chacha is used by the /dev/random driver which is always builtin
+obj-y                                          += chacha.o
+obj-$(CONFIG_CRYPTO_LIB_CHACHA_GENERIC)                += libchacha.o
+
 obj-$(CONFIG_CRYPTO_LIB_AES)                   += libaes.o
 libaes-y                                       := aes.o
 
diff --git a/lib/crypto/chacha.c b/lib/crypto/chacha.c
new file mode 100644 (file)
index 0000000..65ead6b
--- /dev/null
@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * The "hash function" used as the core of the ChaCha stream cipher (RFC7539)
+ *
+ * Copyright (C) 2015 Martin Willi
+ */
+
+#include <linux/bug.h>
+#include <linux/kernel.h>
+#include <linux/export.h>
+#include <linux/bitops.h>
+#include <linux/string.h>
+#include <linux/cryptohash.h>
+#include <asm/unaligned.h>
+#include <crypto/chacha.h>
+
+static void chacha_permute(u32 *x, int nrounds)
+{
+       int i;
+
+       /* whitelist the allowed round counts */
+       WARN_ON_ONCE(nrounds != 20 && nrounds != 12);
+
+       for (i = 0; i < nrounds; i += 2) {
+               x[0]  += x[4];    x[12] = rol32(x[12] ^ x[0],  16);
+               x[1]  += x[5];    x[13] = rol32(x[13] ^ x[1],  16);
+               x[2]  += x[6];    x[14] = rol32(x[14] ^ x[2],  16);
+               x[3]  += x[7];    x[15] = rol32(x[15] ^ x[3],  16);
+
+               x[8]  += x[12];   x[4]  = rol32(x[4]  ^ x[8],  12);
+               x[9]  += x[13];   x[5]  = rol32(x[5]  ^ x[9],  12);
+               x[10] += x[14];   x[6]  = rol32(x[6]  ^ x[10], 12);
+               x[11] += x[15];   x[7]  = rol32(x[7]  ^ x[11], 12);
+
+               x[0]  += x[4];    x[12] = rol32(x[12] ^ x[0],   8);
+               x[1]  += x[5];    x[13] = rol32(x[13] ^ x[1],   8);
+               x[2]  += x[6];    x[14] = rol32(x[14] ^ x[2],   8);
+               x[3]  += x[7];    x[15] = rol32(x[15] ^ x[3],   8);
+
+               x[8]  += x[12];   x[4]  = rol32(x[4]  ^ x[8],   7);
+               x[9]  += x[13];   x[5]  = rol32(x[5]  ^ x[9],   7);
+               x[10] += x[14];   x[6]  = rol32(x[6]  ^ x[10],  7);
+               x[11] += x[15];   x[7]  = rol32(x[7]  ^ x[11],  7);
+
+               x[0]  += x[5];    x[15] = rol32(x[15] ^ x[0],  16);
+               x[1]  += x[6];    x[12] = rol32(x[12] ^ x[1],  16);
+               x[2]  += x[7];    x[13] = rol32(x[13] ^ x[2],  16);
+               x[3]  += x[4];    x[14] = rol32(x[14] ^ x[3],  16);
+
+               x[10] += x[15];   x[5]  = rol32(x[5]  ^ x[10], 12);
+               x[11] += x[12];   x[6]  = rol32(x[6]  ^ x[11], 12);
+               x[8]  += x[13];   x[7]  = rol32(x[7]  ^ x[8],  12);
+               x[9]  += x[14];   x[4]  = rol32(x[4]  ^ x[9],  12);
+
+               x[0]  += x[5];    x[15] = rol32(x[15] ^ x[0],   8);
+               x[1]  += x[6];    x[12] = rol32(x[12] ^ x[1],   8);
+               x[2]  += x[7];    x[13] = rol32(x[13] ^ x[2],   8);
+               x[3]  += x[4];    x[14] = rol32(x[14] ^ x[3],   8);
+
+               x[10] += x[15];   x[5]  = rol32(x[5]  ^ x[10],  7);
+               x[11] += x[12];   x[6]  = rol32(x[6]  ^ x[11],  7);
+               x[8]  += x[13];   x[7]  = rol32(x[7]  ^ x[8],   7);
+               x[9]  += x[14];   x[4]  = rol32(x[4]  ^ x[9],   7);
+       }
+}
+
+/**
+ * chacha_block - generate one keystream block and increment block counter
+ * @state: input state matrix (16 32-bit words)
+ * @stream: output keystream block (64 bytes)
+ * @nrounds: number of rounds (20 or 12; 20 is recommended)
+ *
+ * This is the ChaCha core, a function from 64-byte strings to 64-byte strings.
+ * The caller has already converted the endianness of the input.  This function
+ * also handles incrementing the block counter in the input matrix.
+ */
+void chacha_block_generic(u32 *state, u8 *stream, int nrounds)
+{
+       u32 x[16];
+       int i;
+
+       memcpy(x, state, 64);
+
+       chacha_permute(x, nrounds);
+
+       for (i = 0; i < ARRAY_SIZE(x); i++)
+               put_unaligned_le32(x[i] + state[i], &stream[i * sizeof(u32)]);
+
+       state[12]++;
+}
+EXPORT_SYMBOL(chacha_block_generic);
+
+/**
+ * hchacha_block_generic - abbreviated ChaCha core, for XChaCha
+ * @state: input state matrix (16 32-bit words)
+ * @out: output (8 32-bit words)
+ * @nrounds: number of rounds (20 or 12; 20 is recommended)
+ *
+ * HChaCha is the ChaCha equivalent of HSalsa and is an intermediate step
+ * towards XChaCha (see https://cr.yp.to/snuffle/xsalsa-20081128.pdf).  HChaCha
+ * skips the final addition of the initial state, and outputs only certain words
+ * of the state.  It should not be used for streaming directly.
+ */
+void hchacha_block_generic(const u32 *state, u32 *stream, int nrounds)
+{
+       u32 x[16];
+
+       memcpy(x, state, 64);
+
+       chacha_permute(x, nrounds);
+
+       memcpy(&stream[0], &x[0], 16);
+       memcpy(&stream[4], &x[12], 16);
+}
+EXPORT_SYMBOL(hchacha_block_generic);
diff --git a/lib/crypto/libchacha.c b/lib/crypto/libchacha.c
new file mode 100644 (file)
index 0000000..dabc3ac
--- /dev/null
@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * The ChaCha stream cipher (RFC7539)
+ *
+ * Copyright (C) 2015 Martin Willi
+ */
+
+#include <linux/kernel.h>
+#include <linux/export.h>
+#include <linux/module.h>
+
+#include <crypto/algapi.h> // for crypto_xor_cpy
+#include <crypto/chacha.h>
+
+void chacha_crypt_generic(u32 *state, u8 *dst, const u8 *src,
+                         unsigned int bytes, int nrounds)
+{
+       /* aligned to potentially speed up crypto_xor() */
+       u8 stream[CHACHA_BLOCK_SIZE] __aligned(sizeof(long));
+
+       while (bytes >= CHACHA_BLOCK_SIZE) {
+               chacha_block_generic(state, stream, nrounds);
+               crypto_xor_cpy(dst, src, stream, CHACHA_BLOCK_SIZE);
+               bytes -= CHACHA_BLOCK_SIZE;
+               dst += CHACHA_BLOCK_SIZE;
+               src += CHACHA_BLOCK_SIZE;
+       }
+       if (bytes) {
+               chacha_block_generic(state, stream, nrounds);
+               crypto_xor_cpy(dst, src, stream, bytes);
+       }
+}
+EXPORT_SYMBOL(chacha_crypt_generic);
+
+MODULE_LICENSE("GPL");