crypto: inside-secure - Added support for the CHACHA20 skcipher

Added support for the CHACHA20 skcipher algorithm.
Tested on an eip197c-iesb configuration in the Xilinx VCU118 devboard,
passes all testmgr vectors plus the extra fuzzing tests.

changes since v1:
- rebased on top of DES library changes done on cryptodev/master
- fixed crypto/Kconfig so that generic fallback is compiled as well

changes since v2:
- made switch entry SAFEXCEL_AES explit and added empty default, as
  requested by Antoine Tenart. Also needed to make SM4 patches apply.

changes since v3:
- nothing

Signed-off-by: Pascal van Leeuwen <pvanleeuwen@verimatrix.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/drivers/crypto/inside-secure/safexcel.c b/drivers/crypto/inside-secure/safexcel.c
index d0f49a56f531d29f141509e8d5fdf98a97b17a41..f958c927f95ebf06032429b11c9ea51e0d93f7d6 100644 (file)
--- a/drivers/crypto/inside-secure/safexcel.c
+++ b/drivers/crypto/inside-secure/safexcel.c
@@ -1173,6 +1173,7 @@ static struct safexcel_alg_template *safexcel_algs[] = {
        &safexcel_alg_cbcmac,
        &safexcel_alg_xcbcmac,
        &safexcel_alg_cmac,
+       &safexcel_alg_chacha20,
 };
 
 static int safexcel_register_algorithms(struct safexcel_crypto_priv *priv)

diff --git a/drivers/crypto/inside-secure/safexcel.h b/drivers/crypto/inside-secure/safexcel.h
index 6ddc6d1bebfbd058065f83e76d51f13b0301c89b..c7f1a201354ab8c4a80608d27cd7dc652444af7a 100644 (file)
--- a/drivers/crypto/inside-secure/safexcel.h
+++ b/drivers/crypto/inside-secure/safexcel.h
@@ -358,6 +358,7 @@ struct safexcel_context_record {
 #define CONTEXT_CONTROL_CRYPTO_ALG_AES128      (0x5 << 17)
 #define CONTEXT_CONTROL_CRYPTO_ALG_AES192      (0x6 << 17)
 #define CONTEXT_CONTROL_CRYPTO_ALG_AES256      (0x7 << 17)
+#define CONTEXT_CONTROL_CRYPTO_ALG_CHACHA20    (0x8 << 17)
 #define CONTEXT_CONTROL_DIGEST_PRECOMPUTED     (0x1 << 21)
 #define CONTEXT_CONTROL_DIGEST_XCM             (0x2 << 21)
 #define CONTEXT_CONTROL_DIGEST_HMAC            (0x3 << 21)
@@ -378,6 +379,7 @@ struct safexcel_context_record {
 /* control1 */
 #define CONTEXT_CONTROL_CRYPTO_MODE_ECB                (0 << 0)
 #define CONTEXT_CONTROL_CRYPTO_MODE_CBC                (1 << 0)
+#define CONTEXT_CONTROL_CHACHA20_MODE_256_32   (2 << 0)
 #define CONTEXT_CONTROL_CRYPTO_MODE_OFB                (4 << 0)
 #define CONTEXT_CONTROL_CRYPTO_MODE_CFB                (5 << 0)
 #define CONTEXT_CONTROL_CRYPTO_MODE_CTR_LOAD   (6 << 0)
@@ -858,5 +860,6 @@ extern struct safexcel_alg_template safexcel_alg_crc32;
 extern struct safexcel_alg_template safexcel_alg_cbcmac;
 extern struct safexcel_alg_template safexcel_alg_xcbcmac;
 extern struct safexcel_alg_template safexcel_alg_cmac;
+extern struct safexcel_alg_template safexcel_alg_chacha20;
 
 #endif

diff --git a/drivers/crypto/inside-secure/safexcel_cipher.c b/drivers/crypto/inside-secure/safexcel_cipher.c
index ef51f8c2b473ba8c914a1d6258c7602697e96676..15d98a913da025f43a7a62f4b35f8699170b63fa 100644 (file)
--- a/drivers/crypto/inside-secure/safexcel_cipher.c
+++ b/drivers/crypto/inside-secure/safexcel_cipher.c
@@ -5,13 +5,14 @@
  * Antoine Tenart <antoine.tenart@free-electrons.com>
  */
 
+#include <asm/unaligned.h>
 #include <linux/device.h>
 #include <linux/dma-mapping.h>
 #include <linux/dmapool.h>
-
 #include <crypto/aead.h>
 #include <crypto/aes.h>
 #include <crypto/authenc.h>
+#include <crypto/chacha.h>
 #include <crypto/ctr.h>
 #include <crypto/internal/des.h>
 #include <crypto/gcm.h>
@@ -33,6 +34,7 @@ enum safexcel_cipher_alg {
        SAFEXCEL_DES,
        SAFEXCEL_3DES,
        SAFEXCEL_AES,
+       SAFEXCEL_CHACHA20,
 };
 
 struct safexcel_cipher_ctx {
@@ -80,6 +82,15 @@ static void safexcel_cipher_token(struct safexcel_cipher_ctx *ctx, u8 *iv,
                /* 32 bit counter, start at 1 (big endian!) */
                cdesc->control_data.token[3] = cpu_to_be32(1);
 
+               return;
+       } else if (ctx->alg == SAFEXCEL_CHACHA20) {
+               cdesc->control_data.options |= EIP197_OPTION_4_TOKEN_IV_CMD;
+
+               /* 96 bit nonce part */
+               memcpy(&cdesc->control_data.token[0], &iv[4], 12);
+               /* 32 bit counter */
+               cdesc->control_data.token[3] = *(u32 *)iv;
+
                return;
        } else if (ctx->xcm == EIP197_XCM_MODE_GCM) {
                cdesc->control_data.options |= EIP197_OPTION_4_TOKEN_IV_CMD;
@@ -116,6 +127,8 @@ static void safexcel_cipher_token(struct safexcel_cipher_ctx *ctx, u8 *iv,
                        block_sz = AES_BLOCK_SIZE;
                        cdesc->control_data.options |= EIP197_OPTION_4_TOKEN_IV_CMD;
                        break;
+               default:
+                       break;
                }
                memcpy(cdesc->control_data.token, iv, block_sz);
        }
@@ -480,6 +493,9 @@ static int safexcel_context_control(struct safexcel_cipher_ctx *ctx,
                                ctx->key_len >> ctx->xts);
                        return -EINVAL;
                }
+       } else if (ctx->alg == SAFEXCEL_CHACHA20) {
+               cdesc->control_data.control0 |=
+                       CONTEXT_CONTROL_CRYPTO_ALG_CHACHA20;
        }
 
        return 0;
@@ -2303,3 +2319,68 @@ struct safexcel_alg_template safexcel_alg_ccm = {
                },
        },
 };
