1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * PCBC: Propagating Cipher Block Chaining mode 4 * 5 * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved. 6 * Written by David Howells (dhowells@redhat.com) 7 * 8 * Derived from cbc.c 9 * - Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au> 10 */ 11 12 #include <crypto/algapi.h> 13 #include <crypto/internal/skcipher.h> 14 #include <linux/err.h> 15 #include <linux/init.h> 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 19 static int crypto_pcbc_encrypt_segment(struct skcipher_request *req, 20 struct skcipher_walk *walk, 21 struct crypto_cipher *tfm) 22 { 23 int bsize = crypto_cipher_blocksize(tfm); 24 unsigned int nbytes = walk->nbytes; 25 u8 *src = walk->src.virt.addr; 26 u8 *dst = walk->dst.virt.addr; 27 u8 * const iv = walk->iv; 28 29 do { 30 crypto_xor(iv, src, bsize); 31 crypto_cipher_encrypt_one(tfm, dst, iv); 32 crypto_xor_cpy(iv, dst, src, bsize); 33 34 src += bsize; 35 dst += bsize; 36 } while ((nbytes -= bsize) >= bsize); 37 38 return nbytes; 39 } 40 41 static int crypto_pcbc_encrypt_inplace(struct skcipher_request *req, 42 struct skcipher_walk *walk, 43 struct crypto_cipher *tfm) 44 { 45 int bsize = crypto_cipher_blocksize(tfm); 46 unsigned int nbytes = walk->nbytes; 47 u8 *src = walk->src.virt.addr; 48 u8 * const iv = walk->iv; 49 u8 tmpbuf[MAX_CIPHER_BLOCKSIZE]; 50 51 do { 52 memcpy(tmpbuf, src, bsize); 53 crypto_xor(iv, src, bsize); 54 crypto_cipher_encrypt_one(tfm, src, iv); 55 crypto_xor_cpy(iv, tmpbuf, src, bsize); 56 57 src += bsize; 58 } while ((nbytes -= bsize) >= bsize); 59 60 return nbytes; 61 } 62 63 static int crypto_pcbc_encrypt(struct skcipher_request *req) 64 { 65 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 66 struct crypto_cipher *cipher = skcipher_cipher_simple(tfm); 67 struct skcipher_walk walk; 68 unsigned int nbytes; 69 int err; 70 71 err = skcipher_walk_virt(&walk, req, false); 72 73 while ((nbytes = walk.nbytes)) { 74 if (walk.src.virt.addr == walk.dst.virt.addr) 75 nbytes = crypto_pcbc_encrypt_inplace(req, &walk, 76 cipher); 77 else 78 nbytes = crypto_pcbc_encrypt_segment(req, &walk, 79 cipher); 80 err = skcipher_walk_done(&walk, nbytes); 81 } 82 83 return err; 84 } 85 86 static int crypto_pcbc_decrypt_segment(struct skcipher_request *req, 87 struct skcipher_walk *walk, 88 struct crypto_cipher *tfm) 89 { 90 int bsize = crypto_cipher_blocksize(tfm); 91 unsigned int nbytes = walk->nbytes; 92 u8 *src = walk->src.virt.addr; 93 u8 *dst = walk->dst.virt.addr; 94 u8 * const iv = walk->iv; 95 96 do { 97 crypto_cipher_decrypt_one(tfm, dst, src); 98 crypto_xor(dst, iv, bsize); 99 crypto_xor_cpy(iv, dst, src, bsize); 100 101 src += bsize; 102 dst += bsize; 103 } while ((nbytes -= bsize) >= bsize); 104 105 return nbytes; 106 } 107 108 static int crypto_pcbc_decrypt_inplace(struct skcipher_request *req, 109 struct skcipher_walk *walk, 110 struct crypto_cipher *tfm) 111 { 112 int bsize = crypto_cipher_blocksize(tfm); 113 unsigned int nbytes = walk->nbytes; 114 u8 *src = walk->src.virt.addr; 115 u8 * const iv = walk->iv; 116 u8 tmpbuf[MAX_CIPHER_BLOCKSIZE] __aligned(__alignof__(u32)); 117 118 do { 119 memcpy(tmpbuf, src, bsize); 120 crypto_cipher_decrypt_one(tfm, src, src); 121 crypto_xor(src, iv, bsize); 122 crypto_xor_cpy(iv, src, tmpbuf, bsize); 123 124 src += bsize; 125 } while ((nbytes -= bsize) >= bsize); 126 127 return nbytes; 128 } 129 130 static int crypto_pcbc_decrypt(struct skcipher_request *req) 131 { 132 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 133 struct crypto_cipher *cipher = skcipher_cipher_simple(tfm); 134 struct skcipher_walk walk; 135 unsigned int nbytes; 136 int err; 137 138 err = skcipher_walk_virt(&walk, req, false); 139 140 while ((nbytes = walk.nbytes)) { 141 if (walk.src.virt.addr == walk.dst.virt.addr) 142 nbytes = crypto_pcbc_decrypt_inplace(req, &walk, 143 cipher); 144 else 145 nbytes = crypto_pcbc_decrypt_segment(req, &walk, 146 cipher); 147 err = skcipher_walk_done(&walk, nbytes); 148 } 149 150 return err; 151 } 152 153 static int crypto_pcbc_create(struct crypto_template *tmpl, struct rtattr **tb) 154 { 155 struct skcipher_instance *inst; 156 int err; 157 158 inst = skcipher_alloc_instance_simple(tmpl, tb); 159 if (IS_ERR(inst)) 160 return PTR_ERR(inst); 161 162 inst->alg.encrypt = crypto_pcbc_encrypt; 163 inst->alg.decrypt = crypto_pcbc_decrypt; 164 165 err = skcipher_register_instance(tmpl, inst); 166 if (err) 167 inst->free(inst); 168 169 return err; 170 } 171 172 static struct crypto_template crypto_pcbc_tmpl = { 173 .name = "pcbc", 174 .create = crypto_pcbc_create, 175 .module = THIS_MODULE, 176 }; 177 178 static int __init crypto_pcbc_module_init(void) 179 { 180 return crypto_register_template(&crypto_pcbc_tmpl); 181 } 182 183 static void __exit crypto_pcbc_module_exit(void) 184 { 185 crypto_unregister_template(&crypto_pcbc_tmpl); 186 } 187 188 subsys_initcall(crypto_pcbc_module_init); 189 module_exit(crypto_pcbc_module_exit); 190 191 MODULE_LICENSE("GPL"); 192 MODULE_DESCRIPTION("PCBC block cipher mode of operation"); 193 MODULE_ALIAS_CRYPTO("pcbc"); 194