contrib/wpa/src/crypto/crypto.h

   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 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  */
 496 int 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  */
 505 struct crypto_bignum;
 506
 507 /**
 508  * crypto_bignum_init - Allocate memory for bignum
 509  * Returns: Pointer to allocated bignum or %NULL on failure
 510  */
 511 struct 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  */
 519 struct 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  */
 526 void 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  */
 536 int 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  */
 545 int 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  */
 554 int 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  */
 565 int 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  */
 577 int 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  */
 589 int 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  */
 600 int 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  */
 611 int 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  */
 623 int 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  */
 635 int 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  */
 644 int 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  */
 652 int 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  */
 659 int 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  */
 666 int 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  */
 673 int 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  */
 681 int 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  */
 690 struct 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  */
 698 struct 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  */
 704 void 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  */
 711 size_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  */
 718 size_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  */
 725 size_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  */
 732 const 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  */
 739 const 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  */
 747 struct 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  */
 754 struct 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  */
 761 void 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  */
 770 int 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  */
 785 int 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  */
 798 struct 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  */
 809 int 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  */
 821 int 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  */
 831 int 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  */
 841 int 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  */
 851 struct crypto_bignum *
 852 crypto_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  */
 862 int 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  */
 871 int 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  */
 881 int crypto_ec_point_cmp(const struct crypto_ec *e,
 882                         const struct crypto_ec_point *a,
 883                         const struct crypto_ec_point *b);
 884
 885 struct crypto_ecdh;
 886
 887 struct crypto_ecdh * crypto_ecdh_init(int group);
 888 struct wpabuf * crypto_ecdh_get_pubkey(struct crypto_ecdh *ecdh, int inc_y);
 889 struct wpabuf * crypto_ecdh_set_peerkey(struct crypto_ecdh *ecdh, int inc_y,
 890                                         const u8 *key, size_t len);
 891 void crypto_ecdh_deinit(struct crypto_ecdh *ecdh);
 892
 893 #endif /* CRYPTO_H */