+
+static int safexcel_skcipher_chacha20_setkey(struct crypto_skcipher *ctfm,
+                                            const u8 *key, unsigned int len)
+{
+       struct safexcel_cipher_ctx *ctx = crypto_skcipher_ctx(ctfm);
+       struct safexcel_crypto_priv *priv = ctx->priv;
+       int i;
+
+       if (len != CHACHA_KEY_SIZE) {
+               crypto_skcipher_set_flags(ctfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
+               return -EINVAL;
+       }
+
+       if (priv->flags & EIP197_TRC_CACHE && ctx->base.ctxr_dma) {
+               for (i = 0; i < CHACHA_KEY_SIZE / sizeof(u32); i++) {
+                       if (ctx->key[i] !=
+                           get_unaligned_le32(key + i * sizeof(u32))) {
+                               ctx->base.needs_inv = true;
+                               break;
+                       }
+               }
+       }
+
+       for (i = 0; i < CHACHA_KEY_SIZE / sizeof(u32); i++)
+               ctx->key[i] = get_unaligned_le32(key + i * sizeof(u32));
+       ctx->key_len = CHACHA_KEY_SIZE;
+
+       return 0;
+}
+
+static int safexcel_skcipher_chacha20_cra_init(struct crypto_tfm *tfm)
+{
+       struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
+
+       safexcel_skcipher_cra_init(tfm);
+       ctx->alg  = SAFEXCEL_CHACHA20;
+       ctx->mode = CONTEXT_CONTROL_CHACHA20_MODE_256_32;
+       return 0;
+}
+
+struct safexcel_alg_template safexcel_alg_chacha20 = {
+       .type = SAFEXCEL_ALG_TYPE_SKCIPHER,
+       .algo_mask = SAFEXCEL_ALG_CHACHA20,
+       .alg.skcipher = {
+               .setkey = safexcel_skcipher_chacha20_setkey,
+               .encrypt = safexcel_encrypt,
+               .decrypt = safexcel_decrypt,
+               .min_keysize = CHACHA_KEY_SIZE,
+               .max_keysize = CHACHA_KEY_SIZE,
+               .ivsize = CHACHA_IV_SIZE,
+               .base = {
+                       .cra_name = "chacha20",
+                       .cra_driver_name = "safexcel-chacha20",
+                       .cra_priority = SAFEXCEL_CRA_PRIORITY,
+                       .cra_flags = CRYPTO_ALG_ASYNC |
+                                    CRYPTO_ALG_KERN_DRIVER_ONLY,
+                       .cra_blocksize = 1,
+                       .cra_ctxsize = sizeof(struct safexcel_cipher_ctx),
+                       .cra_alignmask = 0,
+                       .cra_init = safexcel_skcipher_chacha20_cra_init,
+                       .cra_exit = safexcel_skcipher_cra_exit,
+                       .cra_module = THIS_MODULE,
+               },
+       },
+};