1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#include <linux/types.h>
23#include <linux/err.h>
24#include <linux/crypto.h>
25#include <linux/delay.h>
26#include <linux/hardirq.h>
27#include <asm/switch_to.h>
28#include <crypto/aes.h>
29#include <crypto/scatterwalk.h>
30
31#include "aesp8-ppc.h"
32
33struct p8_aes_cbc_ctx {
34 struct crypto_blkcipher *fallback;
35 struct aes_key enc_key;
36 struct aes_key dec_key;
37};
38
39static int p8_aes_cbc_init(struct crypto_tfm *tfm)
40{
41 const char *alg;
42 struct crypto_blkcipher *fallback;
43 struct p8_aes_cbc_ctx *ctx = crypto_tfm_ctx(tfm);
44
45 if (!(alg = crypto_tfm_alg_name(tfm))) {
46 printk(KERN_ERR "Failed to get algorithm name.\n");
47 return -ENOENT;
48 }
49
50 fallback =
51 crypto_alloc_blkcipher(alg, 0, CRYPTO_ALG_NEED_FALLBACK);
52 if (IS_ERR(fallback)) {
53 printk(KERN_ERR
54 "Failed to allocate transformation for '%s': %ld\n",
55 alg, PTR_ERR(fallback));
56 return PTR_ERR(fallback);
57 }
58 printk(KERN_INFO "Using '%s' as fallback implementation.\n",
59 crypto_tfm_alg_driver_name((struct crypto_tfm *) fallback));
60
61 crypto_blkcipher_set_flags(
62 fallback,
63 crypto_blkcipher_get_flags((struct crypto_blkcipher *)tfm));
64 ctx->fallback = fallback;
65
66 return 0;
67}
68
69static void p8_aes_cbc_exit(struct crypto_tfm *tfm)
70{
71 struct p8_aes_cbc_ctx *ctx = crypto_tfm_ctx(tfm);
72
73 if (ctx->fallback) {
74 crypto_free_blkcipher(ctx->fallback);
75 ctx->fallback = NULL;
76 }
77}
78
79static int p8_aes_cbc_setkey(struct crypto_tfm *tfm, const u8 *key,
80 unsigned int keylen)
81{
82 int ret;
83 struct p8_aes_cbc_ctx *ctx = crypto_tfm_ctx(tfm);
84
85 preempt_disable();
86 pagefault_disable();
87 enable_kernel_altivec();
88 enable_kernel_vsx();
89 ret = aes_p8_set_encrypt_key(key, keylen * 8, &ctx->enc_key);
90 ret += aes_p8_set_decrypt_key(key, keylen * 8, &ctx->dec_key);
91 pagefault_enable();
92 preempt_enable();
93
94 ret += crypto_blkcipher_setkey(ctx->fallback, key, keylen);
95 return ret;
96}
97
98static int p8_aes_cbc_encrypt(struct blkcipher_desc *desc,
99 struct scatterlist *dst,
100 struct scatterlist *src, unsigned int nbytes)
101{
102 int ret;
103 struct blkcipher_walk walk;
104 struct p8_aes_cbc_ctx *ctx =
105 crypto_tfm_ctx(crypto_blkcipher_tfm(desc->tfm));
106 struct blkcipher_desc fallback_desc = {
107 .tfm = ctx->fallback,
108 .info = desc->info,
109 .flags = desc->flags
110 };
111
112 if (in_interrupt()) {
113 ret = crypto_blkcipher_encrypt(&fallback_desc, dst, src,
114 nbytes);
115 } else {
116 preempt_disable();
117 pagefault_disable();
118 enable_kernel_altivec();
119 enable_kernel_vsx();
120
121 blkcipher_walk_init(&walk, dst, src, nbytes);
122 ret = blkcipher_walk_virt(desc, &walk);
123 while ((nbytes = walk.nbytes)) {
124 aes_p8_cbc_encrypt(walk.src.virt.addr,
125 walk.dst.virt.addr,
126 nbytes & AES_BLOCK_MASK,
127 &ctx->enc_key, walk.iv, 1);
128 nbytes &= AES_BLOCK_SIZE - 1;
129 ret = blkcipher_walk_done(desc, &walk, nbytes);
130 }
131
132 pagefault_enable();
133 preempt_enable();
134 }
135
136 return ret;
137}
138
139static int p8_aes_cbc_decrypt(struct blkcipher_desc *desc,
140 struct scatterlist *dst,
141 struct scatterlist *src, unsigned int nbytes)
142{
143 int ret;
144 struct blkcipher_walk walk;
145 struct p8_aes_cbc_ctx *ctx =
146 crypto_tfm_ctx(crypto_blkcipher_tfm(desc->tfm));
147 struct blkcipher_desc fallback_desc = {
148 .tfm = ctx->fallback,
149 .info = desc->info,
150 .flags = desc->flags
151 };
152
153 if (in_interrupt()) {
154 ret = crypto_blkcipher_decrypt(&fallback_desc, dst, src,
155 nbytes);
156 } else {
157 preempt_disable();
158 pagefault_disable();
159 enable_kernel_altivec();
160 enable_kernel_vsx();
161
162 blkcipher_walk_init(&walk, dst, src, nbytes);
163 ret = blkcipher_walk_virt(desc, &walk);
164 while ((nbytes = walk.nbytes)) {
165 aes_p8_cbc_encrypt(walk.src.virt.addr,
166 walk.dst.virt.addr,
167 nbytes & AES_BLOCK_MASK,
168 &ctx->dec_key, walk.iv, 0);
169 nbytes &= AES_BLOCK_SIZE - 1;
170 ret = blkcipher_walk_done(desc, &walk, nbytes);
171 }
172
173 pagefault_enable();
174 preempt_enable();
175 }
176
177 return ret;
178}
179
180
181struct crypto_alg p8_aes_cbc_alg = {
182 .cra_name = "cbc(aes)",
183 .cra_driver_name = "p8_aes_cbc",
184 .cra_module = THIS_MODULE,
185 .cra_priority = 1000,
186 .cra_type = &crypto_blkcipher_type,
187 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | CRYPTO_ALG_NEED_FALLBACK,
188 .cra_alignmask = 0,
189 .cra_blocksize = AES_BLOCK_SIZE,
190 .cra_ctxsize = sizeof(struct p8_aes_cbc_ctx),
191 .cra_init = p8_aes_cbc_init,
192 .cra_exit = p8_aes_cbc_exit,
193 .cra_blkcipher = {
194 .ivsize = 0,
195 .min_keysize = AES_MIN_KEY_SIZE,
196 .max_keysize = AES_MAX_KEY_SIZE,
197 .setkey = p8_aes_cbc_setkey,
198 .encrypt = p8_aes_cbc_encrypt,
199 .decrypt = p8_aes_cbc_decrypt,
200 },
201};
202
