crypto.h revision 346981
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 */ 32int 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 */ 42int 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 */ 53int 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 */ 68int __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 */ 79int 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 */ 90int 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 */ 101int 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 */ 111int 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 */ 119void * 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 */ 128int 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 */ 134void 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 */ 142void * 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 */ 151int 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 */ 157void aes_decrypt_deinit(void *ctx); 158 159 160enum 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 167struct 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 */ 181struct 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 */ 194void 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 */ 213int crypto_hash_finish(struct crypto_hash *ctx, u8 *hash, size_t *len); 214 215 216enum 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 221struct 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 */ 236struct 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 */ 252int __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 */ 267int __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 */ 278void crypto_cipher_deinit(struct crypto_cipher *ctx); 279 280 281struct crypto_public_key; 282struct 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 */ 298struct crypto_public_key * crypto_public_key_import(const u8 *key, size_t len); 299 300struct crypto_public_key * 301crypto_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 */ 315struct 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 */ 333struct 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 */ 349int __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 */ 366int __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 */ 383int __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 */ 395void 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 */ 405void 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 */ 416int __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 420int crypto_dh_init(u8 generator, const u8 *prime, size_t prime_len, u8 *privkey, 421 u8 *pubkey); 422int 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 */ 435int __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 */ 444void 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 */ 466int __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 */ 484int 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 pseudy-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 */ 496int crypto_get_random(void *buf, size_t len); 497 498 499/** 500 * struct crypto_bignum - bignum 501 * 502 * Internal data structure for bignum implementation. The contents is specific 503 * to the used crypto library. 504 */ 505struct crypto_bignum; 506 507/** 508 * crypto_bignum_init - Allocate memory for bignum 509 * Returns: Pointer to allocated bignum or %NULL on failure 510 */ 511struct crypto_bignum * crypto_bignum_init(void); 512 513/** 514 * crypto_bignum_init_set - Allocate memory for bignum and set the value 515 * @buf: Buffer with unsigned binary value 516 * @len: Length of buf in octets 517 * Returns: Pointer to allocated bignum or %NULL on failure 518 */ 519struct crypto_bignum * crypto_bignum_init_set(const u8 *buf, size_t len); 520 521/** 522 * crypto_bignum_deinit - Free bignum 523 * @n: Bignum from crypto_bignum_init() or crypto_bignum_init_set() 524 * @clear: Whether to clear the value from memory 525 */ 526void crypto_bignum_deinit(struct crypto_bignum *n, int clear); 527 528/** 529 * crypto_bignum_to_bin - Set binary buffer to unsigned bignum 530 * @a: Bignum 531 * @buf: Buffer for the binary number 532 * @len: Length of @buf in octets 533 * @padlen: Length in octets to pad the result to or 0 to indicate no padding 534 * Returns: Number of octets written on success, -1 on failure 535 */ 536int crypto_bignum_to_bin(const struct crypto_bignum *a, 537 u8 *buf, size_t buflen, size_t padlen); 538 539/** 540 * crypto_bignum_rand - Create a random number in range of modulus 541 * @r: Bignum; set to a random value 542 * @m: Bignum; modulus 543 * Returns: 0 on success, -1 on failure 544 */ 545int crypto_bignum_rand(struct crypto_bignum *r, const struct crypto_bignum *m); 546 547/** 548 * crypto_bignum_add - c = a + b 549 * @a: Bignum 550 * @b: Bignum 551 * @c: Bignum; used to store the result of a + b 552 * Returns: 0 on success, -1 on failure 553 */ 554int crypto_bignum_add(const struct crypto_bignum *a, 555 const struct crypto_bignum *b, 556 struct crypto_bignum *c); 557 558/** 559 * crypto_bignum_mod - c = a % b 560 * @a: Bignum 561 * @b: Bignum 562 * @c: Bignum; used to store the result of a % b 563 * Returns: 0 on success, -1 on failure 564 */ 565int crypto_bignum_mod(const struct crypto_bignum *a, 566 const struct crypto_bignum *b, 567 struct crypto_bignum *c); 568 569/** 570 * crypto_bignum_exptmod - Modular exponentiation: d = a^b (mod c) 571 * @a: Bignum; base 572 * @b: Bignum; exponent 573 * @c: Bignum; modulus 574 * @d: Bignum; used to store the result of a^b (mod c) 575 * Returns: 0 on success, -1 on failure 576 */ 577int crypto_bignum_exptmod(const struct crypto_bignum *a, 578 const struct crypto_bignum *b, 579 const struct crypto_bignum *c, 580 struct crypto_bignum *d); 581 582/** 583 * crypto_bignum_inverse - Inverse a bignum so that a * c = 1 (mod b) 584 * @a: Bignum 585 * @b: Bignum 586 * @c: Bignum; used to store the result 587 * Returns: 0 on success, -1 on failure 588 */ 589int crypto_bignum_inverse(const struct crypto_bignum *a, 590 const struct crypto_bignum *b, 591 struct crypto_bignum *c); 592 593/** 594 * crypto_bignum_sub - c = a - b 595 * @a: Bignum 596 * @b: Bignum 597 * @c: Bignum; used to store the result of a - b 598 * Returns: 0 on success, -1 on failure 599 */ 600int crypto_bignum_sub(const struct crypto_bignum *a, 601 const struct crypto_bignum *b, 602 struct crypto_bignum *c); 603 604/** 605 * crypto_bignum_div - c = a / b 606 * @a: Bignum 607 * @b: Bignum 608 * @c: Bignum; used to store the result of a / b 609 * Returns: 0 on success, -1 on failure 610 */ 611int crypto_bignum_div(const struct crypto_bignum *a, 612 const struct crypto_bignum *b, 613 struct crypto_bignum *c); 614 615/** 616 * crypto_bignum_mulmod - d = a * b (mod c) 617 * @a: Bignum 618 * @b: Bignum 619 * @c: Bignum 620 * @d: Bignum; used to store the result of (a * b) % c 621 * Returns: 0 on success, -1 on failure 622 */ 623int crypto_bignum_mulmod(const struct crypto_bignum *a, 624 const struct crypto_bignum *b, 625 const struct crypto_bignum *c, 626 struct crypto_bignum *d); 627 628/** 629 * crypto_bignum_rshift - r = a >> n 630 * @a: Bignum 631 * @n: Number of bits 632 * @r: Bignum; used to store the result of a >> n 633 * Returns: 0 on success, -1 on failure 634 */ 635int crypto_bignum_rshift(const struct crypto_bignum *a, int n, 636 struct crypto_bignum *r); 637 638/** 639 * crypto_bignum_cmp - Compare two bignums 640 * @a: Bignum 641 * @b: Bignum 642 * Returns: -1 if a < b, 0 if a == b, or 1 if a > b 643 */ 644int crypto_bignum_cmp(const struct crypto_bignum *a, 645 const struct crypto_bignum *b); 646 647/** 648 * crypto_bignum_bits - Get size of a bignum in bits 649 * @a: Bignum 650 * Returns: Number of bits in the bignum 651 */ 652int crypto_bignum_bits(const struct crypto_bignum *a); 653 654/** 655 * crypto_bignum_is_zero - Is the given bignum zero 656 * @a: Bignum 657 * Returns: 1 if @a is zero or 0 if not 658 */ 659int crypto_bignum_is_zero(const struct crypto_bignum *a); 660 661/** 662 * crypto_bignum_is_one - Is the given bignum one 663 * @a: Bignum 664 * Returns: 1 if @a is one or 0 if not 665 */ 666int crypto_bignum_is_one(const struct crypto_bignum *a); 667 668/** 669 * crypto_bignum_is_odd - Is the given bignum odd 670 * @a: Bignum 671 * Returns: 1 if @a is odd or 0 if not 672 */ 673int crypto_bignum_is_odd(const struct crypto_bignum *a); 674 675/** 676 * crypto_bignum_legendre - Compute the Legendre symbol (a/p) 677 * @a: Bignum 678 * @p: Bignum 679 * Returns: Legendre symbol -1,0,1 on success; -2 on calculation failure 680 */ 681int crypto_bignum_legendre(const struct crypto_bignum *a, 682 const struct crypto_bignum *p); 683 684/** 685 * struct crypto_ec - Elliptic curve context 686 * 687 * Internal data structure for EC implementation. The contents is specific 688 * to the used crypto library. 689 */ 690struct crypto_ec; 691 692/** 693 * crypto_ec_init - Initialize elliptic curve context 694 * @group: Identifying number for the ECC group (IANA "Group Description" 695 * attribute registrty for RFC 2409) 696 * Returns: Pointer to EC context or %NULL on failure 697 */ 698struct crypto_ec * crypto_ec_init(int group); 699 700/** 701 * crypto_ec_deinit - Deinitialize elliptic curve context 702 * @e: EC context from crypto_ec_init() 703 */ 704void crypto_ec_deinit(struct crypto_ec *e); 705 706/** 707 * crypto_ec_prime_len - Get length of the prime in octets 708 * @e: EC context from crypto_ec_init() 709 * Returns: Length of the prime defining the group 710 */ 711size_t crypto_ec_prime_len(struct crypto_ec *e); 712 713/** 714 * crypto_ec_prime_len_bits - Get length of the prime in bits 715 * @e: EC context from crypto_ec_init() 716 * Returns: Length of the prime defining the group in bits 717 */ 718size_t crypto_ec_prime_len_bits(struct crypto_ec *e); 719 720/** 721 * crypto_ec_order_len - Get length of the order in octets 722 * @e: EC context from crypto_ec_init() 723 * Returns: Length of the order defining the group 724 */ 725size_t crypto_ec_order_len(struct crypto_ec *e); 726 727/** 728 * crypto_ec_get_prime - Get prime defining an EC group 729 * @e: EC context from crypto_ec_init() 730 * Returns: Prime (bignum) defining the group 731 */ 732const struct crypto_bignum * crypto_ec_get_prime(struct crypto_ec *e); 733 734/** 735 * crypto_ec_get_order - Get order of an EC group 736 * @e: EC context from crypto_ec_init() 737 * Returns: Order (bignum) of the group 738 */ 739const struct crypto_bignum * crypto_ec_get_order(struct crypto_ec *e); 740 741/** 742 * struct crypto_ec_point - Elliptic curve point 743 * 744 * Internal data structure for EC implementation to represent a point. The 745 * contents is specific to the used crypto library. 746 */ 747struct crypto_ec_point; 748 749/** 750 * crypto_ec_point_init - Initialize data for an EC point 751 * @e: EC context from crypto_ec_init() 752 * Returns: Pointer to EC point data or %NULL on failure 753 */ 754struct crypto_ec_point * crypto_ec_point_init(struct crypto_ec *e); 755 756/** 757 * crypto_ec_point_deinit - Deinitialize EC point data 758 * @p: EC point data from crypto_ec_point_init() 759 * @clear: Whether to clear the EC point value from memory 760 */ 761void crypto_ec_point_deinit(struct crypto_ec_point *p, int clear); 762 763/** 764 * crypto_ec_point_x - Copies the x-ordinate point into big number 765 * @e: EC context from crypto_ec_init() 766 * @p: EC point data 767 * @x: Big number to set to the copy of x-ordinate 768 * Returns: 0 on success, -1 on failure 769 */ 770int crypto_ec_point_x(struct crypto_ec *e, const struct crypto_ec_point *p, 771 struct crypto_bignum *x); 772 773/** 774 * crypto_ec_point_to_bin - Write EC point value as binary data 775 * @e: EC context from crypto_ec_init() 776 * @p: EC point data from crypto_ec_point_init() 777 * @x: Buffer for writing the binary data for x coordinate or %NULL if not used 778 * @y: Buffer for writing the binary data for y coordinate or %NULL if not used 779 * Returns: 0 on success, -1 on failure 780 * 781 * This function can be used to write an EC point as binary data in a format 782 * that has the x and y coordinates in big endian byte order fields padded to 783 * the length of the prime defining the group. 784 */ 785int crypto_ec_point_to_bin(struct crypto_ec *e, 786 const struct crypto_ec_point *point, u8 *x, u8 *y); 787 788/** 789 * crypto_ec_point_from_bin - Create EC point from binary data 790 * @e: EC context from crypto_ec_init() 791 * @val: Binary data to read the EC point from 792 * Returns: Pointer to EC point data or %NULL on failure 793 * 794 * This function readers x and y coordinates of the EC point from the provided 795 * buffer assuming the values are in big endian byte order with fields padded to 796 * the length of the prime defining the group. 797 */ 798struct crypto_ec_point * crypto_ec_point_from_bin(struct crypto_ec *e, 799 const u8 *val); 800 801/** 802 * crypto_ec_point_add - c = a + b 803 * @e: EC context from crypto_ec_init() 804 * @a: Bignum 805 * @b: Bignum 806 * @c: Bignum; used to store the result of a + b 807 * Returns: 0 on success, -1 on failure 808 */ 809int crypto_ec_point_add(struct crypto_ec *e, const struct crypto_ec_point *a, 810 const struct crypto_ec_point *b, 811 struct crypto_ec_point *c); 812 813/** 814 * crypto_ec_point_mul - res = b * p 815 * @e: EC context from crypto_ec_init() 816 * @p: EC point 817 * @b: Bignum 818 * @res: EC point; used to store the result of b * p 819 * Returns: 0 on success, -1 on failure 820 */ 821int crypto_ec_point_mul(struct crypto_ec *e, const struct crypto_ec_point *p, 822 const struct crypto_bignum *b, 823 struct crypto_ec_point *res); 824 825/** 826 * crypto_ec_point_invert - Compute inverse of an EC point 827 * @e: EC context from crypto_ec_init() 828 * @p: EC point to invert (and result of the operation) 829 * Returns: 0 on success, -1 on failure 830 */ 831int crypto_ec_point_invert(struct crypto_ec *e, struct crypto_ec_point *p); 832 833/** 834 * crypto_ec_point_solve_y_coord - Solve y coordinate for an x coordinate 835 * @e: EC context from crypto_ec_init() 836 * @p: EC point to use for the returning the result 837 * @x: x coordinate 838 * @y_bit: y-bit (0 or 1) for selecting the y value to use 839 * Returns: 0 on success, -1 on failure 840 */ 841int crypto_ec_point_solve_y_coord(struct crypto_ec *e, 842 struct crypto_ec_point *p, 843 const struct crypto_bignum *x, int y_bit); 844 845/** 846 * crypto_ec_point_compute_y_sqr - Compute y^2 = x^3 + ax + b 847 * @e: EC context from crypto_ec_init() 848 * @x: x coordinate 849 * Returns: y^2 on success, %NULL failure 850 */ 851struct crypto_bignum * 852crypto_ec_point_compute_y_sqr(struct crypto_ec *e, 853 const struct crypto_bignum *x); 854 855/** 856 * crypto_ec_point_is_at_infinity - Check whether EC point is neutral element 857 * @e: EC context from crypto_ec_init() 858 * @p: EC point 859 * Returns: 1 if the specified EC point is the neutral element of the group or 860 * 0 if not 861 */ 862int crypto_ec_point_is_at_infinity(struct crypto_ec *e, 863 const struct crypto_ec_point *p); 864 865/** 866 * crypto_ec_point_is_on_curve - Check whether EC point is on curve 867 * @e: EC context from crypto_ec_init() 868 * @p: EC point 869 * Returns: 1 if the specified EC point is on the curve or 0 if not 870 */ 871int crypto_ec_point_is_on_curve(struct crypto_ec *e, 872 const struct crypto_ec_point *p); 873 874/** 875 * crypto_ec_point_cmp - Compare two EC points 876 * @e: EC context from crypto_ec_init() 877 * @a: EC point 878 * @b: EC point 879 * Returns: 0 on equal, non-zero otherwise 880 */ 881int crypto_ec_point_cmp(const struct crypto_ec *e, 882 const struct crypto_ec_point *a, 883 const struct crypto_ec_point *b); 884 885struct crypto_ecdh; 886 887struct crypto_ecdh * crypto_ecdh_init(int group); 888struct wpabuf * crypto_ecdh_get_pubkey(struct crypto_ecdh *ecdh, int inc_y); 889struct wpabuf * crypto_ecdh_set_peerkey(struct crypto_ecdh *ecdh, int inc_y, 890 const u8 *key, size_t len); 891void crypto_ecdh_deinit(struct crypto_ecdh *ecdh); 892 893#endif /* CRYPTO_H */ 894