xref: /openbmc/linux/drivers/crypto/vmx/aes_xts.c (revision 82003e04)
1 /**
2  * AES XTS routines supporting VMX In-core instructions on Power 8
3  *
4  * Copyright (C) 2015 International Business Machines Inc.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundations; version 2 only.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY of FITNESS FOR A PARTICUPAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18  *
19  * Author: Leonidas S. Barbosa <leosilva@linux.vnet.ibm.com>
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 
34 struct 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 
41 static 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 
71 static 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 
81 static 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 
105 static 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 
156 static 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 
163 static 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 
170 struct 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