2 * AES CBC routines supporting VMX instructions on the Power 8
4 * Copyright (C) 2015 International Business Machines Inc.
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 Foundation; version 2 only.
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 or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
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.
19 * Author: Marcelo Henrique Cerri <mhcerri@br.ibm.com>
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/skcipher.h>
32 #include "aesp8-ppc.h"
34 struct p8_aes_cbc_ctx
{
35 struct crypto_skcipher
*fallback
;
36 struct aes_key enc_key
;
37 struct aes_key dec_key
;
40 static int p8_aes_cbc_init(struct crypto_tfm
*tfm
)
43 struct crypto_skcipher
*fallback
;
44 struct p8_aes_cbc_ctx
*ctx
= crypto_tfm_ctx(tfm
);
46 if (!(alg
= crypto_tfm_alg_name(tfm
))) {
47 printk(KERN_ERR
"Failed to get algorithm name.\n");
51 fallback
= crypto_alloc_skcipher(alg
, 0,
52 CRYPTO_ALG_ASYNC
| CRYPTO_ALG_NEED_FALLBACK
);
54 if (IS_ERR(fallback
)) {
56 "Failed to allocate transformation for '%s': %ld\n",
57 alg
, PTR_ERR(fallback
));
58 return PTR_ERR(fallback
);
60 printk(KERN_INFO
"Using '%s' as fallback implementation.\n",
61 crypto_skcipher_driver_name(fallback
));
64 crypto_skcipher_set_flags(
66 crypto_skcipher_get_flags((struct crypto_skcipher
*)tfm
));
67 ctx
->fallback
= fallback
;
72 static void p8_aes_cbc_exit(struct crypto_tfm
*tfm
)
74 struct p8_aes_cbc_ctx
*ctx
= crypto_tfm_ctx(tfm
);
77 crypto_free_skcipher(ctx
->fallback
);
82 static int p8_aes_cbc_setkey(struct crypto_tfm
*tfm
, const u8
*key
,
86 struct p8_aes_cbc_ctx
*ctx
= crypto_tfm_ctx(tfm
);
91 ret
= aes_p8_set_encrypt_key(key
, keylen
* 8, &ctx
->enc_key
);
92 ret
+= aes_p8_set_decrypt_key(key
, keylen
* 8, &ctx
->dec_key
);
97 ret
+= crypto_skcipher_setkey(ctx
->fallback
, key
, keylen
);
101 static int p8_aes_cbc_encrypt(struct blkcipher_desc
*desc
,
102 struct scatterlist
*dst
,
103 struct scatterlist
*src
, unsigned int nbytes
)
106 struct blkcipher_walk walk
;
107 struct p8_aes_cbc_ctx
*ctx
=
108 crypto_tfm_ctx(crypto_blkcipher_tfm(desc
->tfm
));
110 if (in_interrupt()) {
111 SKCIPHER_REQUEST_ON_STACK(req
, ctx
->fallback
);
112 skcipher_request_set_tfm(req
, ctx
->fallback
);
113 skcipher_request_set_callback(req
, desc
->flags
, NULL
, NULL
);
114 skcipher_request_set_crypt(req
, src
, dst
, nbytes
, desc
->info
);
115 ret
= crypto_skcipher_encrypt(req
);
116 skcipher_request_zero(req
);
122 blkcipher_walk_init(&walk
, dst
, src
, nbytes
);
123 ret
= blkcipher_walk_virt(desc
, &walk
);
124 while ((nbytes
= walk
.nbytes
)) {
125 aes_p8_cbc_encrypt(walk
.src
.virt
.addr
,
127 nbytes
& AES_BLOCK_MASK
,
128 &ctx
->enc_key
, walk
.iv
, 1);
129 nbytes
&= AES_BLOCK_SIZE
- 1;
130 ret
= blkcipher_walk_done(desc
, &walk
, nbytes
);
133 disable_kernel_vsx();
141 static int p8_aes_cbc_decrypt(struct blkcipher_desc
*desc
,
142 struct scatterlist
*dst
,
143 struct scatterlist
*src
, unsigned int nbytes
)
146 struct blkcipher_walk walk
;
147 struct p8_aes_cbc_ctx
*ctx
=
148 crypto_tfm_ctx(crypto_blkcipher_tfm(desc
->tfm
));
150 if (in_interrupt()) {
151 SKCIPHER_REQUEST_ON_STACK(req
, ctx
->fallback
);
152 skcipher_request_set_tfm(req
, ctx
->fallback
);
153 skcipher_request_set_callback(req
, desc
->flags
, NULL
, NULL
);
154 skcipher_request_set_crypt(req
, src
, dst
, nbytes
, desc
->info
);
155 ret
= crypto_skcipher_decrypt(req
);
156 skcipher_request_zero(req
);
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
,
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
);
173 disable_kernel_vsx();
182 struct crypto_alg p8_aes_cbc_alg
= {
183 .cra_name
= "cbc(aes)",
184 .cra_driver_name
= "p8_aes_cbc",
185 .cra_module
= THIS_MODULE
,
186 .cra_priority
= 2000,
187 .cra_type
= &crypto_blkcipher_type
,
188 .cra_flags
= CRYPTO_ALG_TYPE_BLKCIPHER
| CRYPTO_ALG_NEED_FALLBACK
,
190 .cra_blocksize
= AES_BLOCK_SIZE
,
191 .cra_ctxsize
= sizeof(struct p8_aes_cbc_ctx
),
192 .cra_init
= p8_aes_cbc_init
,
193 .cra_exit
= p8_aes_cbc_exit
,
195 .ivsize
= AES_BLOCK_SIZE
,
196 .min_keysize
= AES_MIN_KEY_SIZE
,
197 .max_keysize
= AES_MAX_KEY_SIZE
,
198 .setkey
= p8_aes_cbc_setkey
,
199 .encrypt
= p8_aes_cbc_encrypt
,
200 .decrypt
= p8_aes_cbc_decrypt
,