1 /* 2 * Wrapper functions for crypto libraries 3 * Copyright (c) 2004-2017, Jouni Malinen <j@w1.fi> 4 * 5 * This software may be distributed under the terms of the BSD license. 6 * See README for more details. 7 * 8 * This file defines the cryptographic functions that need to be implemented 9 * for wpa_supplicant and hostapd. When TLS is not used, internal 10 * implementation of MD5, SHA1, and AES is used and no external libraries are 11 * required. When TLS is enabled (e.g., by enabling EAP-TLS or EAP-PEAP), the 12 * crypto library used by the TLS implementation is expected to be used for 13 * non-TLS needs, too, in order to save space by not implementing these 14 * functions twice. 15 * 16 * Wrapper code for using each crypto library is in its own file (crypto*.c) 17 * and one of these files is build and linked in to provide the functions 18 * defined here. 19 */ 20 21 #ifndef CRYPTO_H 22 #define CRYPTO_H 23 24 /** 25 * md4_vector - MD4 hash for data vector 26 * @num_elem: Number of elements in the data vector 27 * @addr: Pointers to the data areas 28 * @len: Lengths of the data blocks 29 * @mac: Buffer for the hash 30 * Returns: 0 on success, -1 on failure 31 */ 32 int md4_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac); 33 34 /** 35 * md5_vector - MD5 hash for data vector 36 * @num_elem: Number of elements in the data vector 37 * @addr: Pointers to the data areas 38 * @len: Lengths of the data blocks 39 * @mac: Buffer for the hash 40 * Returns: 0 on success, -1 on failure 41 */ 42 int md5_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac); 43 44 45 /** 46 * sha1_vector - SHA-1 hash for data vector 47 * @num_elem: Number of elements in the data vector 48 * @addr: Pointers to the data areas 49 * @len: Lengths of the data blocks 50 * @mac: Buffer for the hash 51 * Returns: 0 on success, -1 on failure 52 */ 53 int sha1_vector(size_t num_elem, const u8 *addr[], const size_t *len, 54 u8 *mac); 55 56 /** 57 * fips186_2-prf - NIST FIPS Publication 186-2 change notice 1 PRF 58 * @seed: Seed/key for the PRF 59 * @seed_len: Seed length in bytes 60 * @x: Buffer for PRF output 61 * @xlen: Output length in bytes 62 * Returns: 0 on success, -1 on failure 63 * 64 * This function implements random number generation specified in NIST FIPS 65 * Publication 186-2 for EAP-SIM. This PRF uses a function that is similar to 66 * SHA-1, but has different message padding. 67 */ 68 int __must_check fips186_2_prf(const u8 *seed, size_t seed_len, u8 *x, 69 size_t xlen); 70 71 /** 72 * sha256_vector - SHA256 hash for data vector 73 * @num_elem: Number of elements in the data vector 74 * @addr: Pointers to the data areas 75 * @len: Lengths of the data blocks 76 * @mac: Buffer for the hash 77 * Returns: 0 on success, -1 on failure 78 */ 79 int sha256_vector(size_t num_elem, const u8 *addr[], const size_t *len, 80 u8 *mac); 81 82 /** 83 * sha384_vector - SHA384 hash for data vector 84 * @num_elem: Number of elements in the data vector 85 * @addr: Pointers to the data areas 86 * @len: Lengths of the data blocks 87 * @mac: Buffer for the hash 88 * Returns: 0 on success, -1 on failure 89 */ 90 int sha384_vector(size_t num_elem, const u8 *addr[], const size_t *len, 91 u8 *mac); 92 93 /** 94 * sha512_vector - SHA512 hash for data vector 95 * @num_elem: Number of elements in the data vector 96 * @addr: Pointers to the data areas 97 * @len: Lengths of the data blocks 98 * @mac: Buffer for the hash 99 * Returns: 0 on success, -1 on failure 100 */ 101 int sha512_vector(size_t num_elem, const u8 *addr[], const size_t *len, 102 u8 *mac); 103 104 /** 105 * des_encrypt - Encrypt one block with DES 106 * @clear: 8 octets (in) 107 * @key: 7 octets (in) (no parity bits included) 108 * @cypher: 8 octets (out) 109 * Returns: 0 on success, -1 on failure 110 */ 111 int des_encrypt(const u8 *clear, const u8 *key, u8 *cypher); 112 113 /** 114 * aes_encrypt_init - Initialize AES for encryption 115 * @key: Encryption key 116 * @len: Key length in bytes (usually 16, i.e., 128 bits) 117 * Returns: Pointer to context data or %NULL on failure 118 */ 119 void * aes_encrypt_init(const u8 *key, size_t len); 120 121 /** 122 * aes_encrypt - Encrypt one AES block 123 * @ctx: Context pointer from aes_encrypt_init() 124 * @plain: Plaintext data to be encrypted (16 bytes) 125 * @crypt: Buffer for the encrypted data (16 bytes) 126 * Returns: 0 on success, -1 on failure 127 */ 128 int aes_encrypt(void *ctx, const u8 *plain, u8 *crypt); 129 130 /** 131 * aes_encrypt_deinit - Deinitialize AES encryption 132 * @ctx: Context pointer from aes_encrypt_init() 133 */ 134 void aes_encrypt_deinit(void *ctx); 135 136 /** 137 * aes_decrypt_init - Initialize AES for decryption 138 * @key: Decryption key 139 * @len: Key length in bytes (usually 16, i.e., 128 bits) 140 * Returns: Pointer to context data or %NULL on failure 141 */ 142 void * aes_decrypt_init(const u8 *key, size_t len); 143 144 /** 145 * aes_decrypt - Decrypt one AES block 146 * @ctx: Context pointer from aes_encrypt_init() 147 * @crypt: Encrypted data (16 bytes) 148 * @plain: Buffer for the decrypted data (16 bytes) 149 * Returns: 0 on success, -1 on failure 150 */ 151 int aes_decrypt(void *ctx, const u8 *crypt, u8 *plain); 152 153 /** 154 * aes_decrypt_deinit - Deinitialize AES decryption 155 * @ctx: Context pointer from aes_encrypt_init() 156 */ 157 void aes_decrypt_deinit(void *ctx); 158 159 160 enum crypto_hash_alg { 161 CRYPTO_HASH_ALG_MD5, CRYPTO_HASH_ALG_SHA1, 162 CRYPTO_HASH_ALG_HMAC_MD5, CRYPTO_HASH_ALG_HMAC_SHA1, 163 CRYPTO_HASH_ALG_SHA256, CRYPTO_HASH_ALG_HMAC_SHA256, 164 CRYPTO_HASH_ALG_SHA384, CRYPTO_HASH_ALG_SHA512 165 }; 166 167 struct crypto_hash; 168 169 /** 170 * crypto_hash_init - Initialize hash/HMAC function 171 * @alg: Hash algorithm 172 * @key: Key for keyed hash (e.g., HMAC) or %NULL if not needed 173 * @key_len: Length of the key in bytes 174 * Returns: Pointer to hash context to use with other hash functions or %NULL 175 * on failure 176 * 177 * This function is only used with internal TLSv1 implementation 178 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 179 * to implement this. 180 */ 181 struct crypto_hash * crypto_hash_init(enum crypto_hash_alg alg, const u8 *key, 182 size_t key_len); 183 184 /** 185 * crypto_hash_update - Add data to hash calculation 186 * @ctx: Context pointer from crypto_hash_init() 187 * @data: Data buffer to add 188 * @len: Length of the buffer 189 * 190 * This function is only used with internal TLSv1 implementation 191 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 192 * to implement this. 193 */ 194 void crypto_hash_update(struct crypto_hash *ctx, const u8 *data, size_t len); 195 196 /** 197 * crypto_hash_finish - Complete hash calculation 198 * @ctx: Context pointer from crypto_hash_init() 199 * @hash: Buffer for hash value or %NULL if caller is just freeing the hash 200 * context 201 * @len: Pointer to length of the buffer or %NULL if caller is just freeing the 202 * hash context; on return, this is set to the actual length of the hash value 203 * Returns: 0 on success, -1 if buffer is too small (len set to needed length), 204 * or -2 on other failures (including failed crypto_hash_update() operations) 205 * 206 * This function calculates the hash value and frees the context buffer that 207 * was used for hash calculation. 208 * 209 * This function is only used with internal TLSv1 implementation 210 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 211 * to implement this. 212 */ 213 int crypto_hash_finish(struct crypto_hash *ctx, u8 *hash, size_t *len); 214 215 216 enum crypto_cipher_alg { 217 CRYPTO_CIPHER_NULL = 0, CRYPTO_CIPHER_ALG_AES, CRYPTO_CIPHER_ALG_3DES, 218 CRYPTO_CIPHER_ALG_DES, CRYPTO_CIPHER_ALG_RC2, CRYPTO_CIPHER_ALG_RC4 219 }; 220 221 struct crypto_cipher; 222 223 /** 224 * crypto_cipher_init - Initialize block/stream cipher function 225 * @alg: Cipher algorithm 226 * @iv: Initialization vector for block ciphers or %NULL for stream ciphers 227 * @key: Cipher key 228 * @key_len: Length of key in bytes 229 * Returns: Pointer to cipher context to use with other cipher functions or 230 * %NULL on failure 231 * 232 * This function is only used with internal TLSv1 implementation 233 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 234 * to implement this. 235 */ 236 struct crypto_cipher * crypto_cipher_init(enum crypto_cipher_alg alg, 237 const u8 *iv, const u8 *key, 238 size_t key_len); 239 240 /** 241 * crypto_cipher_encrypt - Cipher encrypt 242 * @ctx: Context pointer from crypto_cipher_init() 243 * @plain: Plaintext to cipher 244 * @crypt: Resulting ciphertext 245 * @len: Length of the plaintext 246 * Returns: 0 on success, -1 on failure 247 * 248 * This function is only used with internal TLSv1 implementation 249 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 250 * to implement this. 251 */ 252 int __must_check crypto_cipher_encrypt(struct crypto_cipher *ctx, 253 const u8 *plain, u8 *crypt, size_t len); 254 255 /** 256 * crypto_cipher_decrypt - Cipher decrypt 257 * @ctx: Context pointer from crypto_cipher_init() 258 * @crypt: Ciphertext to decrypt 259 * @plain: Resulting plaintext 260 * @len: Length of the cipher text 261 * Returns: 0 on success, -1 on failure 262 * 263 * This function is only used with internal TLSv1 implementation 264 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 265 * to implement this. 266 */ 267 int __must_check crypto_cipher_decrypt(struct crypto_cipher *ctx, 268 const u8 *crypt, u8 *plain, size_t len); 269 270 /** 271 * crypto_cipher_decrypt - Free cipher context 272 * @ctx: Context pointer from crypto_cipher_init() 273 * 274 * This function is only used with internal TLSv1 implementation 275 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 276 * to implement this. 277 */ 278 void crypto_cipher_deinit(struct crypto_cipher *ctx); 279 280 281 struct crypto_public_key; 282 struct crypto_private_key; 283 284 /** 285 * crypto_public_key_import - Import an RSA public key 286 * @key: Key buffer (DER encoded RSA public key) 287 * @len: Key buffer length in bytes 288 * Returns: Pointer to the public key or %NULL on failure 289 * 290 * This function can just return %NULL if the crypto library supports X.509 291 * parsing. In that case, crypto_public_key_from_cert() is used to import the 292 * public key from a certificate. 293 * 294 * This function is only used with internal TLSv1 implementation 295 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 296 * to implement this. 297 */ 298 struct crypto_public_key * crypto_public_key_import(const u8 *key, size_t len); 299 300 struct crypto_public_key * 301 crypto_public_key_import_parts(const u8 *n, size_t n_len, 302 const u8 *e, size_t e_len); 303 304 /** 305 * crypto_private_key_import - Import an RSA private key 306 * @key: Key buffer (DER encoded RSA private key) 307 * @len: Key buffer length in bytes 308 * @passwd: Key encryption password or %NULL if key is not encrypted 309 * Returns: Pointer to the private key or %NULL on failure 310 * 311 * This function is only used with internal TLSv1 implementation 312 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 313 * to implement this. 314 */ 315 struct crypto_private_key * crypto_private_key_import(const u8 *key, 316 size_t len, 317 const char *passwd); 318 319 /** 320 * crypto_public_key_from_cert - Import an RSA public key from a certificate 321 * @buf: DER encoded X.509 certificate 322 * @len: Certificate buffer length in bytes 323 * Returns: Pointer to public key or %NULL on failure 324 * 325 * This function can just return %NULL if the crypto library does not support 326 * X.509 parsing. In that case, internal code will be used to parse the 327 * certificate and public key is imported using crypto_public_key_import(). 328 * 329 * This function is only used with internal TLSv1 implementation 330 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 331 * to implement this. 332 */ 333 struct crypto_public_key * crypto_public_key_from_cert(const u8 *buf, 334 size_t len); 335 336 /** 337 * crypto_public_key_encrypt_pkcs1_v15 - Public key encryption (PKCS #1 v1.5) 338 * @key: Public key 339 * @in: Plaintext buffer 340 * @inlen: Length of plaintext buffer in bytes 341 * @out: Output buffer for encrypted data 342 * @outlen: Length of output buffer in bytes; set to used length on success 343 * Returns: 0 on success, -1 on failure 344 * 345 * This function is only used with internal TLSv1 implementation 346 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 347 * to implement this. 348 */ 349 int __must_check crypto_public_key_encrypt_pkcs1_v15( 350 struct crypto_public_key *key, const u8 *in, size_t inlen, 351 u8 *out, size_t *outlen); 352 353 /** 354 * crypto_private_key_decrypt_pkcs1_v15 - Private key decryption (PKCS #1 v1.5) 355 * @key: Private key 356 * @in: Encrypted buffer 357 * @inlen: Length of encrypted buffer in bytes 358 * @out: Output buffer for encrypted data 359 * @outlen: Length of output buffer in bytes; set to used length on success 360 * Returns: 0 on success, -1 on failure 361 * 362 * This function is only used with internal TLSv1 implementation 363 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 364 * to implement this. 365 */ 366 int __must_check crypto_private_key_decrypt_pkcs1_v15( 367 struct crypto_private_key *key, const u8 *in, size_t inlen, 368 u8 *out, size_t *outlen); 369 370 /** 371 * crypto_private_key_sign_pkcs1 - Sign with private key (PKCS #1) 372 * @key: Private key from crypto_private_key_import() 373 * @in: Plaintext buffer 374 * @inlen: Length of plaintext buffer in bytes 375 * @out: Output buffer for encrypted (signed) data 376 * @outlen: Length of output buffer in bytes; set to used length on success 377 * Returns: 0 on success, -1 on failure 378 * 379 * This function is only used with internal TLSv1 implementation 380 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 381 * to implement this. 382 */ 383 int __must_check crypto_private_key_sign_pkcs1(struct crypto_private_key *key, 384 const u8 *in, size_t inlen, 385 u8 *out, size_t *outlen); 386 387 /** 388 * crypto_public_key_free - Free public key 389 * @key: Public key 390 * 391 * This function is only used with internal TLSv1 implementation 392 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 393 * to implement this. 394 */ 395 void crypto_public_key_free(struct crypto_public_key *key); 396 397 /** 398 * crypto_private_key_free - Free private key 399 * @key: Private key from crypto_private_key_import() 400 * 401 * This function is only used with internal TLSv1 implementation 402 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 403 * to implement this. 404 */ 405 void crypto_private_key_free(struct crypto_private_key *key); 406 407 /** 408 * crypto_public_key_decrypt_pkcs1 - Decrypt PKCS #1 signature 409 * @key: Public key 410 * @crypt: Encrypted signature data (using the private key) 411 * @crypt_len: Encrypted signature data length 412 * @plain: Buffer for plaintext (at least crypt_len bytes) 413 * @plain_len: Plaintext length (max buffer size on input, real len on output); 414 * Returns: 0 on success, -1 on failure 415 */ 416 int __must_check crypto_public_key_decrypt_pkcs1( 417 struct crypto_public_key *key, const u8 *crypt, size_t crypt_len, 418 u8 *plain, size_t *plain_len); 419 420 int crypto_dh_init(u8 generator, const u8 *prime, size_t prime_len, u8 *privkey, 421 u8 *pubkey); 422 int crypto_dh_derive_secret(u8 generator, const u8 *prime, size_t prime_len, 423 const u8 *order, size_t order_len, 424 const u8 *privkey, size_t privkey_len, 425 const u8 *pubkey, size_t pubkey_len, 426 u8 *secret, size_t *len); 427 428 /** 429 * crypto_global_init - Initialize crypto wrapper 430 * 431 * This function is only used with internal TLSv1 implementation 432 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 433 * to implement this. 434 */ 435 int __must_check crypto_global_init(void); 436 437 /** 438 * crypto_global_deinit - Deinitialize crypto wrapper 439 * 440 * This function is only used with internal TLSv1 implementation 441 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 442 * to implement this. 443 */ 444 void crypto_global_deinit(void); 445 446 /** 447 * crypto_mod_exp - Modular exponentiation of large integers 448 * @base: Base integer (big endian byte array) 449 * @base_len: Length of base integer in bytes 450 * @power: Power integer (big endian byte array) 451 * @power_len: Length of power integer in bytes 452 * @modulus: Modulus integer (big endian byte array) 453 * @modulus_len: Length of modulus integer in bytes 454 * @result: Buffer for the result 455 * @result_len: Result length (max buffer size on input, real len on output) 456 * Returns: 0 on success, -1 on failure 457 * 458 * This function calculates result = base ^ power mod modulus. modules_len is 459 * used as the maximum size of modulus buffer. It is set to the used size on 460 * success. 461 * 462 * This function is only used with internal TLSv1 implementation 463 * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need 464 * to implement this. 465 */ 466 int __must_check crypto_mod_exp(const u8 *base, size_t base_len, 467 const u8 *power, size_t power_len, 468 const u8 *modulus, size_t modulus_len, 469 u8 *result, size_t *result_len); 470 471 /** 472 * rc4_skip - XOR RC4 stream to given data with skip-stream-start 473 * @key: RC4 key 474 * @keylen: RC4 key length 475 * @skip: number of bytes to skip from the beginning of the RC4 stream 476 * @data: data to be XOR'ed with RC4 stream 477 * @data_len: buf length 478 * Returns: 0 on success, -1 on failure 479 * 480 * Generate RC4 pseudo random stream for the given key, skip beginning of the 481 * stream, and XOR the end result with the data buffer to perform RC4 482 * encryption/decryption. 483 */ 484 int rc4_skip(const u8 *key, size_t keylen, size_t skip, 485 u8 *data, size_t data_len); 486 487 /** 488 * crypto_get_random - Generate cryptographically strong pseudo-random bytes 489 * @buf: Buffer for data 490 * @len: Number of bytes to generate 491 * Returns: 0 on success, -1 on failure 492 * 493 * If the PRNG does not have enough entropy to ensure unpredictable byte 494 * sequence, this functions must return -1. 495 */ 496 int crypto_get_random(void *buf, size_t len); 497 498 /** 499 * crypto_pkcs7_get_certificates - Extract X.509 certificates from PKCS#7 data 500 * @pkcs7: DER encoded PKCS#7 data 501 * Returns: Buffer of the extracted PEM X.509 certificates or %NULL on failure 502 */ 503 struct wpabuf * crypto_pkcs7_get_certificates(const struct wpabuf *pkcs7); 504 505 506 /** 507 * struct crypto_bignum - bignum 508 * 509 * Internal data structure for bignum implementation. The contents is specific 510 * to the used crypto library. 511 */ 512 struct crypto_bignum; 513 514 /** 515 * crypto_bignum_init - Allocate memory for bignum 516 * Returns: Pointer to allocated bignum or %NULL on failure 517 */ 518 struct crypto_bignum * crypto_bignum_init(void); 519 520 /** 521 * crypto_bignum_init_set - Allocate memory for bignum and set the value 522 * @buf: Buffer with unsigned binary value 523 * @len: Length of buf in octets 524 * Returns: Pointer to allocated bignum or %NULL on failure 525 */ 526 struct crypto_bignum * crypto_bignum_init_set(const u8 *buf, size_t len); 527 528 /** 529 * crypto_bignum_init_set - Allocate memory for bignum and set the value (uint) 530 * @val: Value to set 531 * Returns: Pointer to allocated bignum or %NULL on failure 532 */ 533 struct crypto_bignum * crypto_bignum_init_uint(unsigned int val); 534 535 /** 536 * crypto_bignum_deinit - Free bignum 537 * @n: Bignum from crypto_bignum_init() or crypto_bignum_init_set() 538 * @clear: Whether to clear the value from memory 539 */ 540 void crypto_bignum_deinit(struct crypto_bignum *n, int clear); 541 542 /** 543 * crypto_bignum_to_bin - Set binary buffer to unsigned bignum 544 * @a: Bignum 545 * @buf: Buffer for the binary number 546 * @len: Length of @buf in octets 547 * @padlen: Length in octets to pad the result to or 0 to indicate no padding 548 * Returns: Number of octets written on success, -1 on failure 549 */ 550 int crypto_bignum_to_bin(const struct crypto_bignum *a, 551 u8 *buf, size_t buflen, size_t padlen); 552 553 /** 554 * crypto_bignum_rand - Create a random number in range of modulus 555 * @r: Bignum; set to a random value 556 * @m: Bignum; modulus 557 * Returns: 0 on success, -1 on failure 558 */ 559 int crypto_bignum_rand(struct crypto_bignum *r, const struct crypto_bignum *m); 560 561 /** 562 * crypto_bignum_add - c = a + b 563 * @a: Bignum 564 * @b: Bignum 565 * @c: Bignum; used to store the result of a + b 566 * Returns: 0 on success, -1 on failure 567 */ 568 int crypto_bignum_add(const struct crypto_bignum *a, 569 const struct crypto_bignum *b, 570 struct crypto_bignum *c); 571 572 /** 573 * crypto_bignum_mod - c = a % b 574 * @a: Bignum 575 * @b: Bignum 576 * @c: Bignum; used to store the result of a % b 577 * Returns: 0 on success, -1 on failure 578 */ 579 int crypto_bignum_mod(const struct crypto_bignum *a, 580 const struct crypto_bignum *b, 581 struct crypto_bignum *c); 582 583 /** 584 * crypto_bignum_exptmod - Modular exponentiation: d = a^b (mod c) 585 * @a: Bignum; base 586 * @b: Bignum; exponent 587 * @c: Bignum; modulus 588 * @d: Bignum; used to store the result of a^b (mod c) 589 * Returns: 0 on success, -1 on failure 590 */ 591 int crypto_bignum_exptmod(const struct crypto_bignum *a, 592 const struct crypto_bignum *b, 593 const struct crypto_bignum *c, 594 struct crypto_bignum *d); 595 596 /** 597 * crypto_bignum_inverse - Inverse a bignum so that a * c = 1 (mod b) 598 * @a: Bignum 599 * @b: Bignum 600 * @c: Bignum; used to store the result 601 * Returns: 0 on success, -1 on failure 602 */ 603 int crypto_bignum_inverse(const struct crypto_bignum *a, 604 const struct crypto_bignum *b, 605 struct crypto_bignum *c); 606 607 /** 608 * crypto_bignum_sub - c = a - b 609 * @a: Bignum 610 * @b: Bignum 611 * @c: Bignum; used to store the result of a - b 612 * Returns: 0 on success, -1 on failure 613 */ 614 int crypto_bignum_sub(const struct crypto_bignum *a, 615 const struct crypto_bignum *b, 616 struct crypto_bignum *c); 617 618 /** 619 * crypto_bignum_div - c = a / b 620 * @a: Bignum 621 * @b: Bignum 622 * @c: Bignum; used to store the result of a / b 623 * Returns: 0 on success, -1 on failure 624 */ 625 int crypto_bignum_div(const struct crypto_bignum *a, 626 const struct crypto_bignum *b, 627 struct crypto_bignum *c); 628 629 /** 630 * crypto_bignum_addmod - d = a + b (mod c) 631 * @a: Bignum 632 * @b: Bignum 633 * @c: Bignum 634 * @d: Bignum; used to store the result of (a + b) % c 635 * Returns: 0 on success, -1 on failure 636 */ 637 int crypto_bignum_addmod(const struct crypto_bignum *a, 638 const struct crypto_bignum *b, 639 const struct crypto_bignum *c, 640 struct crypto_bignum *d); 641 642 /** 643 * crypto_bignum_mulmod - d = a * b (mod c) 644 * @a: Bignum 645 * @b: Bignum 646 * @c: Bignum 647 * @d: Bignum; used to store the result of (a * b) % c 648 * Returns: 0 on success, -1 on failure 649 */ 650 int crypto_bignum_mulmod(const struct crypto_bignum *a, 651 const struct crypto_bignum *b, 652 const struct crypto_bignum *c, 653 struct crypto_bignum *d); 654 655 /** 656 * crypto_bignum_sqrmod - c = a^2 (mod b) 657 * @a: Bignum 658 * @b: Bignum 659 * @c: Bignum; used to store the result of a^2 % b 660 * Returns: 0 on success, -1 on failure 661 */ 662 int crypto_bignum_sqrmod(const struct crypto_bignum *a, 663 const struct crypto_bignum *b, 664 struct crypto_bignum *c); 665 666 /** 667 * crypto_bignum_sqrtmod - returns sqrt(a) (mod b) 668 * @a: Bignum 669 * @b: Bignum 670 * @c: Bignum; used to store the result 671 * Returns: 0 on success, -1 on failure 672 */ 673 int crypto_bignum_sqrtmod(const struct crypto_bignum *a, 674 const struct crypto_bignum *b, 675 struct crypto_bignum *c); 676 677 /** 678 * crypto_bignum_rshift - r = a >> n 679 * @a: Bignum 680 * @n: Number of bits 681 * @r: Bignum; used to store the result of a >> n 682 * Returns: 0 on success, -1 on failure 683 */ 684 int crypto_bignum_rshift(const struct crypto_bignum *a, int n, 685 struct crypto_bignum *r); 686 687 /** 688 * crypto_bignum_cmp - Compare two bignums 689 * @a: Bignum 690 * @b: Bignum 691 * Returns: -1 if a < b, 0 if a == b, or 1 if a > b 692 */ 693 int crypto_bignum_cmp(const struct crypto_bignum *a, 694 const struct crypto_bignum *b); 695 696 /** 697 * crypto_bignum_is_zero - Is the given bignum zero 698 * @a: Bignum 699 * Returns: 1 if @a is zero or 0 if not 700 */ 701 int crypto_bignum_is_zero(const struct crypto_bignum *a); 702 703 /** 704 * crypto_bignum_is_one - Is the given bignum one 705 * @a: Bignum 706 * Returns: 1 if @a is one or 0 if not 707 */ 708 int crypto_bignum_is_one(const struct crypto_bignum *a); 709 710 /** 711 * crypto_bignum_is_odd - Is the given bignum odd 712 * @a: Bignum 713 * Returns: 1 if @a is odd or 0 if not 714 */ 715 int crypto_bignum_is_odd(const struct crypto_bignum *a); 716 717 /** 718 * crypto_bignum_legendre - Compute the Legendre symbol (a/p) 719 * @a: Bignum 720 * @p: Bignum 721 * Returns: Legendre symbol -1,0,1 on success; -2 on calculation failure 722 */ 723 int crypto_bignum_legendre(const struct crypto_bignum *a, 724 const struct crypto_bignum *p); 725 726 /** 727 * struct crypto_ec - Elliptic curve context 728 * 729 * Internal data structure for EC implementation. The contents is specific 730 * to the used crypto library. 731 */ 732 struct crypto_ec; 733 734 /** 735 * struct crypto_ec_point - Elliptic curve point 736 * 737 * Internal data structure for EC implementation to represent a point. The 738 * contents is specific to the used crypto library. 739 */ 740 struct crypto_ec_point; 741 742 /** 743 * crypto_ec_init - Initialize elliptic curve context 744 * @group: Identifying number for the ECC group (IANA "Group Description" 745 * attribute registrty for RFC 2409) 746 * Returns: Pointer to EC context or %NULL on failure 747 */ 748 struct crypto_ec * crypto_ec_init(int group); 749 750 /** 751 * crypto_ec_deinit - Deinitialize elliptic curve context 752 * @e: EC context from crypto_ec_init() 753 */ 754 void crypto_ec_deinit(struct crypto_ec *e); 755 756 /** 757 * crypto_ec_prime_len - Get length of the prime in octets 758 * @e: EC context from crypto_ec_init() 759 * Returns: Length of the prime defining the group 760 */ 761 size_t crypto_ec_prime_len(struct crypto_ec *e); 762 763 /** 764 * crypto_ec_prime_len_bits - Get length of the prime in bits 765 * @e: EC context from crypto_ec_init() 766 * Returns: Length of the prime defining the group in bits 767 */ 768 size_t crypto_ec_prime_len_bits(struct crypto_ec *e); 769 770 /** 771 * crypto_ec_order_len - Get length of the order in octets 772 * @e: EC context from crypto_ec_init() 773 * Returns: Length of the order defining the group 774 */ 775 size_t crypto_ec_order_len(struct crypto_ec *e); 776 777 /** 778 * crypto_ec_get_prime - Get prime defining an EC group 779 * @e: EC context from crypto_ec_init() 780 * Returns: Prime (bignum) defining the group 781 */ 782 const struct crypto_bignum * crypto_ec_get_prime(struct crypto_ec *e); 783 784 /** 785 * crypto_ec_get_order - Get order of an EC group 786 * @e: EC context from crypto_ec_init() 787 * Returns: Order (bignum) of the group 788 */ 789 const struct crypto_bignum * crypto_ec_get_order(struct crypto_ec *e); 790 791 const struct crypto_bignum * crypto_ec_get_a(struct crypto_ec *e); 792 const struct crypto_bignum * crypto_ec_get_b(struct crypto_ec *e); 793 794 /** 795 * crypto_ec_get_a - Get 'a' coefficient of an EC group's curve 796 * @e: EC context from crypto_ec_init() 797 * Returns: 'a' coefficient (bignum) of the group 798 */ 799 const struct crypto_bignum * crypto_ec_get_a(struct crypto_ec *e); 800 801 /** 802 * crypto_ec_get_b - Get 'b' coeffiecient of an EC group's curve 803 * @e: EC context from crypto_ec_init() 804 * Returns: 'b' coefficient (bignum) of the group 805 */ 806 const struct crypto_bignum * crypto_ec_get_b(struct crypto_ec *e); 807 808 /** 809 * crypto_ec_get_generator - Get generator point of the EC group's curve 810 * @e: EC context from crypto_ec_init() 811 * Returns: Pointer to generator point 812 */ 813 const struct crypto_ec_point * crypto_ec_get_generator(struct crypto_ec *e); 814 815 /** 816 * crypto_ec_point_init - Initialize data for an EC point 817 * @e: EC context from crypto_ec_init() 818 * Returns: Pointer to EC point data or %NULL on failure 819 */ 820 struct crypto_ec_point * crypto_ec_point_init(struct crypto_ec *e); 821 822 /** 823 * crypto_ec_point_deinit - Deinitialize EC point data 824 * @p: EC point data from crypto_ec_point_init() 825 * @clear: Whether to clear the EC point value from memory 826 */ 827 void crypto_ec_point_deinit(struct crypto_ec_point *p, int clear); 828 829 /** 830 * crypto_ec_point_x - Copies the x-ordinate point into big number 831 * @e: EC context from crypto_ec_init() 832 * @p: EC point data 833 * @x: Big number to set to the copy of x-ordinate 834 * Returns: 0 on success, -1 on failure 835 */ 836 int crypto_ec_point_x(struct crypto_ec *e, const struct crypto_ec_point *p, 837 struct crypto_bignum *x); 838 839 /** 840 * crypto_ec_point_to_bin - Write EC point value as binary data 841 * @e: EC context from crypto_ec_init() 842 * @p: EC point data from crypto_ec_point_init() 843 * @x: Buffer for writing the binary data for x coordinate or %NULL if not used 844 * @y: Buffer for writing the binary data for y coordinate or %NULL if not used 845 * Returns: 0 on success, -1 on failure 846 * 847 * This function can be used to write an EC point as binary data in a format 848 * that has the x and y coordinates in big endian byte order fields padded to 849 * the length of the prime defining the group. 850 */ 851 int crypto_ec_point_to_bin(struct crypto_ec *e, 852 const struct crypto_ec_point *point, u8 *x, u8 *y); 853 854 /** 855 * crypto_ec_point_from_bin - Create EC point from binary data 856 * @e: EC context from crypto_ec_init() 857 * @val: Binary data to read the EC point from 858 * Returns: Pointer to EC point data or %NULL on failure 859 * 860 * This function readers x and y coordinates of the EC point from the provided 861 * buffer assuming the values are in big endian byte order with fields padded to 862 * the length of the prime defining the group. 863 */ 864 struct crypto_ec_point * crypto_ec_point_from_bin(struct crypto_ec *e, 865 const u8 *val); 866 867 /** 868 * crypto_ec_point_add - c = a + b 869 * @e: EC context from crypto_ec_init() 870 * @a: Bignum 871 * @b: Bignum 872 * @c: Bignum; used to store the result of a + b 873 * Returns: 0 on success, -1 on failure 874 */ 875 int crypto_ec_point_add(struct crypto_ec *e, const struct crypto_ec_point *a, 876 const struct crypto_ec_point *b, 877 struct crypto_ec_point *c); 878 879 /** 880 * crypto_ec_point_mul - res = b * p 881 * @e: EC context from crypto_ec_init() 882 * @p: EC point 883 * @b: Bignum 884 * @res: EC point; used to store the result of b * p 885 * Returns: 0 on success, -1 on failure 886 */ 887 int crypto_ec_point_mul(struct crypto_ec *e, const struct crypto_ec_point *p, 888 const struct crypto_bignum *b, 889 struct crypto_ec_point *res); 890 891 /** 892 * crypto_ec_point_invert - Compute inverse of an EC point 893 * @e: EC context from crypto_ec_init() 894 * @p: EC point to invert (and result of the operation) 895 * Returns: 0 on success, -1 on failure 896 */ 897 int crypto_ec_point_invert(struct crypto_ec *e, struct crypto_ec_point *p); 898 899 /** 900 * crypto_ec_point_compute_y_sqr - Compute y^2 = x^3 + ax + b 901 * @e: EC context from crypto_ec_init() 902 * @x: x coordinate 903 * Returns: y^2 on success, %NULL failure 904 */ 905 struct crypto_bignum * 906 crypto_ec_point_compute_y_sqr(struct crypto_ec *e, 907 const struct crypto_bignum *x); 908 909 /** 910 * crypto_ec_point_is_at_infinity - Check whether EC point is neutral element 911 * @e: EC context from crypto_ec_init() 912 * @p: EC point 913 * Returns: 1 if the specified EC point is the neutral element of the group or 914 * 0 if not 915 */ 916 int crypto_ec_point_is_at_infinity(struct crypto_ec *e, 917 const struct crypto_ec_point *p); 918 919 /** 920 * crypto_ec_point_is_on_curve - Check whether EC point is on curve 921 * @e: EC context from crypto_ec_init() 922 * @p: EC point 923 * Returns: 1 if the specified EC point is on the curve or 0 if not 924 */ 925 int crypto_ec_point_is_on_curve(struct crypto_ec *e, 926 const struct crypto_ec_point *p); 927 928 /** 929 * crypto_ec_point_cmp - Compare two EC points 930 * @e: EC context from crypto_ec_init() 931 * @a: EC point 932 * @b: EC point 933 * Returns: 0 on equal, non-zero otherwise 934 */ 935 int crypto_ec_point_cmp(const struct crypto_ec *e, 936 const struct crypto_ec_point *a, 937 const struct crypto_ec_point *b); 938 939 /** 940 * crypto_ec_point_debug_print - Dump EC point to debug log 941 * @e: EC context from crypto_ec_init() 942 * @p: EC point 943 * @title: Name of the EC point in the trace 944 */ 945 void crypto_ec_point_debug_print(const struct crypto_ec *e, 946 const struct crypto_ec_point *p, 947 const char *title); 948 949 /** 950 * struct crypto_ec_key - Elliptic curve key pair 951 * 952 * Internal data structure for EC key pair. The contents is specific to the used 953 * crypto library. 954 */ 955 struct crypto_ec_key; 956 957 /** 958 * struct crypto_ecdh - Elliptic Curve Diffie�CHellman context 959 * 960 * Internal data structure for ECDH. The contents is specific to the used 961 * crypto library. 962 */ 963 struct crypto_ecdh; 964 965 /** 966 * crypto_ecdh_init - Initialize elliptic curve Diffie�CHellman context 967 * @group: Identifying number for the ECC group (IANA "Group Description" 968 * attribute registry for RFC 2409) 969 * This function generates an ephemeral key pair. 970 * Returns: Pointer to ECDH context or %NULL on failure 971 */ 972 struct crypto_ecdh * crypto_ecdh_init(int group); 973 974 /** 975 * crypto_ecdh_init2 - Initialize elliptic curve Diffie�CHellman context with a 976 * given EC key 977 * @group: Identifying number for the ECC group (IANA "Group Description" 978 * attribute registry for RFC 2409) 979 * @own_key: Our own EC Key 980 * Returns: Pointer to ECDH context or %NULL on failure 981 */ 982 struct crypto_ecdh * crypto_ecdh_init2(int group, 983 struct crypto_ec_key *own_key); 984 985 /** 986 * crypto_ecdh_get_pubkey - Retrieve public key from ECDH context 987 * @ecdh: ECDH context from crypto_ecdh_init() or crypto_ecdh_init2() 988 * @inc_y: Whether public key should include y coordinate (explicit form) 989 * or not (compressed form) 990 * Returns: Binary data f the public key or %NULL on failure 991 */ 992 struct wpabuf * crypto_ecdh_get_pubkey(struct crypto_ecdh *ecdh, int inc_y); 993 994 /** 995 * crypto_ecdh_set_peerkey - Compute ECDH secret 996 * @ecdh: ECDH context from crypto_ecdh_init() or crypto_ecdh_init2() 997 * @inc_y: Whether peer's public key includes y coordinate (explicit form) 998 * or not (compressed form) 999 * @key: Binary data of the peer's public key 1000 * @len: Length of the @key buffer 1001 * Returns: Binary data with the EDCH secret or %NULL on failure 1002 */ 1003 struct wpabuf * crypto_ecdh_set_peerkey(struct crypto_ecdh *ecdh, int inc_y, 1004 const u8 *key, size_t len); 1005 1006 /** 1007 * crypto_ecdh_deinit - Free ECDH context 1008 * @ecdh: ECDH context from crypto_ecdh_init() or crypto_ecdh_init2() 1009 */ 1010 void crypto_ecdh_deinit(struct crypto_ecdh *ecdh); 1011 1012 /** 1013 * crypto_ecdh_prime_len - Get length of the prime in octets 1014 * @e: ECDH context from crypto_ecdh_init() 1015 * Returns: Length of the prime defining the group 1016 */ 1017 size_t crypto_ecdh_prime_len(struct crypto_ecdh *ecdh); 1018 1019 /** 1020 * crypto_ec_key_parse_priv - Initialize EC key pair from ECPrivateKey ASN.1 1021 * @der: DER encoding of ASN.1 ECPrivateKey 1022 * @der_len: Length of @der buffer 1023 * Returns: EC key or %NULL on failure 1024 */ 1025 struct crypto_ec_key * crypto_ec_key_parse_priv(const u8 *der, size_t der_len); 1026 1027 /** 1028 * crypto_ec_key_parse_pub - Initialize EC key pair from SubjectPublicKeyInfo ASN.1 1029 * @der: DER encoding of ASN.1 SubjectPublicKeyInfo 1030 * @der_len: Length of @der buffer 1031 * Returns: EC key or %NULL on failure 1032 */ 1033 struct crypto_ec_key * crypto_ec_key_parse_pub(const u8 *der, size_t der_len); 1034 1035 /** 1036 * crypto_ec_key_set_pub - Initialize an EC public key from EC point coordinates 1037 * @group: Identifying number for the ECC group 1038 * @x: X coordinate of the public key 1039 * @y: Y coordinate of the public key 1040 * @len: Length of @x and @y buffer 1041 * Returns: EC key or %NULL on failure 1042 * 1043 * This function initialize an EC key from public key coordinates, in big endian 1044 * byte order padded to the length of the prime defining the group. 1045 */ 1046 struct crypto_ec_key * crypto_ec_key_set_pub(int group, const u8 *x, 1047 const u8 *y, size_t len); 1048 1049 /** 1050 * crypto_ec_key_set_pub_point - Initialize an EC public key from EC point 1051 * @e: EC context from crypto_ec_init() 1052 * @pub: Public key point 1053 * Returns: EC key or %NULL on failure 1054 */ 1055 struct crypto_ec_key * 1056 crypto_ec_key_set_pub_point(struct crypto_ec *e, 1057 const struct crypto_ec_point *pub); 1058 1059 /** 1060 * crypto_ec_key_gen - Generate EC key pair 1061 * @group: Identifying number for the ECC group 1062 * Returns: EC key or %NULL on failure 1063 */ 1064 struct crypto_ec_key * crypto_ec_key_gen(int group); 1065 1066 /** 1067 * crypto_ec_key_deinit - Free EC key 1068 * @key: EC key from crypto_ec_key_parse_pub/priv() or crypto_ec_key_gen() 1069 */ 1070 void crypto_ec_key_deinit(struct crypto_ec_key *key); 1071 1072 /** 1073 * crypto_ec_key_get_subject_public_key - Get SubjectPublicKeyInfo ASN.1 for an EC key 1074 * @key: EC key from crypto_ec_key_parse/set_pub/priv() or crypto_ec_key_gen() 1075 * Returns: Buffer with DER encoding of ASN.1 SubjectPublicKeyInfo or %NULL on failure 1076 */ 1077 struct wpabuf * crypto_ec_key_get_subject_public_key(struct crypto_ec_key *key); 1078 1079 /** 1080 * crypto_ec_key_get_ecprivate_key - Get ECPrivateKey ASN.1 for a EC key 1081 * @key: EC key from crypto_ec_key_parse_priv() or crypto_ec_key_gen() 1082 * @include_pub: Whether to include public key in the ASN.1 sequence 1083 * Returns: Buffer with DER encoding of ASN.1 ECPrivateKey or %NULL on failure 1084 */ 1085 struct wpabuf * crypto_ec_key_get_ecprivate_key(struct crypto_ec_key *key, 1086 bool include_pub); 1087 1088 /** 1089 * crypto_ec_key_get_pubkey_point - Get public key point coordinates 1090 * @key: EC key from crypto_ec_key_parse/set_pub() or crypto_ec_key_parse_priv() 1091 * @prefix: Whether output buffer should include the octet to indicate 1092 * coordinate form (as defined for SubjectPublicKeyInfo) 1093 * Returns: Buffer with coordinates of public key in uncompressed form or %NULL 1094 * on failure 1095 */ 1096 struct wpabuf * crypto_ec_key_get_pubkey_point(struct crypto_ec_key *key, 1097 int prefix); 1098 1099 /** 1100 * crypto_ec_key_get_public_key - Get EC public key as an EC point 1101 * @key: EC key from crypto_ec_key_parse/set_pub() or crypto_ec_key_parse_priv() 1102 * Returns: Public key as an EC point or %NULL on failure 1103 */ 1104 const struct crypto_ec_point * 1105 crypto_ec_key_get_public_key(struct crypto_ec_key *key); 1106 1107 /** 1108 * crypto_ec_key_get_private_key - Get EC private key as a bignum 1109 * @key: EC key from crypto_ec_key_parse/set_pub() or crypto_ec_key_parse_priv() 1110 * Returns: Private key as a bignum or %NULL on failure 1111 */ 1112 const struct crypto_bignum * 1113 crypto_ec_key_get_private_key(struct crypto_ec_key *key); 1114 1115 /** 1116 * crypto_ec_key_sign - Sign a buffer with an EC key 1117 * @key: EC key from crypto_ec_key_parse_priv() or crypto_ec_key_gen() 1118 * @data: Data to sign 1119 * @len: Length of @data buffer 1120 * Returns: Buffer with DER encoding of ASN.1 Ecdsa-Sig-Value or %NULL on failure 1121 */ 1122 struct wpabuf * crypto_ec_key_sign(struct crypto_ec_key *key, const u8 *data, 1123 size_t len); 1124 1125 /** 1126 * crypto_ec_key_sign_r_s - Sign a buffer with an EC key 1127 * @key: EC key from crypto_ec_key_parse_priv() or crypto_ec_key_gen() 1128 * @data: Data to sign 1129 * @len: Length of @data buffer 1130 * Returns: Buffer with the concatenated r and s values. Each value is in big 1131 * endian byte order padded to the length of the prime defining the group of 1132 * the key. 1133 */ 1134 struct wpabuf * crypto_ec_key_sign_r_s(struct crypto_ec_key *key, 1135 const u8 *data, size_t len); 1136 1137 /** 1138 * crypto_ec_key_verify_signature - Verify ECDSA signature 1139 * @key: EC key from crypto_ec_key_parse/set_pub() or crypto_ec_key_gen() 1140 * @data: Data to be signed 1141 * @len: Length of @data buffer 1142 * @sig: DER encoding of ASN.1 Ecdsa-Sig-Value 1143 * @sig_len: Length of @sig buffer 1144 * Returns: 1 if signature is valid, 0 if signature is invalid and -1 on failure 1145 */ 1146 int crypto_ec_key_verify_signature(struct crypto_ec_key *key, const u8 *data, 1147 size_t len, const u8 *sig, size_t sig_len); 1148 1149 /** 1150 * crypto_ec_key_verify_signature_r_s - Verify signature 1151 * @key: EC key from crypto_ec_key_parse/set_pub() or crypto_ec_key_gen() 1152 * @data: Data to signed 1153 * @len: Length of @data buffer 1154 * @r: Binary data, in big endian byte order, of the 'r' field of the ECDSA 1155 * signature. 1156 * @s: Binary data, in big endian byte order, of the 's' field of the ECDSA 1157 * signature. 1158 * @r_len: Length of @r buffer 1159 * @s_len: Length of @s buffer 1160 * Returns: 1 if signature is valid, 0 if signature is invalid, or -1 on failure 1161 */ 1162 int crypto_ec_key_verify_signature_r_s(struct crypto_ec_key *key, 1163 const u8 *data, size_t len, 1164 const u8 *r, size_t r_len, 1165 const u8 *s, size_t s_len); 1166 1167 /** 1168 * crypto_ec_key_group - Get IANA group identifier for an EC key 1169 * @key: EC key from crypto_ec_key_parse/set_pub/priv() or crypto_ec_key_gen() 1170 * Returns: IANA group identifier and -1 on failure 1171 */ 1172 int crypto_ec_key_group(struct crypto_ec_key *key); 1173 1174 /** 1175 * crypto_ec_key_cmp - Compare two EC public keys 1176 * @key1: Key 1 1177 * @key2: Key 2 1178 * Returns: 0 if public keys are identical, -1 otherwise 1179 */ 1180 int crypto_ec_key_cmp(struct crypto_ec_key *key1, struct crypto_ec_key *key2); 1181 1182 /** 1183 * crypto_ec_key_debug_print - Dump EC key to debug log 1184 * @key: EC key from crypto_ec_key_parse/set_pub/priv() or crypto_ec_key_gen() 1185 * @title: Name of the EC point in the trace 1186 */ 1187 void crypto_ec_key_debug_print(const struct crypto_ec_key *key, 1188 const char *title); 1189 1190 /** 1191 * struct crypto_csr - Certification Signing Request 1192 * 1193 * Internal data structure for CSR. The contents is specific to the used 1194 * crypto library. 1195 * For now it is assumed that only an EC public key can be used 1196 */ 1197 struct crypto_csr; 1198 1199 /** 1200 * enum crypto_csr_name - CSR name type 1201 */ 1202 enum crypto_csr_name { 1203 CSR_NAME_CN, 1204 CSR_NAME_SN, 1205 CSR_NAME_C, 1206 CSR_NAME_O, 1207 CSR_NAME_OU, 1208 }; 1209 1210 /** 1211 * enum crypto_csr_attr - CSR attribute 1212 */ 1213 enum crypto_csr_attr { 1214 CSR_ATTR_CHALLENGE_PASSWORD, 1215 }; 1216 1217 /** 1218 * crypto_csr_init - Initialize empty CSR 1219 * Returns: Pointer to CSR data or %NULL on failure 1220 */ 1221 struct crypto_csr * crypto_csr_init(void); 1222 1223 /** 1224 * crypto_csr_verify - Initialize CSR from CertificationRequest 1225 * @req: DER encoding of ASN.1 CertificationRequest 1226 * 1227 * Returns: Pointer to CSR data or %NULL on failure or if signature is invalid 1228 */ 1229 struct crypto_csr * crypto_csr_verify(const struct wpabuf *req); 1230 1231 /** 1232 * crypto_csr_deinit - Free CSR structure 1233 * @csr: CSR structure from @crypto_csr_init() or crypto_csr_verify() 1234 */ 1235 void crypto_csr_deinit(struct crypto_csr *csr); 1236 1237 /** 1238 * crypto_csr_set_ec_public_key - Set public key in CSR 1239 * @csr: CSR structure from @crypto_csr_init() 1240 * @key: EC public key to set as public key in the CSR 1241 * Returns: 0 on success, -1 on failure 1242 */ 1243 int crypto_csr_set_ec_public_key(struct crypto_csr *csr, 1244 struct crypto_ec_key *key); 1245 1246 /** 1247 * crypto_csr_set_name - Set name entry in CSR SubjectName 1248 * @csr: CSR structure from @crypto_csr_init() 1249 * @type: Name type to add into the CSR SubjectName 1250 * @name: UTF-8 string to write in the CSR SubjectName 1251 * Returns: 0 on success, -1 on failure 1252 */ 1253 int crypto_csr_set_name(struct crypto_csr *csr, enum crypto_csr_name type, 1254 const char *name); 1255 1256 /** 1257 * crypto_csr_set_attribute - Set attribute in CSR 1258 * @csr: CSR structure from @crypto_csr_init() 1259 * @attr: Attribute identifier 1260 * @attr_type: ASN.1 type of @value buffer 1261 * @value: Attribute value 1262 * @len: length of @value buffer 1263 * Returns: 0 on success, -1 on failure 1264 */ 1265 int crypto_csr_set_attribute(struct crypto_csr *csr, enum crypto_csr_attr attr, 1266 int attr_type, const u8 *value, size_t len); 1267 1268 /** 1269 * crypto_csr_get_attribute - Get attribute from CSR 1270 * @csr: CSR structure from @crypto_csr_verify() 1271 * @attr: Updated with atribute identifier 1272 * @len: Updated with length of returned buffer 1273 * @type: ASN.1 type of the attribute buffer 1274 * Returns: Type, length, and pointer on attribute value or %NULL on failure 1275 */ 1276 const u8 * crypto_csr_get_attribute(struct crypto_csr *csr, 1277 enum crypto_csr_attr attr, 1278 size_t *len, int *type); 1279 1280 /** 1281 * crypto_csr_sign - Sign CSR and return ASN.1 CertificationRequest 1282 * @csr: CSR structure from @crypto_csr_init() 1283 * @key: Private key to sign the CSR (for now ony EC key are supported) 1284 * @algo: Hash algorithm to use for the signature 1285 * Returns: DER encoding of ASN.1 CertificationRequest for the CSR or %NULL on 1286 * failure 1287 */ 1288 struct wpabuf * crypto_csr_sign(struct crypto_csr *csr, 1289 struct crypto_ec_key *key, 1290 enum crypto_hash_alg algo); 1291 1292 #endif /* CRYPTO_H */ 1293