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