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#include <crypto/xts.h>
31
32#include "aesp8-ppc.h"
33
34struct p8_aes_xts_ctx {
35 struct crypto_blkcipher *fallback;
36 struct aes_key enc_key;
37 struct aes_key dec_key;
38 struct aes_key tweak_key;
39};
40
41static int p8_aes_xts_init(struct crypto_tfm *tfm)
42{
43 const char *alg;
44 struct crypto_blkcipher *fallback;
45 struct p8_aes_xts_ctx *ctx = crypto_tfm_ctx(tfm);
46
47 if (!(alg = crypto_tfm_alg_name(tfm))) {
48 printk(KERN_ERR "Failed to get algorithm name.\n");
49 return -ENOENT;
50 }
51
52 fallback =
53 crypto_alloc_blkcipher(alg, 0, CRYPTO_ALG_NEED_FALLBACK);
54 if (IS_ERR(fallback)) {
55 printk(KERN_ERR
56 "Failed to allocate transformation for '%s': %ld\n",
57 alg, PTR_ERR(fallback));
58 return PTR_ERR(fallback);
59 }
60 printk(KERN_INFO "Using '%s' as fallback implementation.\n",
61 crypto_tfm_alg_driver_name((struct crypto_tfm *) fallback));
62
63 crypto_blkcipher_set_flags(
64 fallback,
65 crypto_blkcipher_get_flags((struct crypto_blkcipher *)tfm));
66 ctx->fallback = fallback;
67
68 return 0;
69}
70
71static void p8_aes_xts_exit(struct crypto_tfm *tfm)
72{
73 struct p8_aes_xts_ctx *ctx = crypto_tfm_ctx(tfm);
74
75 if (ctx->fallback) {
76 crypto_free_blkcipher(ctx->fallback);
77 ctx->fallback = NULL;
78 }
79}
80
81static int p8_aes_xts_setkey(struct crypto_tfm *tfm, const u8 *key,
82 unsigned int keylen)
83{
84 int ret;
85 struct p8_aes_xts_ctx *ctx = crypto_tfm_ctx(tfm);
86
87 ret = xts_check_key(tfm, key, keylen);
88 if (ret)
89 return ret;
90
91 preempt_disable();
92 pagefault_disable();
93 enable_kernel_vsx();
94 ret = aes_p8_set_encrypt_key(key + keylen/2, (keylen/2) * 8, &ctx->tweak_key);
95 ret += aes_p8_set_encrypt_key(key, (keylen/2) * 8, &ctx->enc_key);
96 ret += aes_p8_set_decrypt_key(key, (keylen/2) * 8, &ctx->dec_key);
97 disable_kernel_vsx();
98 pagefault_enable();
99 preempt_enable();
100
101 ret += crypto_blkcipher_setkey(ctx->fallback, key, keylen);
102 return ret;
103}
104
105static int p8_aes_xts_crypt(struct blkcipher_desc *desc,
106 struct scatterlist *dst,
107 struct scatterlist *src,
108 unsigned int nbytes, int enc)
109{
110 int ret;
111 u8 tweak[AES_BLOCK_SIZE];
112 u8 *iv;
113 struct blkcipher_walk walk;
114 struct p8_aes_xts_ctx *ctx =
115 crypto_tfm_ctx(crypto_blkcipher_tfm(desc->tfm));
116 struct blkcipher_desc fallback_desc = {
117 .tfm = ctx->fallback,
118 .info = desc->info,
119 .flags = desc->flags
120 };
121
122 if (in_interrupt()) {
123 ret = enc ? crypto_blkcipher_encrypt(&fallback_desc, dst, src, nbytes) :
124 crypto_blkcipher_decrypt(&fallback_desc, dst, src, nbytes);
125 } else {
126 preempt_disable();
127 pagefault_disable();
128 enable_kernel_vsx();
129
130 blkcipher_walk_init(&walk, dst, src, nbytes);
131
132 ret = blkcipher_walk_virt(desc, &walk);
133 iv = walk.iv;
134 memset(tweak, 0, AES_BLOCK_SIZE);
135 aes_p8_encrypt(iv, tweak, &ctx->tweak_key);
136
137 while ((nbytes = walk.nbytes)) {
138 if (enc)
139 aes_p8_xts_encrypt(walk.src.virt.addr, walk.dst.virt.addr,
140 nbytes & AES_BLOCK_MASK, &ctx->enc_key, NULL, tweak);
141 else
142 aes_p8_xts_decrypt(walk.src.virt.addr, walk.dst.virt.addr,
143 nbytes & AES_BLOCK_MASK, &ctx->dec_key, NULL, tweak);
144
145 nbytes &= AES_BLOCK_SIZE - 1;
146 ret = blkcipher_walk_done(desc, &walk, nbytes);
147 }
148
149 disable_kernel_vsx();
150 pagefault_enable();
151 preempt_enable();
152 }
153 return ret;
154}
155
156static int p8_aes_xts_encrypt(struct blkcipher_desc *desc,
157 struct scatterlist *dst,
158 struct scatterlist *src, unsigned int nbytes)
159{
160 return p8_aes_xts_crypt(desc, dst, src, nbytes, 1);
161}
162
163static int p8_aes_xts_decrypt(struct blkcipher_desc *desc,
164 struct scatterlist *dst,
165 struct scatterlist *src, unsigned int nbytes)
166{
167 return p8_aes_xts_crypt(desc, dst, src, nbytes, 0);
168}
169
170struct crypto_alg p8_aes_xts_alg = {
171 .cra_name = "xts(aes)",
172 .cra_driver_name = "p8_aes_xts",
173 .cra_module = THIS_MODULE,
174 .cra_priority = 2000,
175 .cra_type = &crypto_blkcipher_type,
176 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | CRYPTO_ALG_NEED_FALLBACK,
177 .cra_alignmask = 0,
178 .cra_blocksize = AES_BLOCK_SIZE,
179 .cra_ctxsize = sizeof(struct p8_aes_xts_ctx),
180 .cra_init = p8_aes_xts_init,
181 .cra_exit = p8_aes_xts_exit,
182 .cra_blkcipher = {
183 .ivsize = AES_BLOCK_SIZE,
184 .min_keysize = 2 * AES_MIN_KEY_SIZE,
185 .max_keysize = 2 * AES_MAX_KEY_SIZE,
186 .setkey = p8_aes_xts_setkey,
187 .encrypt = p8_aes_xts_encrypt,
188 .decrypt = p8_aes_xts_decrypt,
189 }
190};
191
