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