1 #include <linux/crypto.h>
2 #include <linux/kernel.h>
3 #include <linux/module.h>
4 #include <linux/printk.h>
5 
6 #include <crypto/aes.h>
7 #include <crypto/skcipher.h>
8 #include <crypto/ctr.h>
9 #include <crypto/des.h>
10 #include <crypto/xts.h>
11 
12 #include "nitrox_dev.h"
13 #include "nitrox_common.h"
14 #include "nitrox_req.h"
15 
16 #define PRIO 4001
17 
18 struct nitrox_cipher {
19 	const char *name;
20 	enum flexi_cipher value;
21 };
22 
23 /**
24  * supported cipher list
25  */
26 static const struct nitrox_cipher flexi_cipher_table[] = {
27 	{ "null",		CIPHER_NULL },
28 	{ "cbc(des3_ede)",	CIPHER_3DES_CBC },
29 	{ "ecb(des3_ede)",	CIPHER_3DES_ECB },
30 	{ "cbc(aes)",		CIPHER_AES_CBC },
31 	{ "ecb(aes)",		CIPHER_AES_ECB },
32 	{ "cfb(aes)",		CIPHER_AES_CFB },
33 	{ "rfc3686(ctr(aes))",	CIPHER_AES_CTR },
34 	{ "xts(aes)",		CIPHER_AES_XTS },
35 	{ "cts(cbc(aes))",	CIPHER_AES_CBC_CTS },
36 	{ NULL,			CIPHER_INVALID }
37 };
38 
39 static enum flexi_cipher flexi_cipher_type(const char *name)
40 {
41 	const struct nitrox_cipher *cipher = flexi_cipher_table;
42 
43 	while (cipher->name) {
44 		if (!strcmp(cipher->name, name))
45 			break;
46 		cipher++;
47 	}
48 	return cipher->value;
49 }
50 
51 static int flexi_aes_keylen(int keylen)
52 {
53 	int aes_keylen;
54 
55 	switch (keylen) {
56 	case AES_KEYSIZE_128:
57 		aes_keylen = 1;
58 		break;
59 	case AES_KEYSIZE_192:
60 		aes_keylen = 2;
61 		break;
62 	case AES_KEYSIZE_256:
63 		aes_keylen = 3;
64 		break;
65 	default:
66 		aes_keylen = -EINVAL;
67 		break;
68 	}
69 	return aes_keylen;
70 }
71 
72 static int nitrox_skcipher_init(struct crypto_skcipher *tfm)
73 {
74 	struct nitrox_crypto_ctx *nctx = crypto_skcipher_ctx(tfm);
75 	void *fctx;
76 
77 	/* get the first device */
78 	nctx->ndev = nitrox_get_first_device();
79 	if (!nctx->ndev)
80 		return -ENODEV;
81 
82 	/* allocate nitrox crypto context */
83 	fctx = crypto_alloc_context(nctx->ndev);
84 	if (!fctx) {
85 		nitrox_put_device(nctx->ndev);
86 		return -ENOMEM;
87 	}
88 	nctx->u.ctx_handle = (uintptr_t)fctx;
89 	crypto_skcipher_set_reqsize(tfm, crypto_skcipher_reqsize(tfm) +
90 				    sizeof(struct nitrox_kcrypt_request));
91 	return 0;
92 }
93 
94 static void nitrox_skcipher_exit(struct crypto_skcipher *tfm)
95 {
96 	struct nitrox_crypto_ctx *nctx = crypto_skcipher_ctx(tfm);
97 
98 	/* free the nitrox crypto context */
99 	if (nctx->u.ctx_handle) {
100 		struct flexi_crypto_context *fctx = nctx->u.fctx;
101 
102 		memset(&fctx->crypto, 0, sizeof(struct crypto_keys));
103 		memset(&fctx->auth, 0, sizeof(struct auth_keys));
104 		crypto_free_context((void *)fctx);
105 	}
106 	nitrox_put_device(nctx->ndev);
107 
108 	nctx->u.ctx_handle = 0;
109 	nctx->ndev = NULL;
110 }
111 
112 static inline int nitrox_skcipher_setkey(struct crypto_skcipher *cipher,
113 					 int aes_keylen, const u8 *key,
114 					 unsigned int keylen)
115 {
116 	struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);
117 	struct nitrox_crypto_ctx *nctx = crypto_tfm_ctx(tfm);
118 	struct flexi_crypto_context *fctx;
119 	enum flexi_cipher cipher_type;
120 	const char *name;
121 
122 	name = crypto_tfm_alg_name(tfm);
123 	cipher_type = flexi_cipher_type(name);
124 	if (unlikely(cipher_type == CIPHER_INVALID)) {
125 		pr_err("unsupported cipher: %s\n", name);
126 		return -EINVAL;
127 	}
128 
129 	/* fill crypto context */
130 	fctx = nctx->u.fctx;
131 	fctx->flags = 0;
132 	fctx->w0.cipher_type = cipher_type;
133 	fctx->w0.aes_keylen = aes_keylen;
134 	fctx->w0.iv_source = IV_FROM_DPTR;
135 	fctx->flags = cpu_to_be64(*(u64 *)&fctx->w0);
136 	/* copy the key to context */
137 	memcpy(fctx->crypto.u.key, key, keylen);
138 
139 	return 0;
140 }
141 
142 static int nitrox_aes_setkey(struct crypto_skcipher *cipher, const u8 *key,
143 			     unsigned int keylen)
144 {
145 	int aes_keylen;
146 
147 	aes_keylen = flexi_aes_keylen(keylen);
148 	if (aes_keylen < 0) {
149 		crypto_skcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
150 		return -EINVAL;
151 	}
152 	return nitrox_skcipher_setkey(cipher, aes_keylen, key, keylen);
153 }
154 
155 static void nitrox_skcipher_callback(struct skcipher_request *skreq,
156 				     int err)
157 {
158 	if (err) {
159 		pr_err_ratelimited("request failed status 0x%0x\n", err);
160 		err = -EINVAL;
161 	}
162 	skcipher_request_complete(skreq, err);
163 }
164 
165 static int nitrox_skcipher_crypt(struct skcipher_request *skreq, bool enc)
166 {
167 	struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(skreq);
168 	struct nitrox_crypto_ctx *nctx = crypto_skcipher_ctx(cipher);
169 	struct nitrox_kcrypt_request *nkreq = skcipher_request_ctx(skreq);
170 	int ivsize = crypto_skcipher_ivsize(cipher);
171 	struct se_crypto_request *creq;
172 
173 	creq = &nkreq->creq;
174 	creq->flags = skreq->base.flags;
175 	creq->gfp = (skreq->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) ?
176 		     GFP_KERNEL : GFP_ATOMIC;
177 
178 	/* fill the request */
179 	creq->ctrl.value = 0;
180 	creq->opcode = FLEXI_CRYPTO_ENCRYPT_HMAC;
181 	creq->ctrl.s.arg = (enc ? ENCRYPT : DECRYPT);
182 	/* param0: length of the data to be encrypted */
183 	creq->gph.param0 = cpu_to_be16(skreq->cryptlen);
184 	creq->gph.param1 = 0;
185 	/* param2: encryption data offset */
186 	creq->gph.param2 = cpu_to_be16(ivsize);
187 	creq->gph.param3 = 0;
188 
189 	creq->ctx_handle = nctx->u.ctx_handle;
190 	creq->ctrl.s.ctxl = sizeof(struct flexi_crypto_context);
191 
192 	/* copy the iv */
193 	memcpy(creq->iv, skreq->iv, ivsize);
194 	creq->ivsize = ivsize;
195 	creq->src = skreq->src;
196 	creq->dst = skreq->dst;
197 
198 	nkreq->nctx = nctx;
199 	nkreq->skreq = skreq;
200 
201 	/* send the crypto request */
202 	return nitrox_process_se_request(nctx->ndev, creq,
203 					 nitrox_skcipher_callback, skreq);
204 }
205 
206 static int nitrox_aes_encrypt(struct skcipher_request *skreq)
207 {
208 	return nitrox_skcipher_crypt(skreq, true);
209 }
210 
211 static int nitrox_aes_decrypt(struct skcipher_request *skreq)
212 {
213 	return nitrox_skcipher_crypt(skreq, false);
214 }
215 
216 static int nitrox_3des_setkey(struct crypto_skcipher *cipher,
217 			      const u8 *key, unsigned int keylen)
218 {
219 	if (keylen != DES3_EDE_KEY_SIZE) {
220 		crypto_skcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
221 		return -EINVAL;
222 	}
223 
224 	return nitrox_skcipher_setkey(cipher, 0, key, keylen);
225 }
226 
227 static int nitrox_3des_encrypt(struct skcipher_request *skreq)
228 {
229 	return nitrox_skcipher_crypt(skreq, true);
230 }
231 
232 static int nitrox_3des_decrypt(struct skcipher_request *skreq)
233 {
234 	return nitrox_skcipher_crypt(skreq, false);
235 }
236 
237 static int nitrox_aes_xts_setkey(struct crypto_skcipher *cipher,
238 				 const u8 *key, unsigned int keylen)
239 {
240 	struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);
241 	struct nitrox_crypto_ctx *nctx = crypto_tfm_ctx(tfm);
242 	struct flexi_crypto_context *fctx;
243 	int aes_keylen, ret;
244 
245 	ret = xts_check_key(tfm, key, keylen);
246 	if (ret)
247 		return ret;
248 
249 	keylen /= 2;
250 
251 	aes_keylen = flexi_aes_keylen(keylen);
252 	if (aes_keylen < 0) {
253 		crypto_skcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
254 		return -EINVAL;
255 	}
256 
257 	fctx = nctx->u.fctx;
258 	/* copy KEY2 */
259 	memcpy(fctx->auth.u.key2, (key + keylen), keylen);
260 
261 	return nitrox_skcipher_setkey(cipher, aes_keylen, key, keylen);
262 }
263 
264 static int nitrox_aes_ctr_rfc3686_setkey(struct crypto_skcipher *cipher,
265 					 const u8 *key, unsigned int keylen)
266 {
267 	struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);
268 	struct nitrox_crypto_ctx *nctx = crypto_tfm_ctx(tfm);
269 	struct flexi_crypto_context *fctx;
270 	int aes_keylen;
271 
272 	if (keylen < CTR_RFC3686_NONCE_SIZE)
273 		return -EINVAL;
274 
275 	fctx = nctx->u.fctx;
276 
277 	memcpy(fctx->crypto.iv, key + (keylen - CTR_RFC3686_NONCE_SIZE),
278 	       CTR_RFC3686_NONCE_SIZE);
279 
280 	keylen -= CTR_RFC3686_NONCE_SIZE;
281 
282 	aes_keylen = flexi_aes_keylen(keylen);
283 	if (aes_keylen < 0) {
284 		crypto_skcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
285 		return -EINVAL;
286 	}
287 	return nitrox_skcipher_setkey(cipher, aes_keylen, key, keylen);
288 }
289 
290 static struct skcipher_alg nitrox_skciphers[] = { {
291 	.base = {
292 		.cra_name = "cbc(aes)",
293 		.cra_driver_name = "n5_cbc(aes)",
294 		.cra_priority = PRIO,
295 		.cra_flags = CRYPTO_ALG_ASYNC,
296 		.cra_blocksize = AES_BLOCK_SIZE,
297 		.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),
298 		.cra_alignmask = 0,
299 		.cra_module = THIS_MODULE,
300 	},
301 	.min_keysize = AES_MIN_KEY_SIZE,
302 	.max_keysize = AES_MAX_KEY_SIZE,
303 	.ivsize = AES_BLOCK_SIZE,
304 	.setkey = nitrox_aes_setkey,
305 	.encrypt = nitrox_aes_encrypt,
306 	.decrypt = nitrox_aes_decrypt,
307 	.init = nitrox_skcipher_init,
308 	.exit = nitrox_skcipher_exit,
309 }, {
310 	.base = {
311 		.cra_name = "ecb(aes)",
312 		.cra_driver_name = "n5_ecb(aes)",
313 		.cra_priority = PRIO,
314 		.cra_flags = CRYPTO_ALG_ASYNC,
315 		.cra_blocksize = AES_BLOCK_SIZE,
316 		.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),
317 		.cra_alignmask = 0,
318 		.cra_module = THIS_MODULE,
319 	},
320 	.min_keysize = AES_MIN_KEY_SIZE,
321 	.max_keysize = AES_MAX_KEY_SIZE,
322 	.ivsize = AES_BLOCK_SIZE,
323 	.setkey = nitrox_aes_setkey,
324 	.encrypt = nitrox_aes_encrypt,
325 	.decrypt = nitrox_aes_decrypt,
326 	.init = nitrox_skcipher_init,
327 	.exit = nitrox_skcipher_exit,
328 }, {
329 	.base = {
330 		.cra_name = "cfb(aes)",
331 		.cra_driver_name = "n5_cfb(aes)",
332 		.cra_priority = PRIO,
333 		.cra_flags = CRYPTO_ALG_ASYNC,
334 		.cra_blocksize = AES_BLOCK_SIZE,
335 		.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),
336 		.cra_alignmask = 0,
337 		.cra_module = THIS_MODULE,
338 	},
339 	.min_keysize = AES_MIN_KEY_SIZE,
340 	.max_keysize = AES_MAX_KEY_SIZE,
341 	.ivsize = AES_BLOCK_SIZE,
342 	.setkey = nitrox_aes_setkey,
343 	.encrypt = nitrox_aes_encrypt,
344 	.decrypt = nitrox_aes_decrypt,
345 	.init = nitrox_skcipher_init,
346 	.exit = nitrox_skcipher_exit,
347 }, {
348 	.base = {
349 		.cra_name = "xts(aes)",
350 		.cra_driver_name = "n5_xts(aes)",
351 		.cra_priority = PRIO,
352 		.cra_flags = CRYPTO_ALG_ASYNC,
353 		.cra_blocksize = AES_BLOCK_SIZE,
354 		.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),
355 		.cra_alignmask = 0,
356 		.cra_module = THIS_MODULE,
357 	},
358 	.min_keysize = 2 * AES_MIN_KEY_SIZE,
359 	.max_keysize = 2 * AES_MAX_KEY_SIZE,
360 	.ivsize = AES_BLOCK_SIZE,
361 	.setkey = nitrox_aes_xts_setkey,
362 	.encrypt = nitrox_aes_encrypt,
363 	.decrypt = nitrox_aes_decrypt,
364 	.init = nitrox_skcipher_init,
365 	.exit = nitrox_skcipher_exit,
366 }, {
367 	.base = {
368 		.cra_name = "rfc3686(ctr(aes))",
369 		.cra_driver_name = "n5_rfc3686(ctr(aes))",
370 		.cra_priority = PRIO,
371 		.cra_flags = CRYPTO_ALG_ASYNC,
372 		.cra_blocksize = 1,
373 		.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),
374 		.cra_alignmask = 0,
375 		.cra_module = THIS_MODULE,
376 	},
377 	.min_keysize = AES_MIN_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
378 	.max_keysize = AES_MAX_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
379 	.ivsize = CTR_RFC3686_IV_SIZE,
380 	.init = nitrox_skcipher_init,
381 	.exit = nitrox_skcipher_exit,
382 	.setkey = nitrox_aes_ctr_rfc3686_setkey,
383 	.encrypt = nitrox_aes_encrypt,
384 	.decrypt = nitrox_aes_decrypt,
385 }, {
386 	.base = {
387 		.cra_name = "cts(cbc(aes))",
388 		.cra_driver_name = "n5_cts(cbc(aes))",
389 		.cra_priority = PRIO,
390 		.cra_flags = CRYPTO_ALG_ASYNC,
391 		.cra_blocksize = AES_BLOCK_SIZE,
392 		.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),
393 		.cra_alignmask = 0,
394 		.cra_type = &crypto_ablkcipher_type,
395 		.cra_module = THIS_MODULE,
396 	},
397 	.min_keysize = AES_MIN_KEY_SIZE,
398 	.max_keysize = AES_MAX_KEY_SIZE,
399 	.ivsize = AES_BLOCK_SIZE,
400 	.setkey = nitrox_aes_setkey,
401 	.encrypt = nitrox_aes_encrypt,
402 	.decrypt = nitrox_aes_decrypt,
403 	.init = nitrox_skcipher_init,
404 	.exit = nitrox_skcipher_exit,
405 }, {
406 	.base = {
407 		.cra_name = "cbc(des3_ede)",
408 		.cra_driver_name = "n5_cbc(des3_ede)",
409 		.cra_priority = PRIO,
410 		.cra_flags = CRYPTO_ALG_ASYNC,
411 		.cra_blocksize = DES3_EDE_BLOCK_SIZE,
412 		.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),
413 		.cra_alignmask = 0,
414 		.cra_module = THIS_MODULE,
415 	},
416 	.min_keysize = DES3_EDE_KEY_SIZE,
417 	.max_keysize = DES3_EDE_KEY_SIZE,
418 	.ivsize = DES3_EDE_BLOCK_SIZE,
419 	.setkey = nitrox_3des_setkey,
420 	.encrypt = nitrox_3des_encrypt,
421 	.decrypt = nitrox_3des_decrypt,
422 	.init = nitrox_skcipher_init,
423 	.exit = nitrox_skcipher_exit,
424 }, {
425 	.base = {
426 		.cra_name = "ecb(des3_ede)",
427 		.cra_driver_name = "n5_ecb(des3_ede)",
428 		.cra_priority = PRIO,
429 		.cra_flags = CRYPTO_ALG_ASYNC,
430 		.cra_blocksize = DES3_EDE_BLOCK_SIZE,
431 		.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),
432 		.cra_alignmask = 0,
433 		.cra_module = THIS_MODULE,
434 	},
435 	.min_keysize = DES3_EDE_KEY_SIZE,
436 	.max_keysize = DES3_EDE_KEY_SIZE,
437 	.ivsize = DES3_EDE_BLOCK_SIZE,
438 	.setkey = nitrox_3des_setkey,
439 	.encrypt = nitrox_3des_encrypt,
440 	.decrypt = nitrox_3des_decrypt,
441 	.init = nitrox_skcipher_init,
442 	.exit = nitrox_skcipher_exit,
443 }
444 
445 };
446 
447 int nitrox_crypto_register(void)
448 {
449 	return crypto_register_skciphers(nitrox_skciphers,
450 					 ARRAY_SIZE(nitrox_skciphers));
451 }
452 
453 void nitrox_crypto_unregister(void)
454 {
455 	crypto_unregister_skciphers(nitrox_skciphers,
456 				    ARRAY_SIZE(nitrox_skciphers));
457 }
458