1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * CBC: Cipher Block Chaining mode 4 * 5 * Copyright (c) 2006-2016 Herbert Xu <herbert@gondor.apana.org.au> 6 */ 7 8 #include <crypto/internal/skcipher.h> 9 #include <linux/err.h> 10 #include <linux/init.h> 11 #include <linux/kernel.h> 12 #include <linux/log2.h> 13 #include <linux/module.h> 14 15 static int crypto_cbc_encrypt_segment(struct crypto_lskcipher *tfm, 16 const u8 *src, u8 *dst, unsigned nbytes, 17 u8 *iv) 18 { 19 unsigned int bsize = crypto_lskcipher_blocksize(tfm); 20 21 for (; nbytes >= bsize; src += bsize, dst += bsize, nbytes -= bsize) { 22 crypto_xor(iv, src, bsize); 23 crypto_lskcipher_encrypt(tfm, iv, dst, bsize, NULL); 24 memcpy(iv, dst, bsize); 25 } 26 27 return nbytes; 28 } 29 30 static int crypto_cbc_encrypt_inplace(struct crypto_lskcipher *tfm, 31 u8 *src, unsigned nbytes, u8 *oiv) 32 { 33 unsigned int bsize = crypto_lskcipher_blocksize(tfm); 34 u8 *iv = oiv; 35 36 if (nbytes < bsize) 37 goto out; 38 39 do { 40 crypto_xor(src, iv, bsize); 41 crypto_lskcipher_encrypt(tfm, src, src, bsize, NULL); 42 iv = src; 43 44 src += bsize; 45 } while ((nbytes -= bsize) >= bsize); 46 47 memcpy(oiv, iv, bsize); 48 49 out: 50 return nbytes; 51 } 52 53 static int crypto_cbc_encrypt(struct crypto_lskcipher *tfm, const u8 *src, 54 u8 *dst, unsigned len, u8 *iv, bool final) 55 { 56 struct crypto_lskcipher **ctx = crypto_lskcipher_ctx(tfm); 57 struct crypto_lskcipher *cipher = *ctx; 58 int rem; 59 60 if (src == dst) 61 rem = crypto_cbc_encrypt_inplace(cipher, dst, len, iv); 62 else 63 rem = crypto_cbc_encrypt_segment(cipher, src, dst, len, iv); 64 65 return rem && final ? -EINVAL : rem; 66 } 67 68 static int crypto_cbc_decrypt_segment(struct crypto_lskcipher *tfm, 69 const u8 *src, u8 *dst, unsigned nbytes, 70 u8 *oiv) 71 { 72 unsigned int bsize = crypto_lskcipher_blocksize(tfm); 73 const u8 *iv = oiv; 74 75 if (nbytes < bsize) 76 goto out; 77 78 do { 79 crypto_lskcipher_decrypt(tfm, src, dst, bsize, NULL); 80 crypto_xor(dst, iv, bsize); 81 iv = src; 82 83 src += bsize; 84 dst += bsize; 85 } while ((nbytes -= bsize) >= bsize); 86 87 memcpy(oiv, iv, bsize); 88 89 out: 90 return nbytes; 91 } 92 93 static int crypto_cbc_decrypt_inplace(struct crypto_lskcipher *tfm, 94 u8 *src, unsigned nbytes, u8 *iv) 95 { 96 unsigned int bsize = crypto_lskcipher_blocksize(tfm); 97 u8 last_iv[MAX_CIPHER_BLOCKSIZE]; 98 99 if (nbytes < bsize) 100 goto out; 101 102 /* Start of the last block. */ 103 src += nbytes - (nbytes & (bsize - 1)) - bsize; 104 memcpy(last_iv, src, bsize); 105 106 for (;;) { 107 crypto_lskcipher_decrypt(tfm, src, src, bsize, NULL); 108 if ((nbytes -= bsize) < bsize) 109 break; 110 crypto_xor(src, src - bsize, bsize); 111 src -= bsize; 112 } 113 114 crypto_xor(src, iv, bsize); 115 memcpy(iv, last_iv, bsize); 116 117 out: 118 return nbytes; 119 } 120 121 static int crypto_cbc_decrypt(struct crypto_lskcipher *tfm, const u8 *src, 122 u8 *dst, unsigned len, u8 *iv, bool final) 123 { 124 struct crypto_lskcipher **ctx = crypto_lskcipher_ctx(tfm); 125 struct crypto_lskcipher *cipher = *ctx; 126 int rem; 127 128 if (src == dst) 129 rem = crypto_cbc_decrypt_inplace(cipher, dst, len, iv); 130 else 131 rem = crypto_cbc_decrypt_segment(cipher, src, dst, len, iv); 132 133 return rem && final ? -EINVAL : rem; 134 } 135 136 static int crypto_cbc_create(struct crypto_template *tmpl, struct rtattr **tb) 137 { 138 struct lskcipher_instance *inst; 139 int err; 140 141 inst = lskcipher_alloc_instance_simple(tmpl, tb); 142 if (IS_ERR(inst)) 143 return PTR_ERR(inst); 144 145 err = -EINVAL; 146 if (!is_power_of_2(inst->alg.co.base.cra_blocksize)) 147 goto out_free_inst; 148 149 inst->alg.encrypt = crypto_cbc_encrypt; 150 inst->alg.decrypt = crypto_cbc_decrypt; 151 152 err = lskcipher_register_instance(tmpl, inst); 153 if (err) { 154 out_free_inst: 155 inst->free(inst); 156 } 157 158 return err; 159 } 160 161 static struct crypto_template crypto_cbc_tmpl = { 162 .name = "cbc", 163 .create = crypto_cbc_create, 164 .module = THIS_MODULE, 165 }; 166 167 static int __init crypto_cbc_module_init(void) 168 { 169 return crypto_register_template(&crypto_cbc_tmpl); 170 } 171 172 static void __exit crypto_cbc_module_exit(void) 173 { 174 crypto_unregister_template(&crypto_cbc_tmpl); 175 } 176 177 subsys_initcall(crypto_cbc_module_init); 178 module_exit(crypto_cbc_module_exit); 179 180 MODULE_LICENSE("GPL"); 181 MODULE_DESCRIPTION("CBC block cipher mode of operation"); 182 MODULE_ALIAS_CRYPTO("cbc"); 183