Merge tag 'block-pull-request' of https://gitlab.com/stefanha/qemu into staging
[qemu.git] / backends / cryptodev-builtin.c
1 /*
2 * QEMU Cryptodev backend for QEMU cipher APIs
3 *
4 * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
5 *
6 * Authors:
7 * Gonglei <arei.gonglei@huawei.com>
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
21 *
22 */
23
24 #include "qemu/osdep.h"
25 #include "sysemu/cryptodev.h"
26 #include "qapi/error.h"
27 #include "standard-headers/linux/virtio_crypto.h"
28 #include "crypto/cipher.h"
29 #include "crypto/akcipher.h"
30 #include "qom/object.h"
31
32
33 /**
34 * @TYPE_CRYPTODEV_BACKEND_BUILTIN:
35 * name of backend that uses QEMU cipher API
36 */
37 #define TYPE_CRYPTODEV_BACKEND_BUILTIN "cryptodev-backend-builtin"
38
39 OBJECT_DECLARE_SIMPLE_TYPE(CryptoDevBackendBuiltin, CRYPTODEV_BACKEND_BUILTIN)
40
41
42 typedef struct CryptoDevBackendBuiltinSession {
43 QCryptoCipher *cipher;
44 uint8_t direction; /* encryption or decryption */
45 uint8_t type; /* cipher? hash? aead? */
46 QCryptoAkCipher *akcipher;
47 QTAILQ_ENTRY(CryptoDevBackendBuiltinSession) next;
48 } CryptoDevBackendBuiltinSession;
49
50 /* Max number of symmetric/asymmetric sessions */
51 #define MAX_NUM_SESSIONS 256
52
53 #define CRYPTODEV_BUITLIN_MAX_AUTH_KEY_LEN 512
54 #define CRYPTODEV_BUITLIN_MAX_CIPHER_KEY_LEN 64
55
56 struct CryptoDevBackendBuiltin {
57 CryptoDevBackend parent_obj;
58
59 CryptoDevBackendBuiltinSession *sessions[MAX_NUM_SESSIONS];
60 };
61
62 static void cryptodev_builtin_init(
63 CryptoDevBackend *backend, Error **errp)
64 {
65 /* Only support one queue */
66 int queues = backend->conf.peers.queues;
67 CryptoDevBackendClient *cc;
68
69 if (queues != 1) {
70 error_setg(errp,
71 "Only support one queue in cryptdov-builtin backend");
72 return;
73 }
74
75 cc = cryptodev_backend_new_client(
76 "cryptodev-builtin", NULL);
77 cc->info_str = g_strdup_printf("cryptodev-builtin0");
78 cc->queue_index = 0;
79 cc->type = CRYPTODEV_BACKEND_TYPE_BUILTIN;
80 backend->conf.peers.ccs[0] = cc;
81
82 backend->conf.crypto_services =
83 1u << VIRTIO_CRYPTO_SERVICE_CIPHER |
84 1u << VIRTIO_CRYPTO_SERVICE_HASH |
85 1u << VIRTIO_CRYPTO_SERVICE_MAC |
86 1u << VIRTIO_CRYPTO_SERVICE_AKCIPHER;
87 backend->conf.cipher_algo_l = 1u << VIRTIO_CRYPTO_CIPHER_AES_CBC;
88 backend->conf.hash_algo = 1u << VIRTIO_CRYPTO_HASH_SHA1;
89 backend->conf.akcipher_algo = 1u << VIRTIO_CRYPTO_AKCIPHER_RSA;
90 /*
91 * Set the Maximum length of crypto request.
92 * Why this value? Just avoid to overflow when
93 * memory allocation for each crypto request.
94 */
95 backend->conf.max_size = LONG_MAX - sizeof(CryptoDevBackendOpInfo);
96 backend->conf.max_cipher_key_len = CRYPTODEV_BUITLIN_MAX_CIPHER_KEY_LEN;
97 backend->conf.max_auth_key_len = CRYPTODEV_BUITLIN_MAX_AUTH_KEY_LEN;
98
99 cryptodev_backend_set_ready(backend, true);
100 }
101
102 static int
103 cryptodev_builtin_get_unused_session_index(
104 CryptoDevBackendBuiltin *builtin)
105 {
106 size_t i;
107
108 for (i = 0; i < MAX_NUM_SESSIONS; i++) {
109 if (builtin->sessions[i] == NULL) {
110 return i;
111 }
112 }
113
114 return -1;
115 }
116
117 #define AES_KEYSIZE_128 16
118 #define AES_KEYSIZE_192 24
119 #define AES_KEYSIZE_256 32
120 #define AES_KEYSIZE_128_XTS AES_KEYSIZE_256
121 #define AES_KEYSIZE_256_XTS 64
122
123 static int
124 cryptodev_builtin_get_aes_algo(uint32_t key_len, int mode, Error **errp)
125 {
126 int algo;
127
128 if (key_len == AES_KEYSIZE_128) {
129 algo = QCRYPTO_CIPHER_ALG_AES_128;
130 } else if (key_len == AES_KEYSIZE_192) {
131 algo = QCRYPTO_CIPHER_ALG_AES_192;
132 } else if (key_len == AES_KEYSIZE_256) { /* equals AES_KEYSIZE_128_XTS */
133 if (mode == QCRYPTO_CIPHER_MODE_XTS) {
134 algo = QCRYPTO_CIPHER_ALG_AES_128;
135 } else {
136 algo = QCRYPTO_CIPHER_ALG_AES_256;
137 }
138 } else if (key_len == AES_KEYSIZE_256_XTS) {
139 if (mode == QCRYPTO_CIPHER_MODE_XTS) {
140 algo = QCRYPTO_CIPHER_ALG_AES_256;
141 } else {
142 goto err;
143 }
144 } else {
145 goto err;
146 }
147
148 return algo;
149
150 err:
151 error_setg(errp, "Unsupported key length :%u", key_len);
152 return -1;
153 }
154
155 static int cryptodev_builtin_get_rsa_hash_algo(
156 int virtio_rsa_hash, Error **errp)
157 {
158 switch (virtio_rsa_hash) {
159 case VIRTIO_CRYPTO_RSA_MD5:
160 return QCRYPTO_HASH_ALG_MD5;
161
162 case VIRTIO_CRYPTO_RSA_SHA1:
163 return QCRYPTO_HASH_ALG_SHA1;
164
165 case VIRTIO_CRYPTO_RSA_SHA256:
166 return QCRYPTO_HASH_ALG_SHA256;
167
168 case VIRTIO_CRYPTO_RSA_SHA512:
169 return QCRYPTO_HASH_ALG_SHA512;
170
171 default:
172 error_setg(errp, "Unsupported rsa hash algo: %d", virtio_rsa_hash);
173 return -1;
174 }
175 }
176
177 static int cryptodev_builtin_set_rsa_options(
178 int virtio_padding_algo,
179 int virtio_hash_algo,
180 QCryptoAkCipherOptionsRSA *opt,
181 Error **errp)
182 {
183 if (virtio_padding_algo == VIRTIO_CRYPTO_RSA_PKCS1_PADDING) {
184 int hash_alg;
185
186 hash_alg = cryptodev_builtin_get_rsa_hash_algo(virtio_hash_algo, errp);
187 if (hash_alg < 0) {
188 return -1;
189 }
190 opt->hash_alg = hash_alg;
191 opt->padding_alg = QCRYPTO_RSA_PADDING_ALG_PKCS1;
192 return 0;
193 }
194
195 if (virtio_padding_algo == VIRTIO_CRYPTO_RSA_RAW_PADDING) {
196 opt->padding_alg = QCRYPTO_RSA_PADDING_ALG_RAW;
197 return 0;
198 }
199
200 error_setg(errp, "Unsupported rsa padding algo: %d", virtio_padding_algo);
201 return -1;
202 }
203
204 static int cryptodev_builtin_create_cipher_session(
205 CryptoDevBackendBuiltin *builtin,
206 CryptoDevBackendSymSessionInfo *sess_info,
207 Error **errp)
208 {
209 int algo;
210 int mode;
211 QCryptoCipher *cipher;
212 int index;
213 CryptoDevBackendBuiltinSession *sess;
214
215 if (sess_info->op_type != VIRTIO_CRYPTO_SYM_OP_CIPHER) {
216 error_setg(errp, "Unsupported optype :%u", sess_info->op_type);
217 return -1;
218 }
219
220 index = cryptodev_builtin_get_unused_session_index(builtin);
221 if (index < 0) {
222 error_setg(errp, "Total number of sessions created exceeds %u",
223 MAX_NUM_SESSIONS);
224 return -1;
225 }
226
227 switch (sess_info->cipher_alg) {
228 case VIRTIO_CRYPTO_CIPHER_AES_ECB:
229 mode = QCRYPTO_CIPHER_MODE_ECB;
230 algo = cryptodev_builtin_get_aes_algo(sess_info->key_len,
231 mode, errp);
232 if (algo < 0) {
233 return -1;
234 }
235 break;
236 case VIRTIO_CRYPTO_CIPHER_AES_CBC:
237 mode = QCRYPTO_CIPHER_MODE_CBC;
238 algo = cryptodev_builtin_get_aes_algo(sess_info->key_len,
239 mode, errp);
240 if (algo < 0) {
241 return -1;
242 }
243 break;
244 case VIRTIO_CRYPTO_CIPHER_AES_CTR:
245 mode = QCRYPTO_CIPHER_MODE_CTR;
246 algo = cryptodev_builtin_get_aes_algo(sess_info->key_len,
247 mode, errp);
248 if (algo < 0) {
249 return -1;
250 }
251 break;
252 case VIRTIO_CRYPTO_CIPHER_AES_XTS:
253 mode = QCRYPTO_CIPHER_MODE_XTS;
254 algo = cryptodev_builtin_get_aes_algo(sess_info->key_len,
255 mode, errp);
256 if (algo < 0) {
257 return -1;
258 }
259 break;
260 case VIRTIO_CRYPTO_CIPHER_3DES_ECB:
261 mode = QCRYPTO_CIPHER_MODE_ECB;
262 algo = QCRYPTO_CIPHER_ALG_3DES;
263 break;
264 case VIRTIO_CRYPTO_CIPHER_3DES_CBC:
265 mode = QCRYPTO_CIPHER_MODE_CBC;
266 algo = QCRYPTO_CIPHER_ALG_3DES;
267 break;
268 case VIRTIO_CRYPTO_CIPHER_3DES_CTR:
269 mode = QCRYPTO_CIPHER_MODE_CTR;
270 algo = QCRYPTO_CIPHER_ALG_3DES;
271 break;
272 default:
273 error_setg(errp, "Unsupported cipher alg :%u",
274 sess_info->cipher_alg);
275 return -1;
276 }
277
278 cipher = qcrypto_cipher_new(algo, mode,
279 sess_info->cipher_key,
280 sess_info->key_len,
281 errp);
282 if (!cipher) {
283 return -1;
284 }
285
286 sess = g_new0(CryptoDevBackendBuiltinSession, 1);
287 sess->cipher = cipher;
288 sess->direction = sess_info->direction;
289 sess->type = sess_info->op_type;
290
291 builtin->sessions[index] = sess;
292
293 return index;
294 }
295
296 static int cryptodev_builtin_create_akcipher_session(
297 CryptoDevBackendBuiltin *builtin,
298 CryptoDevBackendAsymSessionInfo *sess_info,
299 Error **errp)
300 {
301 CryptoDevBackendBuiltinSession *sess;
302 QCryptoAkCipher *akcipher;
303 int index;
304 QCryptoAkCipherKeyType type;
305 QCryptoAkCipherOptions opts;
306
307 switch (sess_info->algo) {
308 case VIRTIO_CRYPTO_AKCIPHER_RSA:
309 opts.alg = QCRYPTO_AKCIPHER_ALG_RSA;
310 if (cryptodev_builtin_set_rsa_options(sess_info->u.rsa.padding_algo,
311 sess_info->u.rsa.hash_algo, &opts.u.rsa, errp) != 0) {
312 return -1;
313 }
314 break;
315
316 /* TODO support DSA&ECDSA until qemu crypto framework support these */
317
318 default:
319 error_setg(errp, "Unsupported akcipher alg %u", sess_info->algo);
320 return -1;
321 }
322
323 switch (sess_info->keytype) {
324 case VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PUBLIC:
325 type = QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC;
326 break;
327
328 case VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PRIVATE:
329 type = QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE;
330 break;
331
332 default:
333 error_setg(errp, "Unsupported akcipher keytype %u", sess_info->keytype);
334 return -1;
335 }
336
337 index = cryptodev_builtin_get_unused_session_index(builtin);
338 if (index < 0) {
339 error_setg(errp, "Total number of sessions created exceeds %u",
340 MAX_NUM_SESSIONS);
341 return -1;
342 }
343
344 akcipher = qcrypto_akcipher_new(&opts, type, sess_info->key,
345 sess_info->keylen, errp);
346 if (!akcipher) {
347 return -1;
348 }
349
350 sess = g_new0(CryptoDevBackendBuiltinSession, 1);
351 sess->akcipher = akcipher;
352
353 builtin->sessions[index] = sess;
354
355 return index;
356 }
357
358 static int cryptodev_builtin_create_session(
359 CryptoDevBackend *backend,
360 CryptoDevBackendSessionInfo *sess_info,
361 uint32_t queue_index,
362 CryptoDevCompletionFunc cb,
363 void *opaque)
364 {
365 CryptoDevBackendBuiltin *builtin =
366 CRYPTODEV_BACKEND_BUILTIN(backend);
367 CryptoDevBackendSymSessionInfo *sym_sess_info;
368 CryptoDevBackendAsymSessionInfo *asym_sess_info;
369 int ret, status;
370 Error *local_error = NULL;
371
372 switch (sess_info->op_code) {
373 case VIRTIO_CRYPTO_CIPHER_CREATE_SESSION:
374 sym_sess_info = &sess_info->u.sym_sess_info;
375 ret = cryptodev_builtin_create_cipher_session(
376 builtin, sym_sess_info, &local_error);
377 break;
378
379 case VIRTIO_CRYPTO_AKCIPHER_CREATE_SESSION:
380 asym_sess_info = &sess_info->u.asym_sess_info;
381 ret = cryptodev_builtin_create_akcipher_session(
382 builtin, asym_sess_info, &local_error);
383 break;
384
385 case VIRTIO_CRYPTO_HASH_CREATE_SESSION:
386 case VIRTIO_CRYPTO_MAC_CREATE_SESSION:
387 default:
388 error_setg(&local_error, "Unsupported opcode :%" PRIu32 "",
389 sess_info->op_code);
390 return -VIRTIO_CRYPTO_NOTSUPP;
391 }
392
393 if (local_error) {
394 error_report_err(local_error);
395 }
396 if (ret < 0) {
397 status = -VIRTIO_CRYPTO_ERR;
398 } else {
399 sess_info->session_id = ret;
400 status = VIRTIO_CRYPTO_OK;
401 }
402 if (cb) {
403 cb(opaque, status);
404 }
405 return 0;
406 }
407
408 static int cryptodev_builtin_close_session(
409 CryptoDevBackend *backend,
410 uint64_t session_id,
411 uint32_t queue_index,
412 CryptoDevCompletionFunc cb,
413 void *opaque)
414 {
415 CryptoDevBackendBuiltin *builtin =
416 CRYPTODEV_BACKEND_BUILTIN(backend);
417 CryptoDevBackendBuiltinSession *session;
418
419 assert(session_id < MAX_NUM_SESSIONS && builtin->sessions[session_id]);
420
421 session = builtin->sessions[session_id];
422 if (session->cipher) {
423 qcrypto_cipher_free(session->cipher);
424 } else if (session->akcipher) {
425 qcrypto_akcipher_free(session->akcipher);
426 }
427
428 g_free(session);
429 builtin->sessions[session_id] = NULL;
430 if (cb) {
431 cb(opaque, VIRTIO_CRYPTO_OK);
432 }
433 return 0;
434 }
435
436 static int cryptodev_builtin_sym_operation(
437 CryptoDevBackendBuiltinSession *sess,
438 CryptoDevBackendSymOpInfo *op_info, Error **errp)
439 {
440 int ret;
441
442 if (op_info->op_type == VIRTIO_CRYPTO_SYM_OP_ALGORITHM_CHAINING) {
443 error_setg(errp,
444 "Algorithm chain is unsupported for cryptdoev-builtin");
445 return -VIRTIO_CRYPTO_NOTSUPP;
446 }
447
448 if (op_info->iv_len > 0) {
449 ret = qcrypto_cipher_setiv(sess->cipher, op_info->iv,
450 op_info->iv_len, errp);
451 if (ret < 0) {
452 return -VIRTIO_CRYPTO_ERR;
453 }
454 }
455
456 if (sess->direction == VIRTIO_CRYPTO_OP_ENCRYPT) {
457 ret = qcrypto_cipher_encrypt(sess->cipher, op_info->src,
458 op_info->dst, op_info->src_len, errp);
459 if (ret < 0) {
460 return -VIRTIO_CRYPTO_ERR;
461 }
462 } else {
463 ret = qcrypto_cipher_decrypt(sess->cipher, op_info->src,
464 op_info->dst, op_info->src_len, errp);
465 if (ret < 0) {
466 return -VIRTIO_CRYPTO_ERR;
467 }
468 }
469
470 return VIRTIO_CRYPTO_OK;
471 }
472
473 static int cryptodev_builtin_asym_operation(
474 CryptoDevBackendBuiltinSession *sess, uint32_t op_code,
475 CryptoDevBackendAsymOpInfo *op_info, Error **errp)
476 {
477 int ret;
478
479 switch (op_code) {
480 case VIRTIO_CRYPTO_AKCIPHER_ENCRYPT:
481 ret = qcrypto_akcipher_encrypt(sess->akcipher,
482 op_info->src, op_info->src_len,
483 op_info->dst, op_info->dst_len, errp);
484 break;
485
486 case VIRTIO_CRYPTO_AKCIPHER_DECRYPT:
487 ret = qcrypto_akcipher_decrypt(sess->akcipher,
488 op_info->src, op_info->src_len,
489 op_info->dst, op_info->dst_len, errp);
490 break;
491
492 case VIRTIO_CRYPTO_AKCIPHER_SIGN:
493 ret = qcrypto_akcipher_sign(sess->akcipher,
494 op_info->src, op_info->src_len,
495 op_info->dst, op_info->dst_len, errp);
496 break;
497
498 case VIRTIO_CRYPTO_AKCIPHER_VERIFY:
499 ret = qcrypto_akcipher_verify(sess->akcipher,
500 op_info->src, op_info->src_len,
501 op_info->dst, op_info->dst_len, errp);
502 break;
503
504 default:
505 return -VIRTIO_CRYPTO_ERR;
506 }
507
508 if (ret < 0) {
509 if (op_code == VIRTIO_CRYPTO_AKCIPHER_VERIFY) {
510 return -VIRTIO_CRYPTO_KEY_REJECTED;
511 }
512 return -VIRTIO_CRYPTO_ERR;
513 }
514
515 /* Buffer is too short, typically the driver should handle this case */
516 if (unlikely(ret > op_info->dst_len)) {
517 if (errp && !*errp) {
518 error_setg(errp, "dst buffer too short");
519 }
520
521 return -VIRTIO_CRYPTO_ERR;
522 }
523
524 op_info->dst_len = ret;
525
526 return VIRTIO_CRYPTO_OK;
527 }
528
529 static int cryptodev_builtin_operation(
530 CryptoDevBackend *backend,
531 CryptoDevBackendOpInfo *op_info,
532 uint32_t queue_index,
533 CryptoDevCompletionFunc cb,
534 void *opaque)
535 {
536 CryptoDevBackendBuiltin *builtin =
537 CRYPTODEV_BACKEND_BUILTIN(backend);
538 CryptoDevBackendBuiltinSession *sess;
539 CryptoDevBackendSymOpInfo *sym_op_info;
540 CryptoDevBackendAsymOpInfo *asym_op_info;
541 enum CryptoDevBackendAlgType algtype = op_info->algtype;
542 int status = -VIRTIO_CRYPTO_ERR;
543 Error *local_error = NULL;
544
545 if (op_info->session_id >= MAX_NUM_SESSIONS ||
546 builtin->sessions[op_info->session_id] == NULL) {
547 error_setg(&local_error, "Cannot find a valid session id: %" PRIu64 "",
548 op_info->session_id);
549 return -VIRTIO_CRYPTO_INVSESS;
550 }
551
552 sess = builtin->sessions[op_info->session_id];
553 if (algtype == CRYPTODEV_BACKEND_ALG_SYM) {
554 sym_op_info = op_info->u.sym_op_info;
555 status = cryptodev_builtin_sym_operation(sess, sym_op_info,
556 &local_error);
557 } else if (algtype == CRYPTODEV_BACKEND_ALG_ASYM) {
558 asym_op_info = op_info->u.asym_op_info;
559 status = cryptodev_builtin_asym_operation(sess, op_info->op_code,
560 asym_op_info, &local_error);
561 }
562
563 if (local_error) {
564 error_report_err(local_error);
565 }
566 if (cb) {
567 cb(opaque, status);
568 }
569 return 0;
570 }
571
572 static void cryptodev_builtin_cleanup(
573 CryptoDevBackend *backend,
574 Error **errp)
575 {
576 CryptoDevBackendBuiltin *builtin =
577 CRYPTODEV_BACKEND_BUILTIN(backend);
578 size_t i;
579 int queues = backend->conf.peers.queues;
580 CryptoDevBackendClient *cc;
581
582 for (i = 0; i < MAX_NUM_SESSIONS; i++) {
583 if (builtin->sessions[i] != NULL) {
584 cryptodev_builtin_close_session(backend, i, 0, NULL, NULL);
585 }
586 }
587
588 for (i = 0; i < queues; i++) {
589 cc = backend->conf.peers.ccs[i];
590 if (cc) {
591 cryptodev_backend_free_client(cc);
592 backend->conf.peers.ccs[i] = NULL;
593 }
594 }
595
596 cryptodev_backend_set_ready(backend, false);
597 }
598
599 static void
600 cryptodev_builtin_class_init(ObjectClass *oc, void *data)
601 {
602 CryptoDevBackendClass *bc = CRYPTODEV_BACKEND_CLASS(oc);
603
604 bc->init = cryptodev_builtin_init;
605 bc->cleanup = cryptodev_builtin_cleanup;
606 bc->create_session = cryptodev_builtin_create_session;
607 bc->close_session = cryptodev_builtin_close_session;
608 bc->do_op = cryptodev_builtin_operation;
609 }
610
611 static const TypeInfo cryptodev_builtin_info = {
612 .name = TYPE_CRYPTODEV_BACKEND_BUILTIN,
613 .parent = TYPE_CRYPTODEV_BACKEND,
614 .class_init = cryptodev_builtin_class_init,
615 .instance_size = sizeof(CryptoDevBackendBuiltin),
616 };
617
618 static void
619 cryptodev_builtin_register_types(void)
620 {
621 type_register_static(&cryptodev_builtin_info);
622 }
623
624 type_init(cryptodev_builtin_register_types);