blob: 40cae908788ecaeaa73e9df3eb7aebc91edf3f1c [file] [log] [blame]
Thomas Gleixner2874c5f2019-05-27 08:55:01 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
3 * Cryptographic API.
4 *
Eric Biggerse8cfed52019-12-02 13:42:30 -08005 * Single-block cipher operations.
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
7 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
Herbert Xuc774e932005-07-06 13:51:31 -07008 * Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 */
Herbert Xuf1ddcaf2007-01-27 10:05:15 +110010
Salvatore Mesoraca6650c4d2018-04-09 15:54:47 +020011#include <crypto/algapi.h>
Ard Biesheuvel0eb76ba2020-12-11 13:27:15 +010012#include <crypto/internal/cipher.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/kernel.h>
14#include <linux/crypto.h>
15#include <linux/errno.h>
Herbert Xu791b4d52007-08-23 16:23:01 +080016#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070019
Eric Biggerse8cfed52019-12-02 13:42:30 -080020static int setkey_unaligned(struct crypto_cipher *tfm, const u8 *key,
Herbert Xu791b4d52007-08-23 16:23:01 +080021 unsigned int keylen)
Sebastian Siewiorca7c3932007-05-19 19:51:21 +100022{
Eric Biggerse8cfed52019-12-02 13:42:30 -080023 struct cipher_alg *cia = crypto_cipher_alg(tfm);
24 unsigned long alignmask = crypto_cipher_alignmask(tfm);
Sebastian Siewiorca7c3932007-05-19 19:51:21 +100025 int ret;
26 u8 *buffer, *alignbuffer;
27 unsigned long absize;
28
29 absize = keylen + alignmask;
30 buffer = kmalloc(absize, GFP_ATOMIC);
31 if (!buffer)
32 return -ENOMEM;
33
34 alignbuffer = (u8 *)ALIGN((unsigned long)buffer, alignmask + 1);
35 memcpy(alignbuffer, key, keylen);
Eric Biggerse8cfed52019-12-02 13:42:30 -080036 ret = cia->cia_setkey(crypto_cipher_tfm(tfm), alignbuffer, keylen);
Hailey Mothershead23e40992024-04-15 22:19:15 +000037 kfree_sensitive(buffer);
Sebastian Siewiorca7c3932007-05-19 19:51:21 +100038 return ret;
39
40}
41
Eric Biggerse8cfed52019-12-02 13:42:30 -080042int crypto_cipher_setkey(struct crypto_cipher *tfm,
43 const u8 *key, unsigned int keylen)
Linus Torvalds1da177e2005-04-16 15:20:36 -070044{
Eric Biggerse8cfed52019-12-02 13:42:30 -080045 struct cipher_alg *cia = crypto_cipher_alg(tfm);
46 unsigned long alignmask = crypto_cipher_alignmask(tfm);
Sebastian Siewiorca7c3932007-05-19 19:51:21 +100047
Eric Biggers674f3682019-12-30 21:19:36 -060048 if (keylen < cia->cia_min_keysize || keylen > cia->cia_max_keysize)
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 return -EINVAL;
Sebastian Siewiorca7c3932007-05-19 19:51:21 +100050
51 if ((unsigned long)key & alignmask)
52 return setkey_unaligned(tfm, key, keylen);
53
Eric Biggerse8cfed52019-12-02 13:42:30 -080054 return cia->cia_setkey(crypto_cipher_tfm(tfm), key, keylen);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055}
Ard Biesheuvel0eb76ba2020-12-11 13:27:15 +010056EXPORT_SYMBOL_NS_GPL(crypto_cipher_setkey, CRYPTO_INTERNAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057
Eric Biggerse8cfed52019-12-02 13:42:30 -080058static inline void cipher_crypt_one(struct crypto_cipher *tfm,
59 u8 *dst, const u8 *src, bool enc)
Herbert Xuf28776a2006-08-13 20:58:18 +100060{
Eric Biggerse8cfed52019-12-02 13:42:30 -080061 unsigned long alignmask = crypto_cipher_alignmask(tfm);
62 struct cipher_alg *cia = crypto_cipher_alg(tfm);
63 void (*fn)(struct crypto_tfm *, u8 *, const u8 *) =
64 enc ? cia->cia_encrypt : cia->cia_decrypt;
Herbert Xuf28776a2006-08-13 20:58:18 +100065
66 if (unlikely(((unsigned long)dst | (unsigned long)src) & alignmask)) {
Eric Biggerse8cfed52019-12-02 13:42:30 -080067 unsigned int bs = crypto_cipher_blocksize(tfm);
68 u8 buffer[MAX_CIPHER_BLOCKSIZE + MAX_CIPHER_ALIGNMASK];
69 u8 *tmp = (u8 *)ALIGN((unsigned long)buffer, alignmask + 1);
70
71 memcpy(tmp, src, bs);
72 fn(crypto_cipher_tfm(tfm), tmp, tmp);
73 memcpy(dst, tmp, bs);
74 } else {
75 fn(crypto_cipher_tfm(tfm), dst, src);
Herbert Xuf28776a2006-08-13 20:58:18 +100076 }
Herbert Xuf28776a2006-08-13 20:58:18 +100077}
78
Eric Biggerse8cfed52019-12-02 13:42:30 -080079void crypto_cipher_encrypt_one(struct crypto_cipher *tfm,
80 u8 *dst, const u8 *src)
Herbert Xuf28776a2006-08-13 20:58:18 +100081{
Eric Biggerse8cfed52019-12-02 13:42:30 -080082 cipher_crypt_one(tfm, dst, src, true);
Herbert Xuf28776a2006-08-13 20:58:18 +100083}
Ard Biesheuvel0eb76ba2020-12-11 13:27:15 +010084EXPORT_SYMBOL_NS_GPL(crypto_cipher_encrypt_one, CRYPTO_INTERNAL);
Herbert Xuf28776a2006-08-13 20:58:18 +100085
Eric Biggerse8cfed52019-12-02 13:42:30 -080086void crypto_cipher_decrypt_one(struct crypto_cipher *tfm,
87 u8 *dst, const u8 *src)
Linus Torvalds1da177e2005-04-16 15:20:36 -070088{
Eric Biggerse8cfed52019-12-02 13:42:30 -080089 cipher_crypt_one(tfm, dst, src, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090}
Ard Biesheuvel0eb76ba2020-12-11 13:27:15 +010091EXPORT_SYMBOL_NS_GPL(crypto_cipher_decrypt_one, CRYPTO_INTERNAL);
Herbert Xu51d8d6d2023-05-19 16:28:35 +080092
93struct crypto_cipher *crypto_clone_cipher(struct crypto_cipher *cipher)
94{
95 struct crypto_tfm *tfm = crypto_cipher_tfm(cipher);
96 struct crypto_alg *alg = tfm->__crt_alg;
97 struct crypto_cipher *ncipher;
98 struct crypto_tfm *ntfm;
99
100 if (alg->cra_init)
101 return ERR_PTR(-ENOSYS);
102
Dmitry Safonov9979c6e2023-06-14 18:46:43 +0100103 if (unlikely(!crypto_mod_get(alg)))
104 return ERR_PTR(-ESTALE);
105
Herbert Xufa3b3562023-06-15 17:00:51 +0800106 ntfm = __crypto_alloc_tfmgfp(alg, CRYPTO_ALG_TYPE_CIPHER,
107 CRYPTO_ALG_TYPE_MASK, GFP_ATOMIC);
Dmitry Safonov9979c6e2023-06-14 18:46:43 +0100108 if (IS_ERR(ntfm)) {
109 crypto_mod_put(alg);
Herbert Xu51d8d6d2023-05-19 16:28:35 +0800110 return ERR_CAST(ntfm);
Dmitry Safonov9979c6e2023-06-14 18:46:43 +0100111 }
Herbert Xu51d8d6d2023-05-19 16:28:35 +0800112
113 ntfm->crt_flags = tfm->crt_flags;
114
115 ncipher = __crypto_cipher_cast(ntfm);
116
117 return ncipher;
118}
119EXPORT_SYMBOL_GPL(crypto_clone_cipher);