arch/sparc/crypto/camellia_glue.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Glue code for CAMELLIA encryption optimized for sparc64 crypto opcodes.
   3  *
   4  * Copyright (C) 2012 David S. Miller <davem@davemloft.net>
   5  */
   6
   7 #define pr_fmt(fmt)     KBUILD_MODNAME ": " fmt
   8
   9 #include <linux/crypto.h>
  10 #include <linux/init.h>
  11 #include <linux/module.h>
  12 #include <linux/mm.h>
  13 #include <linux/types.h>
  14 #include <crypto/algapi.h>
  15 #include <crypto/internal/skcipher.h>
  16
  17 #include <asm/fpumacro.h>
  18 #include <asm/pstate.h>
  19 #include <asm/elf.h>
  20
  21 #include "opcodes.h"
  22
  23 #define CAMELLIA_MIN_KEY_SIZE        16
  24 #define CAMELLIA_MAX_KEY_SIZE        32
  25 #define CAMELLIA_BLOCK_SIZE          16
  26 #define CAMELLIA_TABLE_BYTE_LEN     272
  27
  28 struct camellia_sparc64_ctx {
  29         u64 encrypt_key[CAMELLIA_TABLE_BYTE_LEN / sizeof(u64)];
  30         u64 decrypt_key[CAMELLIA_TABLE_BYTE_LEN / sizeof(u64)];
  31         int key_len;
  32 };
  33
  34 extern void camellia_sparc64_key_expand(const u32 *in_key, u64 *encrypt_key,
  35                                         unsigned int key_len, u64 *decrypt_key);
  36
  37 static int camellia_set_key(struct crypto_tfm *tfm, const u8 *_in_key,
  38                             unsigned int key_len)
  39 {
  40         struct camellia_sparc64_ctx *ctx = crypto_tfm_ctx(tfm);
  41         const u32 *in_key = (const u32 *) _in_key;
  42         u32 *flags = &tfm->crt_flags;
  43
  44         if (key_len != 16 && key_len != 24 && key_len != 32) {
  45                 *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
  46                 return -EINVAL;
  47         }
  48
  49         ctx->key_len = key_len;
  50
  51         camellia_sparc64_key_expand(in_key, &ctx->encrypt_key[0],
  52                                     key_len, &ctx->decrypt_key[0]);
  53         return 0;
  54 }
  55
  56 static int camellia_set_key_skcipher(struct crypto_skcipher *tfm,
  57                                      const u8 *in_key, unsigned int key_len)
  58 {
  59         return camellia_set_key(crypto_skcipher_tfm(tfm), in_key, key_len);
  60 }
  61
  62 extern void camellia_sparc64_crypt(const u64 *key, const u32 *input,
  63                                    u32 *output, unsigned int key_len);
  64
  65 static void camellia_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
  66 {
  67         struct camellia_sparc64_ctx *ctx = crypto_tfm_ctx(tfm);
  68
  69         camellia_sparc64_crypt(&ctx->encrypt_key[0],
  70                                (const u32 *) src,
  71                                (u32 *) dst, ctx->key_len);
  72 }
  73
  74 static void camellia_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
  75 {
  76         struct camellia_sparc64_ctx *ctx = crypto_tfm_ctx(tfm);
  77
  78         camellia_sparc64_crypt(&ctx->decrypt_key[0],
  79                                (const u32 *) src,
  80                                (u32 *) dst, ctx->key_len);
  81 }
  82
  83 extern void camellia_sparc64_load_keys(const u64 *key, unsigned int key_len);
  84
  85 typedef void ecb_crypt_op(const u64 *input, u64 *output, unsigned int len,
  86                           const u64 *key);
  87
  88 extern ecb_crypt_op camellia_sparc64_ecb_crypt_3_grand_rounds;
  89 extern ecb_crypt_op camellia_sparc64_ecb_crypt_4_grand_rounds;
  90
  91 static int __ecb_crypt(struct skcipher_request *req, bool encrypt)
  92 {
  93         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  94         const struct camellia_sparc64_ctx *ctx = crypto_skcipher_ctx(tfm);
  95         struct skcipher_walk walk;
  96         ecb_crypt_op *op;
  97         const u64 *key;
  98         unsigned int nbytes;
  99         int err;
 100
 101         op = camellia_sparc64_ecb_crypt_3_grand_rounds;
 102         if (ctx->key_len != 16)
 103                 op = camellia_sparc64_ecb_crypt_4_grand_rounds;
 104
 105         err = skcipher_walk_virt(&walk, req, true);
 106         if (err)
 107                 return err;
 108
 109         if (encrypt)
 110                 key = &ctx->encrypt_key[0];
 111         else
 112                 key = &ctx->decrypt_key[0];
 113         camellia_sparc64_load_keys(key, ctx->key_len);
 114         while ((nbytes = walk.nbytes) != 0) {
 115                 op(walk.src.virt.addr, walk.dst.virt.addr,
 116                    round_down(nbytes, CAMELLIA_BLOCK_SIZE), key);
 117                 err = skcipher_walk_done(&walk, nbytes % CAMELLIA_BLOCK_SIZE);
 118         }
 119         fprs_write(0);
 120         return err;
 121 }
 122
 123 static int ecb_encrypt(struct skcipher_request *req)
 124 {
 125         return __ecb_crypt(req, true);
 126 }
 127
 128 static int ecb_decrypt(struct skcipher_request *req)
 129 {
 130         return __ecb_crypt(req, false);
 131 }
 132
 133 typedef void cbc_crypt_op(const u64 *input, u64 *output, unsigned int len,
 134                           const u64 *key, u64 *iv);
 135
 136 extern cbc_crypt_op camellia_sparc64_cbc_encrypt_3_grand_rounds;
 137 extern cbc_crypt_op camellia_sparc64_cbc_encrypt_4_grand_rounds;
 138 extern cbc_crypt_op camellia_sparc64_cbc_decrypt_3_grand_rounds;
 139 extern cbc_crypt_op camellia_sparc64_cbc_decrypt_4_grand_rounds;
 140
 141 static int cbc_encrypt(struct skcipher_request *req)
 142 {
 143         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
 144         const struct camellia_sparc64_ctx *ctx = crypto_skcipher_ctx(tfm);
 145         struct skcipher_walk walk;
 146         cbc_crypt_op *op;
 147         const u64 *key;
 148         unsigned int nbytes;
 149         int err;
 150
 151         op = camellia_sparc64_cbc_encrypt_3_grand_rounds;
 152         if (ctx->key_len != 16)
 153                 op = camellia_sparc64_cbc_encrypt_4_grand_rounds;
 154
 155         err = skcipher_walk_virt(&walk, req, true);
 156         if (err)
 157                 return err;
 158
 159         key = &ctx->encrypt_key[0];
 160         camellia_sparc64_load_keys(key, ctx->key_len);
 161         while ((nbytes = walk.nbytes) != 0) {
 162                 op(walk.src.virt.addr, walk.dst.virt.addr,
 163                    round_down(nbytes, CAMELLIA_BLOCK_SIZE), key, walk.iv);
 164                 err = skcipher_walk_done(&walk, nbytes % CAMELLIA_BLOCK_SIZE);
 165         }
 166         fprs_write(0);
 167         return err;
 168 }
 169
 170 static int cbc_decrypt(struct skcipher_request *req)
 171 {
 172         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
 173         const struct camellia_sparc64_ctx *ctx = crypto_skcipher_ctx(tfm);
 174         struct skcipher_walk walk;
 175         cbc_crypt_op *op;
 176         const u64 *key;
 177         unsigned int nbytes;
 178         int err;
 179
 180         op = camellia_sparc64_cbc_decrypt_3_grand_rounds;
 181         if (ctx->key_len != 16)
 182                 op = camellia_sparc64_cbc_decrypt_4_grand_rounds;
 183
 184         err = skcipher_walk_virt(&walk, req, true);
 185         if (err)
 186                 return err;
 187
 188         key = &ctx->decrypt_key[0];
 189         camellia_sparc64_load_keys(key, ctx->key_len);
 190         while ((nbytes = walk.nbytes) != 0) {
 191                 op(walk.src.virt.addr, walk.dst.virt.addr,
 192                    round_down(nbytes, CAMELLIA_BLOCK_SIZE), key, walk.iv);
 193                 err = skcipher_walk_done(&walk, nbytes % CAMELLIA_BLOCK_SIZE);
 194         }
 195         fprs_write(0);
 196         return err;
 197 }
 198
 199 static struct crypto_alg cipher_alg = {
 200         .cra_name               = "camellia",
 201         .cra_driver_name        = "camellia-sparc64",
 202         .cra_priority           = SPARC_CR_OPCODE_PRIORITY,
 203         .cra_flags              = CRYPTO_ALG_TYPE_CIPHER,
 204         .cra_blocksize          = CAMELLIA_BLOCK_SIZE,
 205         .cra_ctxsize            = sizeof(struct camellia_sparc64_ctx),
 206         .cra_alignmask          = 3,
 207         .cra_module             = THIS_MODULE,
 208         .cra_u  = {
 209                 .cipher = {
 210                         .cia_min_keysize        = CAMELLIA_MIN_KEY_SIZE,
 211                         .cia_max_keysize        = CAMELLIA_MAX_KEY_SIZE,
 212                         .cia_setkey             = camellia_set_key,
 213                         .cia_encrypt            = camellia_encrypt,
 214                         .cia_decrypt            = camellia_decrypt
 215                 }
 216         }
 217 };
 218
 219 static struct skcipher_alg skcipher_algs[] = {
 220         {
 221                 .base.cra_name          = "ecb(camellia)",
 222                 .base.cra_driver_name   = "ecb-camellia-sparc64",
 223                 .base.cra_priority      = SPARC_CR_OPCODE_PRIORITY,
 224                 .base.cra_blocksize     = CAMELLIA_BLOCK_SIZE,
 225                 .base.cra_ctxsize       = sizeof(struct camellia_sparc64_ctx),
 226                 .base.cra_alignmask     = 7,
 227                 .base.cra_module        = THIS_MODULE,
 228                 .min_keysize            = CAMELLIA_MIN_KEY_SIZE,
 229                 .max_keysize            = CAMELLIA_MAX_KEY_SIZE,
 230                 .setkey                 = camellia_set_key_skcipher,
 231                 .encrypt                = ecb_encrypt,
 232                 .decrypt                = ecb_decrypt,
 233         }, {
 234                 .base.cra_name          = "cbc(camellia)",
 235                 .base.cra_driver_name   = "cbc-camellia-sparc64",
 236                 .base.cra_priority      = SPARC_CR_OPCODE_PRIORITY,
 237                 .base.cra_blocksize     = CAMELLIA_BLOCK_SIZE,
 238                 .base.cra_ctxsize       = sizeof(struct camellia_sparc64_ctx),
 239                 .base.cra_alignmask     = 7,
 240                 .base.cra_module        = THIS_MODULE,
 241                 .min_keysize            = CAMELLIA_MIN_KEY_SIZE,
 242                 .max_keysize            = CAMELLIA_MAX_KEY_SIZE,
 243                 .ivsize                 = CAMELLIA_BLOCK_SIZE,
 244                 .setkey                 = camellia_set_key_skcipher,
 245                 .encrypt                = cbc_encrypt,
 246                 .decrypt                = cbc_decrypt,
 247         }
 248 };
 249
 250 static bool __init sparc64_has_camellia_opcode(void)
 251 {
 252         unsigned long cfr;
 253
 254         if (!(sparc64_elf_hwcap & HWCAP_SPARC_CRYPTO))
 255                 return false;
 256
 257         __asm__ __volatile__("rd %%asr26, %0" : "=r" (cfr));
 258         if (!(cfr & CFR_CAMELLIA))
 259                 return false;
 260
 261         return true;
 262 }
 263
 264 static int __init camellia_sparc64_mod_init(void)
 265 {
 266         int err;
 267
 268         if (!sparc64_has_camellia_opcode()) {
 269                 pr_info("sparc64 camellia opcodes not available.\n");
 270                 return -ENODEV;
 271         }
 272         pr_info("Using sparc64 camellia opcodes optimized CAMELLIA implementation\n");
 273         err = crypto_register_alg(&cipher_alg);
 274         if (err)
 275                 return err;
 276         err = crypto_register_skciphers(skcipher_algs,
 277                                         ARRAY_SIZE(skcipher_algs));
 278         if (err)
 279                 crypto_unregister_alg(&cipher_alg);
 280         return err;
 281 }
 282
 283 static void __exit camellia_sparc64_mod_fini(void)
 284 {
 285         crypto_unregister_alg(&cipher_alg);
 286         crypto_unregister_skciphers(skcipher_algs, ARRAY_SIZE(skcipher_algs));
 287 }
 288
 289 module_init(camellia_sparc64_mod_init);
 290 module_exit(camellia_sparc64_mod_fini);
 291
 292 MODULE_LICENSE("GPL");
 293 MODULE_DESCRIPTION("Camellia Cipher Algorithm, sparc64 camellia opcode accelerated");
 294
 295 MODULE_ALIAS_CRYPTO("camellia");
 296
 297 #include "crop_devid.c"