crypto/des_generic.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Cryptographic API.
   4  *
   5  * DES & Triple DES EDE Cipher Algorithms.
   6  *
   7  * Copyright (c) 2005 Dag Arne Osvik <da@osvik.no>
   8  */
   9
  10 #include <asm/byteorder.h>
  11 #include <linux/bitops.h>
  12 #include <linux/init.h>
  13 #include <linux/module.h>
  14 #include <linux/errno.h>
  15 #include <linux/crypto.h>
  16
  17 #include <crypto/internal/des.h>
  18
  19 static int des_setkey(struct crypto_tfm *tfm, const u8 *key,
  20                       unsigned int keylen)
  21 {
  22         struct des_ctx *dctx = crypto_tfm_ctx(tfm);
  23         int err;
  24
  25         err = des_expand_key(dctx, key, keylen);
  26         if (err == -ENOKEY) {
  27                 if (crypto_tfm_get_flags(tfm) & CRYPTO_TFM_REQ_FORBID_WEAK_KEYS)
  28                         err = -EINVAL;
  29                 else
  30                         err = 0;
  31         }
  32
  33         if (err) {
  34                 memset(dctx, 0, sizeof(*dctx));
  35                 crypto_tfm_set_flags(tfm, CRYPTO_TFM_RES_WEAK_KEY);
  36         }
  37         return err;
  38 }
  39
  40 static void crypto_des_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
  41 {
  42         const struct des_ctx *dctx = crypto_tfm_ctx(tfm);
  43
  44         des_encrypt(dctx, dst, src);
  45 }
  46
  47 static void crypto_des_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
  48 {
  49         const struct des_ctx *dctx = crypto_tfm_ctx(tfm);
  50
  51         des_decrypt(dctx, dst, src);
  52 }
  53
  54 int __des3_ede_setkey(u32 *expkey, u32 *flags, const u8 *key,
  55                       unsigned int keylen)
  56 {
  57         int err;
  58
  59         des_ekey(expkey, key); expkey += DES_EXPKEY_WORDS; key += DES_KEY_SIZE;
  60         dkey(expkey, key); expkey += DES_EXPKEY_WORDS; key += DES_KEY_SIZE;
  61         des_ekey(expkey, key);
  62
  63         return 0;
  64 }
  65 EXPORT_SYMBOL_GPL(__des3_ede_setkey);
  66
  67 static int des3_ede_setkey(struct crypto_tfm *tfm, const u8 *key,
  68                            unsigned int keylen)
  69 {
  70         struct des3_ede_ctx *dctx = crypto_tfm_ctx(tfm);
  71         int err;
  72
  73         err = des3_ede_expand_key(dctx, key, keylen);
  74         if (err == -ENOKEY) {
  75                 if (crypto_tfm_get_flags(tfm) & CRYPTO_TFM_REQ_FORBID_WEAK_KEYS)
  76                         err = -EINVAL;
  77                 else
  78                         err = 0;
  79         }
  80
  81         if (err) {
  82                 memset(dctx, 0, sizeof(*dctx));
  83                 crypto_tfm_set_flags(tfm, CRYPTO_TFM_RES_WEAK_KEY);
  84         }
  85         return err;
  86 }
  87
  88 static void crypto_des3_ede_encrypt(struct crypto_tfm *tfm, u8 *dst,
  89                                     const u8 *src)
  90 {
  91         const struct des3_ede_ctx *dctx = crypto_tfm_ctx(tfm);
  92
  93         des3_ede_encrypt(dctx, dst, src);
  94 }
  95
  96 static void crypto_des3_ede_decrypt(struct crypto_tfm *tfm, u8 *dst,
  97                                     const u8 *src)
  98 {
  99         const struct des3_ede_ctx *dctx = crypto_tfm_ctx(tfm);
 100
 101         des3_ede_decrypt(dctx, dst, src);
 102 }
 103
 104 static struct crypto_alg des_algs[2] = { {
 105         .cra_name               =       "des",
 106         .cra_driver_name        =       "des-generic",
 107         .cra_priority           =       100,
 108         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
 109         .cra_blocksize          =       DES_BLOCK_SIZE,
 110         .cra_ctxsize            =       sizeof(struct des_ctx),
 111         .cra_module             =       THIS_MODULE,
 112         .cra_u                  =       { .cipher = {
 113         .cia_min_keysize        =       DES_KEY_SIZE,
 114         .cia_max_keysize        =       DES_KEY_SIZE,
 115         .cia_setkey             =       des_setkey,
 116         .cia_encrypt            =       crypto_des_encrypt,
 117         .cia_decrypt            =       crypto_des_decrypt } }
 118 }, {
 119         .cra_name               =       "des3_ede",
 120         .cra_driver_name        =       "des3_ede-generic",
 121         .cra_priority           =       100,
 122         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
 123         .cra_blocksize          =       DES3_EDE_BLOCK_SIZE,
 124         .cra_ctxsize            =       sizeof(struct des3_ede_ctx),
 125         .cra_module             =       THIS_MODULE,
 126         .cra_u                  =       { .cipher = {
 127         .cia_min_keysize        =       DES3_EDE_KEY_SIZE,
 128         .cia_max_keysize        =       DES3_EDE_KEY_SIZE,
 129         .cia_setkey             =       des3_ede_setkey,
 130         .cia_encrypt            =       crypto_des3_ede_encrypt,
 131         .cia_decrypt            =       crypto_des3_ede_decrypt } }
 132 } };
 133
 134 static int __init des_generic_mod_init(void)
 135 {
 136         return crypto_register_algs(des_algs, ARRAY_SIZE(des_algs));
 137 }
 138
 139 static void __exit des_generic_mod_fini(void)
 140 {
 141         crypto_unregister_algs(des_algs, ARRAY_SIZE(des_algs));
 142 }
 143
 144 subsys_initcall(des_generic_mod_init);
 145 module_exit(des_generic_mod_fini);
 146
 147 MODULE_LICENSE("GPL");
 148 MODULE_DESCRIPTION("DES & Triple DES EDE Cipher Algorithms");
 149 MODULE_AUTHOR("Dag Arne Osvik <da@osvik.no>");
 150 MODULE_ALIAS_CRYPTO("des");
 151 MODULE_ALIAS_CRYPTO("des-generic");
 152 MODULE_ALIAS_CRYPTO("des3_ede");
 153 MODULE_ALIAS_CRYPTO("des3_ede-generic");