LXR linux/crypto/des

   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
  19static 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        if (err)
  33                memset(dctx, 0, sizeof(*dctx));
  34        return err;
  35}
  36
  37static void crypto_des_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
  38{
  39        const struct des_ctx *dctx = crypto_tfm_ctx(tfm);
  40
  41        des_encrypt(dctx, dst, src);
  42}
  43
  44static void crypto_des_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
  45{
  46        const struct des_ctx *dctx = crypto_tfm_ctx(tfm);
  47
  48        des_decrypt(dctx, dst, src);
  49}
  50
  51static int des3_ede_setkey(struct crypto_tfm *tfm, const u8 *key,
  52                           unsigned int keylen)
  53{
  54        struct des3_ede_ctx *dctx = crypto_tfm_ctx(tfm);
  55        int err;
  56
  57        err = des3_ede_expand_key(dctx, key, keylen);
  58        if (err == -ENOKEY) {
  59                if (crypto_tfm_get_flags(tfm) & CRYPTO_TFM_REQ_FORBID_WEAK_KEYS)
  60                        err = -EINVAL;
  61                else
  62                        err = 0;
  63        }
  64        if (err)
  65                memset(dctx, 0, sizeof(*dctx));
  66        return err;
  67}
  68
  69static void crypto_des3_ede_encrypt(struct crypto_tfm *tfm, u8 *dst,
  70                                    const u8 *src)
  71{
  72        const struct des3_ede_ctx *dctx = crypto_tfm_ctx(tfm);
  73
  74        des3_ede_encrypt(dctx, dst, src);
  75}
  76
  77static void crypto_des3_ede_decrypt(struct crypto_tfm *tfm, u8 *dst,
  78                                    const u8 *src)
  79{
  80        const struct des3_ede_ctx *dctx = crypto_tfm_ctx(tfm);
  81
  82        des3_ede_decrypt(dctx, dst, src);
  83}
  84
  85static struct crypto_alg des_algs[2] = { {
  86        .cra_name               =       "des",
  87        .cra_driver_name        =       "des-generic",
  88        .cra_priority           =       100,
  89        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
  90        .cra_blocksize          =       DES_BLOCK_SIZE,
  91        .cra_ctxsize            =       sizeof(struct des_ctx),
  92        .cra_module             =       THIS_MODULE,
  93        .cra_u                  =       { .cipher = {
  94        .cia_min_keysize        =       DES_KEY_SIZE,
  95        .cia_max_keysize        =       DES_KEY_SIZE,
  96        .cia_setkey             =       des_setkey,
  97        .cia_encrypt            =       crypto_des_encrypt,
  98        .cia_decrypt            =       crypto_des_decrypt } }
  99}, {
 100        .cra_name               =       "des3_ede",
 101        .cra_driver_name        =       "des3_ede-generic",
 102        .cra_priority           =       100,
 103        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
 104        .cra_blocksize          =       DES3_EDE_BLOCK_SIZE,
 105        .cra_ctxsize            =       sizeof(struct des3_ede_ctx),
 106        .cra_module             =       THIS_MODULE,
 107        .cra_u                  =       { .cipher = {
 108        .cia_min_keysize        =       DES3_EDE_KEY_SIZE,
 109        .cia_max_keysize        =       DES3_EDE_KEY_SIZE,
 110        .cia_setkey             =       des3_ede_setkey,
 111        .cia_encrypt            =       crypto_des3_ede_encrypt,
 112        .cia_decrypt            =       crypto_des3_ede_decrypt } }
 113} };
 114
 115static int __init des_generic_mod_init(void)
 116{
 117        return crypto_register_algs(des_algs, ARRAY_SIZE(des_algs));
 118}
 119
 120static void __exit des_generic_mod_fini(void)
 121{
 122        crypto_unregister_algs(des_algs, ARRAY_SIZE(des_algs));
 123}
 124
 125subsys_initcall(des_generic_mod_init);
 126module_exit(des_generic_mod_fini);
 127
 128MODULE_LICENSE("GPL");
 129MODULE_DESCRIPTION("DES & Triple DES EDE Cipher Algorithms");
 130MODULE_AUTHOR("Dag Arne Osvik <da@osvik.no>");
 131MODULE_ALIAS_CRYPTO("des");
 132MODULE_ALIAS_CRYPTO("des-generic");
 133MODULE_ALIAS_CRYPTO("des3_ede");
 134MODULE_ALIAS_CRYPTO("des3_ede-generic");
 135