akcipher-nettle.c.inc (13444B)
1 /* 2 * QEMU Crypto akcipher algorithms 3 * 4 * Copyright (c) 2022 Bytedance 5 * Author: lei he <helei.sig11@bytedance.com> 6 * 7 * This library is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * This library is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with this library; if not, see <http://www.gnu.org/licenses/>. 19 * 20 */ 21 22 #include <nettle/rsa.h> 23 24 #include "qemu/osdep.h" 25 #include "qemu/host-utils.h" 26 #include "crypto/akcipher.h" 27 #include "crypto/random.h" 28 #include "qapi/error.h" 29 #include "sysemu/cryptodev.h" 30 #include "rsakey.h" 31 32 typedef struct QCryptoNettleRSA { 33 QCryptoAkCipher akcipher; 34 struct rsa_public_key pub; 35 struct rsa_private_key priv; 36 QCryptoRSAPaddingAlgorithm padding_alg; 37 QCryptoHashAlgorithm hash_alg; 38 } QCryptoNettleRSA; 39 40 static void qcrypto_nettle_rsa_free(QCryptoAkCipher *akcipher) 41 { 42 QCryptoNettleRSA *rsa = (QCryptoNettleRSA *)akcipher; 43 if (!rsa) { 44 return; 45 } 46 47 rsa_public_key_clear(&rsa->pub); 48 rsa_private_key_clear(&rsa->priv); 49 g_free(rsa); 50 } 51 52 static QCryptoAkCipher *qcrypto_nettle_rsa_new( 53 const QCryptoAkCipherOptionsRSA *opt, 54 QCryptoAkCipherKeyType type, 55 const uint8_t *key, size_t keylen, 56 Error **errp); 57 58 QCryptoAkCipher *qcrypto_akcipher_new(const QCryptoAkCipherOptions *opts, 59 QCryptoAkCipherKeyType type, 60 const uint8_t *key, size_t keylen, 61 Error **errp) 62 { 63 switch (opts->alg) { 64 case QCRYPTO_AKCIPHER_ALG_RSA: 65 return qcrypto_nettle_rsa_new(&opts->u.rsa, type, key, keylen, errp); 66 67 default: 68 error_setg(errp, "Unsupported algorithm: %u", opts->alg); 69 return NULL; 70 } 71 72 return NULL; 73 } 74 75 static void qcrypto_nettle_rsa_set_akcipher_size(QCryptoAkCipher *akcipher, 76 int key_size) 77 { 78 akcipher->max_plaintext_len = key_size; 79 akcipher->max_ciphertext_len = key_size; 80 akcipher->max_signature_len = key_size; 81 akcipher->max_dgst_len = key_size; 82 } 83 84 static int qcrypt_nettle_parse_rsa_private_key(QCryptoNettleRSA *rsa, 85 const uint8_t *key, 86 size_t keylen, 87 Error **errp) 88 { 89 g_autoptr(QCryptoAkCipherRSAKey) rsa_key = qcrypto_akcipher_rsakey_parse( 90 QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE, key, keylen, errp); 91 92 if (!rsa_key) { 93 return -1; 94 } 95 96 nettle_mpz_init_set_str_256_u(rsa->pub.n, rsa_key->n.len, rsa_key->n.data); 97 nettle_mpz_init_set_str_256_u(rsa->pub.e, rsa_key->e.len, rsa_key->e.data); 98 nettle_mpz_init_set_str_256_u(rsa->priv.d, rsa_key->d.len, rsa_key->d.data); 99 nettle_mpz_init_set_str_256_u(rsa->priv.p, rsa_key->p.len, rsa_key->p.data); 100 nettle_mpz_init_set_str_256_u(rsa->priv.q, rsa_key->q.len, rsa_key->q.data); 101 nettle_mpz_init_set_str_256_u(rsa->priv.a, rsa_key->dp.len, 102 rsa_key->dp.data); 103 nettle_mpz_init_set_str_256_u(rsa->priv.b, rsa_key->dq.len, 104 rsa_key->dq.data); 105 nettle_mpz_init_set_str_256_u(rsa->priv.c, rsa_key->u.len, rsa_key->u.data); 106 107 if (!rsa_public_key_prepare(&rsa->pub)) { 108 error_setg(errp, "Failed to check RSA key"); 109 return -1; 110 } 111 112 /** 113 * Since in the kernel's unit test, the p, q, a, b, c of some 114 * private keys is 0, only the simplest length check is done here 115 */ 116 if (rsa_key->p.len > 1 && 117 rsa_key->q.len > 1 && 118 rsa_key->dp.len > 1 && 119 rsa_key->dq.len > 1 && 120 rsa_key->u.len > 1) { 121 if (!rsa_private_key_prepare(&rsa->priv)) { 122 error_setg(errp, "Failed to check RSA key"); 123 return -1; 124 } 125 } else { 126 rsa->priv.size = rsa->pub.size; 127 } 128 qcrypto_nettle_rsa_set_akcipher_size( 129 (QCryptoAkCipher *)rsa, rsa->priv.size); 130 131 return 0; 132 } 133 134 static int qcrypt_nettle_parse_rsa_public_key(QCryptoNettleRSA *rsa, 135 const uint8_t *key, 136 size_t keylen, 137 Error **errp) 138 { 139 g_autoptr(QCryptoAkCipherRSAKey) rsa_key = qcrypto_akcipher_rsakey_parse( 140 QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC, key, keylen, errp); 141 142 if (!rsa_key) { 143 return -1; 144 } 145 nettle_mpz_init_set_str_256_u(rsa->pub.n, rsa_key->n.len, rsa_key->n.data); 146 nettle_mpz_init_set_str_256_u(rsa->pub.e, rsa_key->e.len, rsa_key->e.data); 147 148 if (!rsa_public_key_prepare(&rsa->pub)) { 149 error_setg(errp, "Failed to check RSA key"); 150 return -1; 151 } 152 qcrypto_nettle_rsa_set_akcipher_size( 153 (QCryptoAkCipher *)rsa, rsa->pub.size); 154 155 return 0; 156 } 157 158 static void wrap_nettle_random_func(void *ctx, size_t len, uint8_t *out) 159 { 160 qcrypto_random_bytes(out, len, &error_abort); 161 } 162 163 static int qcrypto_nettle_rsa_encrypt(QCryptoAkCipher *akcipher, 164 const void *data, size_t data_len, 165 void *enc, size_t enc_len, 166 Error **errp) 167 { 168 169 QCryptoNettleRSA *rsa = (QCryptoNettleRSA *)akcipher; 170 mpz_t c; 171 int ret = -1; 172 173 if (data_len > rsa->pub.size) { 174 error_setg(errp, "Plaintext length %zu is greater than key size: %zu", 175 data_len, rsa->pub.size); 176 return ret; 177 } 178 179 if (enc_len < rsa->pub.size) { 180 error_setg(errp, "Ciphertext buffer length %zu is less than " 181 "key size: %zu", enc_len, rsa->pub.size); 182 return ret; 183 } 184 185 /* Nettle do not support RSA encryption without any padding */ 186 switch (rsa->padding_alg) { 187 case QCRYPTO_RSA_PADDING_ALG_RAW: 188 error_setg(errp, "RSA with raw padding is not supported"); 189 break; 190 191 case QCRYPTO_RSA_PADDING_ALG_PKCS1: 192 mpz_init(c); 193 if (rsa_encrypt(&rsa->pub, NULL, wrap_nettle_random_func, 194 data_len, (uint8_t *)data, c) != 1) { 195 error_setg(errp, "Failed to encrypt"); 196 } else { 197 nettle_mpz_get_str_256(enc_len, (uint8_t *)enc, c); 198 ret = nettle_mpz_sizeinbase_256_u(c); 199 } 200 mpz_clear(c); 201 break; 202 203 default: 204 error_setg(errp, "Unknown padding"); 205 } 206 207 return ret; 208 } 209 210 static int qcrypto_nettle_rsa_decrypt(QCryptoAkCipher *akcipher, 211 const void *enc, size_t enc_len, 212 void *data, size_t data_len, 213 Error **errp) 214 { 215 QCryptoNettleRSA *rsa = (QCryptoNettleRSA *)akcipher; 216 mpz_t c; 217 int ret = -1; 218 219 if (enc_len > rsa->priv.size) { 220 error_setg(errp, "Ciphertext length %zu is greater than key size: %zu", 221 enc_len, rsa->priv.size); 222 return ret; 223 } 224 225 switch (rsa->padding_alg) { 226 case QCRYPTO_RSA_PADDING_ALG_RAW: 227 error_setg(errp, "RSA with raw padding is not supported"); 228 break; 229 230 case QCRYPTO_RSA_PADDING_ALG_PKCS1: 231 nettle_mpz_init_set_str_256_u(c, enc_len, enc); 232 if (!rsa_decrypt(&rsa->priv, &data_len, (uint8_t *)data, c)) { 233 error_setg(errp, "Failed to decrypt"); 234 } else { 235 ret = data_len; 236 } 237 238 mpz_clear(c); 239 break; 240 241 default: 242 error_setg(errp, "Unknown padding algorithm: %d", rsa->padding_alg); 243 } 244 245 return ret; 246 } 247 248 static int qcrypto_nettle_rsa_sign(QCryptoAkCipher *akcipher, 249 const void *data, size_t data_len, 250 void *sig, size_t sig_len, Error **errp) 251 { 252 QCryptoNettleRSA *rsa = (QCryptoNettleRSA *)akcipher; 253 int ret = -1, rv; 254 mpz_t s; 255 256 /** 257 * The RSA algorithm cannot be used for signature/verification 258 * without padding. 259 */ 260 if (rsa->padding_alg == QCRYPTO_RSA_PADDING_ALG_RAW) { 261 error_setg(errp, "Try to make signature without padding"); 262 return ret; 263 } 264 265 if (data_len > rsa->priv.size) { 266 error_setg(errp, "Data length %zu is greater than key size: %zu", 267 data_len, rsa->priv.size); 268 return ret; 269 } 270 271 if (sig_len < rsa->priv.size) { 272 error_setg(errp, "Signature buffer length %zu is less than " 273 "key size: %zu", sig_len, rsa->priv.size); 274 return ret; 275 } 276 277 mpz_init(s); 278 switch (rsa->hash_alg) { 279 case QCRYPTO_HASH_ALG_MD5: 280 rv = rsa_md5_sign_digest(&rsa->priv, data, s); 281 break; 282 283 case QCRYPTO_HASH_ALG_SHA1: 284 rv = rsa_sha1_sign_digest(&rsa->priv, data, s); 285 break; 286 287 case QCRYPTO_HASH_ALG_SHA256: 288 rv = rsa_sha256_sign_digest(&rsa->priv, data, s); 289 break; 290 291 case QCRYPTO_HASH_ALG_SHA512: 292 rv = rsa_sha512_sign_digest(&rsa->priv, data, s); 293 break; 294 295 default: 296 error_setg(errp, "Unknown hash algorithm: %d", rsa->hash_alg); 297 goto cleanup; 298 } 299 300 if (rv != 1) { 301 error_setg(errp, "Failed to make signature"); 302 goto cleanup; 303 } 304 nettle_mpz_get_str_256(sig_len, (uint8_t *)sig, s); 305 ret = nettle_mpz_sizeinbase_256_u(s); 306 307 cleanup: 308 mpz_clear(s); 309 310 return ret; 311 } 312 313 static int qcrypto_nettle_rsa_verify(QCryptoAkCipher *akcipher, 314 const void *sig, size_t sig_len, 315 const void *data, size_t data_len, 316 Error **errp) 317 { 318 QCryptoNettleRSA *rsa = (QCryptoNettleRSA *)akcipher; 319 320 int ret = -1, rv; 321 mpz_t s; 322 323 /** 324 * The RSA algorithm cannot be used for signature/verification 325 * without padding. 326 */ 327 if (rsa->padding_alg == QCRYPTO_RSA_PADDING_ALG_RAW) { 328 error_setg(errp, "Try to verify signature without padding"); 329 return ret; 330 } 331 if (data_len > rsa->pub.size) { 332 error_setg(errp, "Data length %zu is greater than key size: %zu", 333 data_len, rsa->pub.size); 334 return ret; 335 } 336 if (sig_len < rsa->pub.size) { 337 error_setg(errp, "Signature length %zu is greater than key size: %zu", 338 sig_len, rsa->pub.size); 339 return ret; 340 } 341 342 nettle_mpz_init_set_str_256_u(s, sig_len, sig); 343 switch (rsa->hash_alg) { 344 case QCRYPTO_HASH_ALG_MD5: 345 rv = rsa_md5_verify_digest(&rsa->pub, data, s); 346 break; 347 348 case QCRYPTO_HASH_ALG_SHA1: 349 rv = rsa_sha1_verify_digest(&rsa->pub, data, s); 350 break; 351 352 case QCRYPTO_HASH_ALG_SHA256: 353 rv = rsa_sha256_verify_digest(&rsa->pub, data, s); 354 break; 355 356 case QCRYPTO_HASH_ALG_SHA512: 357 rv = rsa_sha512_verify_digest(&rsa->pub, data, s); 358 break; 359 360 default: 361 error_setg(errp, "Unsupported hash algorithm: %d", rsa->hash_alg); 362 goto cleanup; 363 } 364 365 if (rv != 1) { 366 error_setg(errp, "Failed to verify signature"); 367 goto cleanup; 368 } 369 ret = 0; 370 371 cleanup: 372 mpz_clear(s); 373 374 return ret; 375 } 376 377 QCryptoAkCipherDriver nettle_rsa = { 378 .encrypt = qcrypto_nettle_rsa_encrypt, 379 .decrypt = qcrypto_nettle_rsa_decrypt, 380 .sign = qcrypto_nettle_rsa_sign, 381 .verify = qcrypto_nettle_rsa_verify, 382 .free = qcrypto_nettle_rsa_free, 383 }; 384 385 static QCryptoAkCipher *qcrypto_nettle_rsa_new( 386 const QCryptoAkCipherOptionsRSA *opt, 387 QCryptoAkCipherKeyType type, 388 const uint8_t *key, size_t keylen, 389 Error **errp) 390 { 391 QCryptoNettleRSA *rsa = g_new0(QCryptoNettleRSA, 1); 392 393 rsa->padding_alg = opt->padding_alg; 394 rsa->hash_alg = opt->hash_alg; 395 rsa->akcipher.driver = &nettle_rsa; 396 rsa_public_key_init(&rsa->pub); 397 rsa_private_key_init(&rsa->priv); 398 399 switch (type) { 400 case QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE: 401 if (qcrypt_nettle_parse_rsa_private_key(rsa, key, keylen, errp) != 0) { 402 goto error; 403 } 404 break; 405 406 case QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC: 407 if (qcrypt_nettle_parse_rsa_public_key(rsa, key, keylen, errp) != 0) { 408 goto error; 409 } 410 break; 411 412 default: 413 error_setg(errp, "Unknown akcipher key type %d", type); 414 goto error; 415 } 416 417 return (QCryptoAkCipher *)rsa; 418 419 error: 420 qcrypto_nettle_rsa_free((QCryptoAkCipher *)rsa); 421 return NULL; 422 } 423 424 425 bool qcrypto_akcipher_supports(QCryptoAkCipherOptions *opts) 426 { 427 switch (opts->alg) { 428 case QCRYPTO_AKCIPHER_ALG_RSA: 429 switch (opts->u.rsa.padding_alg) { 430 case QCRYPTO_RSA_PADDING_ALG_PKCS1: 431 switch (opts->u.rsa.hash_alg) { 432 case QCRYPTO_HASH_ALG_MD5: 433 case QCRYPTO_HASH_ALG_SHA1: 434 case QCRYPTO_HASH_ALG_SHA256: 435 case QCRYPTO_HASH_ALG_SHA512: 436 return true; 437 438 default: 439 return false; 440 } 441 442 case QCRYPTO_RSA_PADDING_ALG_RAW: 443 default: 444 return false; 445 } 446 break; 447 448 default: 449 return false; 450 } 451 }