2 * Driver for /dev/crypto device (aka CryptoDev)
4 * Copyright (c) 2010 Nikos Mavrogiannopoulos <nmav@gnutls.org>
6 * This file is part of linux cryptodev.
8 * cryptodev is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
13 * cryptodev is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
22 #include <linux/crypto.h>
24 #include <linux/highmem.h>
25 #include <linux/random.h>
26 #include <asm/uaccess.h>
27 #include <asm/ioctl.h>
28 #include <linux/scatterlist.h>
29 #include <crypto/algapi.h>
30 #include <crypto/hash.h>
31 #include "cryptodev.h"
32 #include "cryptodev_int.h"
35 struct cryptodev_result
{
36 struct completion completion
;
40 static void cryptodev_complete(struct crypto_async_request
*req
, int err
)
42 struct cryptodev_result
*res
= req
->data
;
44 if (err
== -EINPROGRESS
)
48 complete(&res
->completion
);
51 int cryptodev_cipher_init(struct cipher_data
* out
, const char* alg_name
, uint8_t __user
* key
, size_t keylen
)
53 uint8_t keyp
[CRYPTO_CIPHER_MAX_KEY_LEN
];
54 struct ablkcipher_alg
* alg
;
57 memset(out
, 0, sizeof(*out
));
61 if (unlikely(keylen
> CRYPTO_CIPHER_MAX_KEY_LEN
)) {
62 dprintk(1,KERN_DEBUG
,"Setting key failed for %s-%zu.\n",
66 /* Copy the key from user and set to TFM. */
67 copy_from_user(keyp
, key
, keylen
);
69 out
->async
.s
= crypto_alloc_ablkcipher(alg_name
, 0, 0);
70 if (IS_ERR(out
->async
.s
)) {
71 dprintk(1,KERN_DEBUG
,"%s: Failed to load cipher %s\n", __func__
,
76 alg
= crypto_ablkcipher_alg(out
->async
.s
);
79 /* Was correct key length supplied? */
80 if ((keylen
< alg
->min_keysize
) ||
81 (keylen
> alg
->max_keysize
)) {
82 dprintk(1,KERN_DEBUG
,"Wrong keylen '%zu' for algorithm '%s'. Use %u to %u.\n",
83 keylen
, alg_name
, alg
->min_keysize
,
90 ret
= crypto_ablkcipher_setkey(out
->async
.s
, keyp
, keylen
);
92 dprintk(1,KERN_DEBUG
,"Setting key failed for %s-%zu.\n",
98 out
->blocksize
= crypto_ablkcipher_blocksize(out
->async
.s
);
99 out
->ivsize
= crypto_ablkcipher_ivsize(out
->async
.s
);
101 out
->async
.result
= kmalloc(sizeof(*out
->async
.result
), GFP_KERNEL
);
102 if (!out
->async
.result
) {
107 memset(out
->async
.result
, 0, sizeof(*out
->async
.result
));
108 init_completion(&out
->async
.result
->completion
);
110 out
->async
.request
= ablkcipher_request_alloc(out
->async
.s
, GFP_KERNEL
);
111 if (!out
->async
.request
) {
112 dprintk(1,KERN_ERR
,"error allocating async crypto request\n");
117 ablkcipher_request_set_callback(out
->async
.request
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
118 cryptodev_complete
, out
->async
.result
);
122 crypto_free_ablkcipher(out
->async
.s
);
123 kfree(out
->async
.result
);
124 ablkcipher_request_free(out
->async
.request
);
129 void cryptodev_cipher_deinit(struct cipher_data
* cdata
)
131 crypto_free_ablkcipher(cdata
->async
.s
);
132 kfree(cdata
->async
.result
);
133 ablkcipher_request_free(cdata
->async
.request
);
138 void cryptodev_cipher_set_iv(struct cipher_data
* cdata
, void __user
* iv
, size_t iv_size
)
140 copy_from_user(cdata
->async
.iv
, iv
, min(iv_size
,sizeof(cdata
->async
.iv
)));
143 static inline int waitfor (struct cryptodev_result
* cr
, ssize_t ret
)
150 wait_for_completion(&cr
->completion
);
151 /* At this point we known for sure the request has finished,
152 * because wait_for_completion above was not interruptible.
153 * This is important because otherwise hardware or driver
154 * might try to access memory which will be freed or reused for
155 * another request. */
158 dprintk(0,KERN_ERR
,"error from async request: %zd \n", ret
);
170 ssize_t
cryptodev_cipher_encrypt( struct cipher_data
* cdata
, struct scatterlist
*sg1
, struct scatterlist
*sg2
, size_t len
)
174 INIT_COMPLETION(cdata
->async
.result
->completion
);
175 ablkcipher_request_set_crypt(cdata
->async
.request
, sg1
, sg2
,
176 len
, cdata
->async
.iv
);
177 ret
= crypto_ablkcipher_encrypt(cdata
->async
.request
);
179 return waitfor(cdata
->async
.result
,ret
);
182 ssize_t
cryptodev_cipher_decrypt( struct cipher_data
* cdata
, struct scatterlist
*sg1
, struct scatterlist
*sg2
, size_t len
)
186 INIT_COMPLETION(cdata
->async
.result
->completion
);
187 ablkcipher_request_set_crypt(cdata
->async
.request
, sg1
, sg2
,
188 len
, cdata
->async
.iv
);
189 ret
= crypto_ablkcipher_decrypt(cdata
->async
.request
);
191 return waitfor(cdata
->async
.result
, ret
);
196 int cryptodev_hash_init( struct hash_data
* hdata
, const char* alg_name
, int hmac_mode
, void __user
* mackey
, size_t mackeylen
)
199 uint8_t hkeyp
[CRYPTO_HMAC_MAX_KEY_LEN
];
203 if (mackeylen
> CRYPTO_HMAC_MAX_KEY_LEN
) {
204 dprintk(1,KERN_DEBUG
,"Setting hmac key failed for %s-%zu.\n",
205 alg_name
, mackeylen
*8);
208 copy_from_user(hkeyp
, mackey
, mackeylen
);
210 hdata
->async
.s
= crypto_alloc_ahash(alg_name
, 0, 0);
211 if (IS_ERR(hdata
->async
.s
)) {
212 dprintk(1,KERN_DEBUG
,"%s: Failed to load transform for %s\n", __func__
,
217 /* Copy the key from user and set to TFM. */
218 if (hmac_mode
!= 0) {
220 ret
= crypto_ahash_setkey(hdata
->async
.s
, hkeyp
, mackeylen
);
222 dprintk(1,KERN_DEBUG
,"Setting hmac key failed for %s-%zu.\n",
223 alg_name
, mackeylen
*8);
229 hdata
->digestsize
= crypto_ahash_digestsize(hdata
->async
.s
);
231 hdata
->async
.result
= kmalloc(sizeof(*hdata
->async
.result
), GFP_KERNEL
);
232 if (!hdata
->async
.result
) {
237 memset(hdata
->async
.result
, 0, sizeof(*hdata
->async
.result
));
238 init_completion(&hdata
->async
.result
->completion
);
240 hdata
->async
.request
= ahash_request_alloc(hdata
->async
.s
, GFP_KERNEL
);
241 if (!hdata
->async
.request
) {
242 dprintk(0,KERN_ERR
,"error allocating async crypto request\n");
247 ahash_request_set_callback(hdata
->async
.request
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
248 cryptodev_complete
, hdata
->async
.result
);
254 crypto_free_ahash(hdata
->async
.s
);
258 void cryptodev_hash_deinit(struct hash_data
* hdata
)
260 crypto_free_ahash(hdata
->async
.s
);
264 int cryptodev_hash_reset( struct hash_data
* hdata
)
267 ret
= crypto_ahash_init(hdata
->async
.request
);
270 "error in crypto_hash_init()\n");
278 ssize_t
cryptodev_hash_update( struct hash_data
* hdata
, struct scatterlist
*sg
, size_t len
)
282 INIT_COMPLETION(hdata
->async
.result
->completion
);
283 ahash_request_set_crypt(hdata
->async
.request
, sg
, NULL
,
286 ret
= crypto_ahash_update(hdata
->async
.request
);
288 return waitfor(hdata
->async
.result
,ret
);
292 int cryptodev_hash_final( struct hash_data
* hdata
, void* output
)
296 INIT_COMPLETION(hdata
->async
.result
->completion
);
297 ahash_request_set_crypt(hdata
->async
.request
, NULL
, output
, 0);
299 ret
= crypto_ahash_final(hdata
->async
.request
);
301 return waitfor(hdata
->async
.result
,ret
);