cryptodev-builtin.c (19008B)
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);