arch/x86/crypto/blowfish_glue.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Glue Code for assembler optimized version of Blowfish
   4  *
   5  * Copyright (c) 2011 Jussi Kivilinna <[email protected]>
   6  *
   7  * CBC & ECB parts based on code (crypto/cbc.c,ecb.c) by:
   8  *   Copyright (c) 2006 Herbert Xu <[email protected]>
   9  */
  10
  11 #include <crypto/algapi.h>
  12 #include <crypto/blowfish.h>
  13 #include <crypto/internal/skcipher.h>
  14 #include <linux/crypto.h>
  15 #include <linux/init.h>
  16 #include <linux/module.h>
  17 #include <linux/types.h>
  18
  19 #include "ecb_cbc_helpers.h"
  20
  21 /* regular block cipher functions */
  22 asmlinkage void blowfish_enc_blk(struct bf_ctx *ctx, u8 *dst, const u8 *src);
  23 asmlinkage void blowfish_dec_blk(struct bf_ctx *ctx, u8 *dst, const u8 *src);
  24
  25 /* 4-way parallel cipher functions */
  26 asmlinkage void blowfish_enc_blk_4way(struct bf_ctx *ctx, u8 *dst,
  27                                       const u8 *src);
  28 asmlinkage void __blowfish_dec_blk_4way(struct bf_ctx *ctx, u8 *dst,
  29                                         const u8 *src, bool cbc);
  30
  31 static inline void blowfish_dec_ecb_4way(struct bf_ctx *ctx, u8 *dst,
  32                                              const u8 *src)
  33 {
  34         return __blowfish_dec_blk_4way(ctx, dst, src, false);
  35 }
  36
  37 static inline void blowfish_dec_cbc_4way(struct bf_ctx *ctx, u8 *dst,
  38                                              const u8 *src)
  39 {
  40         return __blowfish_dec_blk_4way(ctx, dst, src, true);
  41 }
  42
  43 static void blowfish_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
  44 {
  45         blowfish_enc_blk(crypto_tfm_ctx(tfm), dst, src);
  46 }
  47
  48 static void blowfish_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
  49 {
  50         blowfish_dec_blk(crypto_tfm_ctx(tfm), dst, src);
  51 }
  52
  53 static int blowfish_setkey_skcipher(struct crypto_skcipher *tfm,
  54                                     const u8 *key, unsigned int keylen)
  55 {
  56         return blowfish_setkey(&tfm->base, key, keylen);
  57 }
  58
  59 static int ecb_encrypt(struct skcipher_request *req)
  60 {
  61         ECB_WALK_START(req, BF_BLOCK_SIZE, -1);
  62         ECB_BLOCK(4, blowfish_enc_blk_4way);
  63         ECB_BLOCK(1, blowfish_enc_blk);
  64         ECB_WALK_END();
  65 }
  66
  67 static int ecb_decrypt(struct skcipher_request *req)
  68 {
  69         ECB_WALK_START(req, BF_BLOCK_SIZE, -1);
  70         ECB_BLOCK(4, blowfish_dec_ecb_4way);
  71         ECB_BLOCK(1, blowfish_dec_blk);
  72         ECB_WALK_END();
  73 }
  74
  75 static int cbc_encrypt(struct skcipher_request *req)
  76 {
  77         CBC_WALK_START(req, BF_BLOCK_SIZE, -1);
  78         CBC_ENC_BLOCK(blowfish_enc_blk);
  79         CBC_WALK_END();
  80 }
  81
  82 static int cbc_decrypt(struct skcipher_request *req)
  83 {
  84         CBC_WALK_START(req, BF_BLOCK_SIZE, -1);
  85         CBC_DEC_BLOCK(4, blowfish_dec_cbc_4way);
  86         CBC_DEC_BLOCK(1, blowfish_dec_blk);
  87         CBC_WALK_END();
  88 }
  89
  90 static struct crypto_alg bf_cipher_alg = {
  91         .cra_name               = "blowfish",
  92         .cra_driver_name        = "blowfish-asm",
  93         .cra_priority           = 200,
  94         .cra_flags              = CRYPTO_ALG_TYPE_CIPHER,
  95         .cra_blocksize          = BF_BLOCK_SIZE,
  96         .cra_ctxsize            = sizeof(struct bf_ctx),
  97         .cra_alignmask          = 0,
  98         .cra_module             = THIS_MODULE,
  99         .cra_u = {
 100                 .cipher = {
 101                         .cia_min_keysize        = BF_MIN_KEY_SIZE,
 102                         .cia_max_keysize        = BF_MAX_KEY_SIZE,
 103                         .cia_setkey             = blowfish_setkey,
 104                         .cia_encrypt            = blowfish_encrypt,
 105                         .cia_decrypt            = blowfish_decrypt,
 106                 }
 107         }
 108 };
 109
 110 static struct skcipher_alg bf_skcipher_algs[] = {
 111         {
 112                 .base.cra_name          = "ecb(blowfish)",
 113                 .base.cra_driver_name   = "ecb-blowfish-asm",
 114                 .base.cra_priority      = 300,
 115                 .base.cra_blocksize     = BF_BLOCK_SIZE,
 116                 .base.cra_ctxsize       = sizeof(struct bf_ctx),
 117                 .base.cra_module        = THIS_MODULE,
 118                 .min_keysize            = BF_MIN_KEY_SIZE,
 119                 .max_keysize            = BF_MAX_KEY_SIZE,
 120                 .setkey                 = blowfish_setkey_skcipher,
 121                 .encrypt                = ecb_encrypt,
 122                 .decrypt                = ecb_decrypt,
 123         }, {
 124                 .base.cra_name          = "cbc(blowfish)",
 125                 .base.cra_driver_name   = "cbc-blowfish-asm",
 126                 .base.cra_priority      = 300,
 127                 .base.cra_blocksize     = BF_BLOCK_SIZE,
 128                 .base.cra_ctxsize       = sizeof(struct bf_ctx),
 129                 .base.cra_module        = THIS_MODULE,
 130                 .min_keysize            = BF_MIN_KEY_SIZE,
 131                 .max_keysize            = BF_MAX_KEY_SIZE,
 132                 .ivsize                 = BF_BLOCK_SIZE,
 133                 .setkey                 = blowfish_setkey_skcipher,
 134                 .encrypt                = cbc_encrypt,
 135                 .decrypt                = cbc_decrypt,
 136         },
 137 };
 138
 139 static bool is_blacklisted_cpu(void)
 140 {
 141         if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL)
 142                 return false;
 143
 144         if (boot_cpu_data.x86 == 0x0f) {
 145                 /*
 146                  * On Pentium 4, blowfish-x86_64 is slower than generic C
 147                  * implementation because use of 64bit rotates (which are really
 148                  * slow on P4). Therefore blacklist P4s.
 149                  */
 150                 return true;
 151         }
 152
 153         return false;
 154 }
 155
 156 static int force;
 157 module_param(force, int, 0);
 158 MODULE_PARM_DESC(force, "Force module load, ignore CPU blacklist");
 159
 160 static int __init blowfish_init(void)
 161 {
 162         int err;
 163
 164         if (!force && is_blacklisted_cpu()) {
 165                 printk(KERN_INFO
 166                         "blowfish-x86_64: performance on this CPU "
 167                         "would be suboptimal: disabling "
 168                         "blowfish-x86_64.\n");
 169                 return -ENODEV;
 170         }
 171
 172         err = crypto_register_alg(&bf_cipher_alg);
 173         if (err)
 174                 return err;
 175
 176         err = crypto_register_skciphers(bf_skcipher_algs,
 177                                         ARRAY_SIZE(bf_skcipher_algs));
 178         if (err)
 179                 crypto_unregister_alg(&bf_cipher_alg);
 180
 181         return err;
 182 }
 183
 184 static void __exit blowfish_fini(void)
 185 {
 186         crypto_unregister_alg(&bf_cipher_alg);
 187         crypto_unregister_skciphers(bf_skcipher_algs,
 188                                     ARRAY_SIZE(bf_skcipher_algs));
 189 }
 190
 191 module_init(blowfish_init);
 192 module_exit(blowfish_fini);
 193
 194 MODULE_LICENSE("GPL");
 195 MODULE_DESCRIPTION("Blowfish Cipher Algorithm, asm optimized");
 196 MODULE_ALIAS_CRYPTO("blowfish");
 197 MODULE_ALIAS_CRYPTO("blowfish-asm");