libeap/src/crypto/crypto.h

   1 /*
   2  * Wrapper functions for crypto libraries
   3  * Copyright (c) 2004-2013, 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  * des_encrypt - Encrypt one block with DES
  84  * @clear: 8 octets (in)
  85  * @key: 7 octets (in) (no parity bits included)
  86  * @cypher: 8 octets (out)
  87  */
  88 void des_encrypt(const u8 *clear, const u8 *key, u8 *cypher);
  89
  90 /**
  91  * aes_encrypt_init - Initialize AES for encryption
  92  * @key: Encryption key
  93  * @len: Key length in bytes (usually 16, i.e., 128 bits)
  94  * Returns: Pointer to context data or %NULL on failure
  95  */
  96 void * aes_encrypt_init(const u8 *key, size_t len);
  97
  98 /**
  99  * aes_encrypt - Encrypt one AES block
 100  * @ctx: Context pointer from aes_encrypt_init()
 101  * @plain: Plaintext data to be encrypted (16 bytes)
 102  * @crypt: Buffer for the encrypted data (16 bytes)
 103  */
 104 void aes_encrypt(void *ctx, const u8 *plain, u8 *crypt);
 105
 106 /**
 107  * aes_encrypt_deinit - Deinitialize AES encryption
 108  * @ctx: Context pointer from aes_encrypt_init()
 109  */
 110 void aes_encrypt_deinit(void *ctx);
 111
 112 /**
 113  * aes_decrypt_init - Initialize AES for decryption
 114  * @key: Decryption key
 115  * @len: Key length in bytes (usually 16, i.e., 128 bits)
 116  * Returns: Pointer to context data or %NULL on failure
 117  */
 118 void * aes_decrypt_init(const u8 *key, size_t len);
 119
 120 /**
 121  * aes_decrypt - Decrypt one AES block
 122  * @ctx: Context pointer from aes_encrypt_init()
 123  * @crypt: Encrypted data (16 bytes)
 124  * @plain: Buffer for the decrypted data (16 bytes)
 125  */
 126 void aes_decrypt(void *ctx, const u8 *crypt, u8 *plain);
 127
 128 /**
 129  * aes_decrypt_deinit - Deinitialize AES decryption
 130  * @ctx: Context pointer from aes_encrypt_init()
 131  */
 132 void aes_decrypt_deinit(void *ctx);
 133
 134
 135 enum crypto_hash_alg {
 136         CRYPTO_HASH_ALG_MD5, CRYPTO_HASH_ALG_SHA1,
 137         CRYPTO_HASH_ALG_HMAC_MD5, CRYPTO_HASH_ALG_HMAC_SHA1,
 138         CRYPTO_HASH_ALG_SHA256, CRYPTO_HASH_ALG_HMAC_SHA256
 139 };
 140
 141 struct crypto_hash;
 142
 143 /**
 144  * crypto_hash_init - Initialize hash/HMAC function
 145  * @alg: Hash algorithm
 146  * @key: Key for keyed hash (e.g., HMAC) or %NULL if not needed
 147  * @key_len: Length of the key in bytes
 148  * Returns: Pointer to hash context to use with other hash functions or %NULL
 149  * on failure
 150  *
 151  * This function is only used with internal TLSv1 implementation
 152  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 153  * to implement this.
 154  */
 155 struct crypto_hash * crypto_hash_init(enum crypto_hash_alg alg, const u8 *key,
 156                                       size_t key_len);
 157
 158 /**
 159  * crypto_hash_update - Add data to hash calculation
 160  * @ctx: Context pointer from crypto_hash_init()
 161  * @data: Data buffer to add
 162  * @len: Length of the buffer
 163  *
 164  * This function is only used with internal TLSv1 implementation
 165  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 166  * to implement this.
 167  */
 168 void crypto_hash_update(struct crypto_hash *ctx, const u8 *data, size_t len);
 169
 170 /**
 171  * crypto_hash_finish - Complete hash calculation
 172  * @ctx: Context pointer from crypto_hash_init()
 173  * @hash: Buffer for hash value or %NULL if caller is just freeing the hash
 174  * context
 175  * @len: Pointer to length of the buffer or %NULL if caller is just freeing the
 176  * hash context; on return, this is set to the actual length of the hash value
 177  * Returns: 0 on success, -1 if buffer is too small (len set to needed length),
 178  * or -2 on other failures (including failed crypto_hash_update() operations)
 179  *
 180  * This function calculates the hash value and frees the context buffer that
 181  * was used for hash calculation.
 182  *
 183  * This function is only used with internal TLSv1 implementation
 184  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 185  * to implement this.
 186  */
 187 int crypto_hash_finish(struct crypto_hash *ctx, u8 *hash, size_t *len);
 188
 189
 190 enum crypto_cipher_alg {
 191         CRYPTO_CIPHER_NULL = 0, CRYPTO_CIPHER_ALG_AES, CRYPTO_CIPHER_ALG_3DES,
 192         CRYPTO_CIPHER_ALG_DES, CRYPTO_CIPHER_ALG_RC2, CRYPTO_CIPHER_ALG_RC4
 193 };
 194
 195 struct crypto_cipher;
 196
 197 /**
 198  * crypto_cipher_init - Initialize block/stream cipher function
 199  * @alg: Cipher algorithm
 200  * @iv: Initialization vector for block ciphers or %NULL for stream ciphers
 201  * @key: Cipher key
 202  * @key_len: Length of key in bytes
 203  * Returns: Pointer to cipher context to use with other cipher functions or
 204  * %NULL on failure
 205  *
 206  * This function is only used with internal TLSv1 implementation
 207  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 208  * to implement this.
 209  */
 210 struct crypto_cipher * crypto_cipher_init(enum crypto_cipher_alg alg,
 211                                           const u8 *iv, const u8 *key,
 212                                           size_t key_len);
 213
 214 /**
 215  * crypto_cipher_encrypt - Cipher encrypt
 216  * @ctx: Context pointer from crypto_cipher_init()
 217  * @plain: Plaintext to cipher
 218  * @crypt: Resulting ciphertext
 219  * @len: Length of the plaintext
 220  * Returns: 0 on success, -1 on failure
 221  *
 222  * This function is only used with internal TLSv1 implementation
 223  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 224  * to implement this.
 225  */
 226 int __must_check crypto_cipher_encrypt(struct crypto_cipher *ctx,
 227                                        const u8 *plain, u8 *crypt, size_t len);
 228
 229 /**
 230  * crypto_cipher_decrypt - Cipher decrypt
 231  * @ctx: Context pointer from crypto_cipher_init()
 232  * @crypt: Ciphertext to decrypt
 233  * @plain: Resulting plaintext
 234  * @len: Length of the cipher text
 235  * Returns: 0 on success, -1 on failure
 236  *
 237  * This function is only used with internal TLSv1 implementation
 238  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 239  * to implement this.
 240  */
 241 int __must_check crypto_cipher_decrypt(struct crypto_cipher *ctx,
 242                                        const u8 *crypt, u8 *plain, size_t len);
 243
 244 /**
 245  * crypto_cipher_decrypt - Free cipher context
 246  * @ctx: Context pointer from crypto_cipher_init()
 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 void crypto_cipher_deinit(struct crypto_cipher *ctx);
 253
 254
 255 struct crypto_public_key;
 256 struct crypto_private_key;
 257
 258 /**
 259  * crypto_public_key_import - Import an RSA public key
 260  * @key: Key buffer (DER encoded RSA public key)
 261  * @len: Key buffer length in bytes
 262  * Returns: Pointer to the public key or %NULL on failure
 263  *
 264  * This function can just return %NULL if the crypto library supports X.509
 265  * parsing. In that case, crypto_public_key_from_cert() is used to import the
 266  * public key from a certificate.
 267  *
 268  * This function is only used with internal TLSv1 implementation
 269  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 270  * to implement this.
 271  */
 272 struct crypto_public_key * crypto_public_key_import(const u8 *key, size_t len);
 273
 274 struct crypto_public_key *
 275 crypto_public_key_import_parts(const u8 *n, size_t n_len,
 276                                const u8 *e, size_t e_len);
 277
 278 /**
 279  * crypto_private_key_import - Import an RSA private key
 280  * @key: Key buffer (DER encoded RSA private key)
 281  * @len: Key buffer length in bytes
 282  * @passwd: Key encryption password or %NULL if key is not encrypted
 283  * Returns: Pointer to the private key or %NULL on failure
 284  *
 285  * This function is only used with internal TLSv1 implementation
 286  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 287  * to implement this.
 288  */
 289 struct crypto_private_key * crypto_private_key_import(const u8 *key,
 290                                                       size_t len,
 291                                                       const char *passwd);
 292
 293 /**
 294  * crypto_public_key_from_cert - Import an RSA public key from a certificate
 295  * @buf: DER encoded X.509 certificate
 296  * @len: Certificate buffer length in bytes
 297  * Returns: Pointer to public key or %NULL on failure
 298  *
 299  * This function can just return %NULL if the crypto library does not support
 300  * X.509 parsing. In that case, internal code will be used to parse the
 301  * certificate and public key is imported using crypto_public_key_import().
 302  *
 303  * This function is only used with internal TLSv1 implementation
 304  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 305  * to implement this.
 306  */
 307 struct crypto_public_key * crypto_public_key_from_cert(const u8 *buf,
 308                                                        size_t len);
 309
 310 /**
 311  * crypto_public_key_encrypt_pkcs1_v15 - Public key encryption (PKCS #1 v1.5)
 312  * @key: Public key
 313  * @in: Plaintext buffer
 314  * @inlen: Length of plaintext buffer in bytes
 315  * @out: Output buffer for encrypted data
 316  * @outlen: Length of output buffer in bytes; set to used length on success
 317  * Returns: 0 on success, -1 on failure
 318  *
 319  * This function is only used with internal TLSv1 implementation
 320  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 321  * to implement this.
 322  */
 323 int __must_check crypto_public_key_encrypt_pkcs1_v15(
 324         struct crypto_public_key *key, const u8 *in, size_t inlen,
 325         u8 *out, size_t *outlen);
 326
 327 /**
 328  * crypto_private_key_decrypt_pkcs1_v15 - Private key decryption (PKCS #1 v1.5)
 329  * @key: Private key
 330  * @in: Encrypted buffer
 331  * @inlen: Length of encrypted buffer in bytes
 332  * @out: Output buffer for encrypted data
 333  * @outlen: Length of output buffer in bytes; set to used length on success
 334  * Returns: 0 on success, -1 on failure
 335  *
 336  * This function is only used with internal TLSv1 implementation
 337  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 338  * to implement this.
 339  */
 340 int __must_check crypto_private_key_decrypt_pkcs1_v15(
 341         struct crypto_private_key *key, const u8 *in, size_t inlen,
 342         u8 *out, size_t *outlen);
 343
 344 /**
 345  * crypto_private_key_sign_pkcs1 - Sign with private key (PKCS #1)
 346  * @key: Private key from crypto_private_key_import()
 347  * @in: Plaintext buffer
 348  * @inlen: Length of plaintext buffer in bytes
 349  * @out: Output buffer for encrypted (signed) data
 350  * @outlen: Length of output buffer in bytes; set to used length on success
 351  * Returns: 0 on success, -1 on failure
 352  *
 353  * This function is only used with internal TLSv1 implementation
 354  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 355  * to implement this.
 356  */
 357 int __must_check crypto_private_key_sign_pkcs1(struct crypto_private_key *key,
 358                                                const u8 *in, size_t inlen,
 359                                                u8 *out, size_t *outlen);
 360
 361 /**
 362  * crypto_public_key_free - Free public key
 363  * @key: Public key
 364  *
 365  * This function is only used with internal TLSv1 implementation
 366  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 367  * to implement this.
 368  */
 369 void crypto_public_key_free(struct crypto_public_key *key);
 370
 371 /**
 372  * crypto_private_key_free - Free private key
 373  * @key: Private key from crypto_private_key_import()
 374  *
 375  * This function is only used with internal TLSv1 implementation
 376  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 377  * to implement this.
 378  */
 379 void crypto_private_key_free(struct crypto_private_key *key);
 380
 381 /**
 382  * crypto_public_key_decrypt_pkcs1 - Decrypt PKCS #1 signature
 383  * @key: Public key
 384  * @crypt: Encrypted signature data (using the private key)
 385  * @crypt_len: Encrypted signature data length
 386  * @plain: Buffer for plaintext (at least crypt_len bytes)
 387  * @plain_len: Plaintext length (max buffer size on input, real len on output);
 388  * Returns: 0 on success, -1 on failure
 389  */
 390 int __must_check crypto_public_key_decrypt_pkcs1(
 391         struct crypto_public_key *key, const u8 *crypt, size_t crypt_len,
 392         u8 *plain, size_t *plain_len);
 393
 394 /**
 395  * crypto_global_init - Initialize crypto wrapper
 396  *
 397  * This function is only used with internal TLSv1 implementation
 398  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 399  * to implement this.
 400  */
 401 int __must_check crypto_global_init(void);
 402
 403 /**
 404  * crypto_global_deinit - Deinitialize crypto wrapper
 405  *
 406  * This function is only used with internal TLSv1 implementation
 407  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 408  * to implement this.
 409  */
 410 void crypto_global_deinit(void);
 411
 412 /**
 413  * crypto_mod_exp - Modular exponentiation of large integers
 414  * @base: Base integer (big endian byte array)
 415  * @base_len: Length of base integer in bytes
 416  * @power: Power integer (big endian byte array)
 417  * @power_len: Length of power integer in bytes
 418  * @modulus: Modulus integer (big endian byte array)
 419  * @modulus_len: Length of modulus integer in bytes
 420  * @result: Buffer for the result
 421  * @result_len: Result length (max buffer size on input, real len on output)
 422  * Returns: 0 on success, -1 on failure
 423  *
 424  * This function calculates result = base ^ power mod modulus. modules_len is
 425  * used as the maximum size of modulus buffer. It is set to the used size on
 426  * success.
 427  *
 428  * This function is only used with internal TLSv1 implementation
 429  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 430  * to implement this.
 431  */
 432 int __must_check crypto_mod_exp(const u8 *base, size_t base_len,
 433                                 const u8 *power, size_t power_len,
 434                                 const u8 *modulus, size_t modulus_len,
 435                                 u8 *result, size_t *result_len);
 436
 437 /**
 438  * rc4_skip - XOR RC4 stream to given data with skip-stream-start
 439  * @key: RC4 key
 440  * @keylen: RC4 key length
 441  * @skip: number of bytes to skip from the beginning of the RC4 stream
 442  * @data: data to be XOR'ed with RC4 stream
 443  * @data_len: buf length
 444  * Returns: 0 on success, -1 on failure
 445  *
 446  * Generate RC4 pseudo random stream for the given key, skip beginning of the
 447  * stream, and XOR the end result with the data buffer to perform RC4
 448  * encryption/decryption.
 449  */
 450 int rc4_skip(const u8 *key, size_t keylen, size_t skip,
 451              u8 *data, size_t data_len);
 452
 453 /**
 454  * crypto_get_random - Generate cryptographically strong pseudy-random bytes
 455  * @buf: Buffer for data
 456  * @len: Number of bytes to generate
 457  * Returns: 0 on success, -1 on failure
 458  *
 459  * If the PRNG does not have enough entropy to ensure unpredictable byte
 460  * sequence, this functions must return -1.
 461  */
 462 int crypto_get_random(void *buf, size_t len);
 463
 464
 465 /**
 466  * struct crypto_bignum - bignum
 467  *
 468  * Internal data structure for bignum implementation. The contents is specific
 469  * to the used crypto library.
 470  */
 471 struct crypto_bignum;
 472
 473 /**
 474  * crypto_bignum_init - Allocate memory for bignum
 475  * Returns: Pointer to allocated bignum or %NULL on failure
 476  */
 477 struct crypto_bignum * crypto_bignum_init(void);
 478
 479 /**
 480  * crypto_bignum_init_set - Allocate memory for bignum and set the value
 481  * @buf: Buffer with unsigned binary value
 482  * @len: Length of buf in octets
 483  * Returns: Pointer to allocated bignum or %NULL on failure
 484  */
 485 struct crypto_bignum * crypto_bignum_init_set(const u8 *buf, size_t len);
 486
 487 /**
 488  * crypto_bignum_deinit - Free bignum
 489  * @n: Bignum from crypto_bignum_init() or crypto_bignum_init_set()
 490  * @clear: Whether to clear the value from memory
 491  */
 492 void crypto_bignum_deinit(struct crypto_bignum *n, int clear);
 493
 494 /**
 495  * crypto_bignum_to_bin - Set binary buffer to unsigned bignum
 496  * @a: Bignum
 497  * @buf: Buffer for the binary number
 498  * @len: Length of @buf in octets
 499  * @padlen: Length in octets to pad the result to or 0 to indicate no padding
 500  * Returns: Number of octets written on success, -1 on failure
 501  */
 502 int crypto_bignum_to_bin(const struct crypto_bignum *a,
 503                          u8 *buf, size_t buflen, size_t padlen);
 504
 505 /**
 506  * crypto_bignum_add - c = a + b
 507  * @a: Bignum
 508  * @b: Bignum
 509  * @c: Bignum; used to store the result of a + b
 510  * Returns: 0 on success, -1 on failure
 511  */
 512 int crypto_bignum_add(const struct crypto_bignum *a,
 513                       const struct crypto_bignum *b,
 514                       struct crypto_bignum *c);
 515
 516 /**
 517  * crypto_bignum_mod - c = a % b
 518  * @a: Bignum
 519  * @b: Bignum
 520  * @c: Bignum; used to store the result of a % b
 521  * Returns: 0 on success, -1 on failure
 522  */
 523 int crypto_bignum_mod(const struct crypto_bignum *a,
 524                       const struct crypto_bignum *b,
 525                       struct crypto_bignum *c);
 526
 527 /**
 528  * crypto_bignum_exptmod - Modular exponentiation: d = a^b (mod c)
 529  * @a: Bignum; base
 530  * @b: Bignum; exponent
 531  * @c: Bignum; modulus
 532  * @d: Bignum; used to store the result of a^b (mod c)
 533  * Returns: 0 on success, -1 on failure
 534  */
 535 int crypto_bignum_exptmod(const struct crypto_bignum *a,
 536                           const struct crypto_bignum *b,
 537                           const struct crypto_bignum *c,
 538                           struct crypto_bignum *d);
 539
 540 /**
 541  * crypto_bignum_inverse - Inverse a bignum so that a * c = 1 (mod b)
 542  * @a: Bignum
 543  * @b: Bignum
 544  * @c: Bignum; used to store the result
 545  * Returns: 0 on success, -1 on failure
 546  */
 547 int crypto_bignum_inverse(const struct crypto_bignum *a,
 548                           const struct crypto_bignum *b,
 549                           struct crypto_bignum *c);
 550
 551 /**
 552  * crypto_bignum_sub - c = a - b
 553  * @a: Bignum
 554  * @b: Bignum
 555  * @c: Bignum; used to store the result of a - b
 556  * Returns: 0 on success, -1 on failure
 557  */
 558 int crypto_bignum_sub(const struct crypto_bignum *a,
 559                       const struct crypto_bignum *b,
 560                       struct crypto_bignum *c);
 561
 562 /**
 563  * crypto_bignum_div - c = a / b
 564  * @a: Bignum
 565  * @b: Bignum
 566  * @c: Bignum; used to store the result of a / b
 567  * Returns: 0 on success, -1 on failure
 568  */
 569 int crypto_bignum_div(const struct crypto_bignum *a,
 570                       const struct crypto_bignum *b,
 571                       struct crypto_bignum *c);
 572
 573 /**
 574  * crypto_bignum_mulmod - d = a * b (mod c)
 575  * @a: Bignum
 576  * @b: Bignum
 577  * @c: Bignum
 578  * @d: Bignum; used to store the result of (a * b) % c
 579  * Returns: 0 on success, -1 on failure
 580  */
 581 int crypto_bignum_mulmod(const struct crypto_bignum *a,
 582                          const struct crypto_bignum *b,
 583                          const struct crypto_bignum *c,
 584                          struct crypto_bignum *d);
 585
 586 /**
 587  * crypto_bignum_cmp - Compare two bignums
 588  * @a: Bignum
 589  * @b: Bignum
 590  * Returns: -1 if a < b, 0 if a == b, or 1 if a > b
 591  */
 592 int crypto_bignum_cmp(const struct crypto_bignum *a,
 593                       const struct crypto_bignum *b);
 594
 595 /**
 596  * crypto_bignum_bits - Get size of a bignum in bits
 597  * @a: Bignum
 598  * Returns: Number of bits in the bignum
 599  */
 600 int crypto_bignum_bits(const struct crypto_bignum *a);
 601
 602 /**
 603  * crypto_bignum_is_zero - Is the given bignum zero
 604  * @a: Bignum
 605  * Returns: 1 if @a is zero or 0 if not
 606  */
 607 int crypto_bignum_is_zero(const struct crypto_bignum *a);
 608
 609 /**
 610  * crypto_bignum_is_one - Is the given bignum one
 611  * @a: Bignum
 612  * Returns: 1 if @a is one or 0 if not
 613  */
 614 int crypto_bignum_is_one(const struct crypto_bignum *a);
 615
 616 /**
 617  * crypto_bignum_legendre - Compute the Legendre symbol (a/p)
 618  * @a: Bignum
 619  * @p: Bignum
 620  * Returns: Legendre symbol -1,0,1 on success; -2 on calculation failure
 621  */
 622 int crypto_bignum_legendre(const struct crypto_bignum *a,
 623                            const struct crypto_bignum *p);
 624
 625 /**
 626  * struct crypto_ec - Elliptic curve context
 627  *
 628  * Internal data structure for EC implementation. The contents is specific
 629  * to the used crypto library.
 630  */
 631 struct crypto_ec;
 632
 633 /**
 634  * crypto_ec_init - Initialize elliptic curve context
 635  * @group: Identifying number for the ECC group (IANA "Group Description"
 636  *      attribute registrty for RFC 2409)
 637  * Returns: Pointer to EC context or %NULL on failure
 638  */
 639 struct crypto_ec * crypto_ec_init(int group);
 640
 641 /**
 642  * crypto_ec_deinit - Deinitialize elliptic curve context
 643  * @e: EC context from crypto_ec_init()
 644  */
 645 void crypto_ec_deinit(struct crypto_ec *e);
 646
 647 /**
 648  * crypto_ec_prime_len - Get length of the prime in octets
 649  * @e: EC context from crypto_ec_init()
 650  * Returns: Length of the prime defining the group
 651  */
 652 size_t crypto_ec_prime_len(struct crypto_ec *e);
 653
 654 /**
 655  * crypto_ec_prime_len_bits - Get length of the prime in bits
 656  * @e: EC context from crypto_ec_init()
 657  * Returns: Length of the prime defining the group in bits
 658  */
 659 size_t crypto_ec_prime_len_bits(struct crypto_ec *e);
 660
 661 /**
 662  * crypto_ec_get_prime - Get prime defining an EC group
 663  * @e: EC context from crypto_ec_init()
 664  * Returns: Prime (bignum) defining the group
 665  */
 666 const struct crypto_bignum * crypto_ec_get_prime(struct crypto_ec *e);
 667
 668 /**
 669  * crypto_ec_get_order - Get order of an EC group
 670  * @e: EC context from crypto_ec_init()
 671  * Returns: Order (bignum) of the group
 672  */
 673 const struct crypto_bignum * crypto_ec_get_order(struct crypto_ec *e);
 674
 675 /**
 676  * struct crypto_ec_point - Elliptic curve point
 677  *
 678  * Internal data structure for EC implementation to represent a point. The
 679  * contents is specific to the used crypto library.
 680  */
 681 struct crypto_ec_point;
 682
 683 /**
 684  * crypto_ec_point_init - Initialize data for an EC point
 685  * @e: EC context from crypto_ec_init()
 686  * Returns: Pointer to EC point data or %NULL on failure
 687  */
 688 struct crypto_ec_point * crypto_ec_point_init(struct crypto_ec *e);
 689
 690 /**
 691  * crypto_ec_point_deinit - Deinitialize EC point data
 692  * @p: EC point data from crypto_ec_point_init()
 693  * @clear: Whether to clear the EC point value from memory
 694  */
 695 void crypto_ec_point_deinit(struct crypto_ec_point *p, int clear);
 696
 697 /**
 698  * crypto_ec_point_to_bin - Write EC point value as binary data
 699  * @e: EC context from crypto_ec_init()
 700  * @p: EC point data from crypto_ec_point_init()
 701  * @x: Buffer for writing the binary data for x coordinate or %NULL if not used
 702  * @y: Buffer for writing the binary data for y coordinate or %NULL if not used
 703  * Returns: 0 on success, -1 on failure
 704  *
 705  * This function can be used to write an EC point as binary data in a format
 706  * that has the x and y coordinates in big endian byte order fields padded to
 707  * the length of the prime defining the group.
 708  */
 709 int crypto_ec_point_to_bin(struct crypto_ec *e,
 710                            const struct crypto_ec_point *point, u8 *x, u8 *y);
 711
 712 /**
 713  * crypto_ec_point_from_bin - Create EC point from binary data
 714  * @e: EC context from crypto_ec_init()
 715  * @val: Binary data to read the EC point from
 716  * Returns: Pointer to EC point data or %NULL on failure
 717  *
 718  * This function readers x and y coordinates of the EC point from the provided
 719  * buffer assuming the values are in big endian byte order with fields padded to
 720  * the length of the prime defining the group.
 721  */
 722 struct crypto_ec_point * crypto_ec_point_from_bin(struct crypto_ec *e,
 723                                                   const u8 *val);
 724
 725 /**
 726  * crypto_bignum_add - c = a + b
 727  * @e: EC context from crypto_ec_init()
 728  * @a: Bignum
 729  * @b: Bignum
 730  * @c: Bignum; used to store the result of a + b
 731  * Returns: 0 on success, -1 on failure
 732  */
 733 int crypto_ec_point_add(struct crypto_ec *e, const struct crypto_ec_point *a,
 734                         const struct crypto_ec_point *b,
 735                         struct crypto_ec_point *c);
 736
 737 /**
 738  * crypto_bignum_mul - res = b * p
 739  * @e: EC context from crypto_ec_init()
 740  * @p: EC point
 741  * @b: Bignum
 742  * @res: EC point; used to store the result of b * p
 743  * Returns: 0 on success, -1 on failure
 744  */
 745 int crypto_ec_point_mul(struct crypto_ec *e, const struct crypto_ec_point *p,
 746                         const struct crypto_bignum *b,
 747                         struct crypto_ec_point *res);
 748
 749 /**
 750  * crypto_ec_point_invert - Compute inverse of an EC point
 751  * @e: EC context from crypto_ec_init()
 752  * @p: EC point to invert (and result of the operation)
 753  * Returns: 0 on success, -1 on failure
 754  */
 755 int crypto_ec_point_invert(struct crypto_ec *e, struct crypto_ec_point *p);
 756
 757 /**
 758  * crypto_ec_point_solve_y_coord - Solve y coordinate for an x coordinate
 759  * @e: EC context from crypto_ec_init()
 760  * @p: EC point to use for the returning the result
 761  * @x: x coordinate
 762  * @y_bit: y-bit (0 or 1) for selecting the y value to use
 763  * Returns: 0 on success, -1 on failure
 764  */
 765 int crypto_ec_point_solve_y_coord(struct crypto_ec *e,
 766                                   struct crypto_ec_point *p,
 767                                   const struct crypto_bignum *x, int y_bit);
 768
 769 /**
 770  * crypto_ec_point_compute_y_sqr - Compute y^2 = x^3 + ax + b
 771  * @e: EC context from crypto_ec_init()
 772  * @x: x coordinate
 773  * Returns: y^2 on success, %NULL failure
 774  */
 775 struct crypto_bignum *
 776 crypto_ec_point_compute_y_sqr(struct crypto_ec *e,
 777                               const struct crypto_bignum *x);
 778
 779 /**
 780  * crypto_ec_point_is_at_infinity - Check whether EC point is neutral element
 781  * @e: EC context from crypto_ec_init()
 782  * @p: EC point
 783  * Returns: 1 if the specified EC point is the neutral element of the group or
 784  *      0 if not
 785  */
 786 int crypto_ec_point_is_at_infinity(struct crypto_ec *e,
 787                                    const struct crypto_ec_point *p);
 788
 789 /**
 790  * crypto_ec_point_is_on_curve - Check whether EC point is on curve
 791  * @e: EC context from crypto_ec_init()
 792  * @p: EC point
 793  * Returns: 1 if the specified EC point is on the curve or 0 if not
 794  */
 795 int crypto_ec_point_is_on_curve(struct crypto_ec *e,
 796                                 const struct crypto_ec_point *p);
 797
 798 /**
 799  * crypto_ec_point_cmp - Compare two EC points
 800  * @e: EC context from crypto_ec_init()
 801  * @a: EC point
 802  * @b: EC point
 803  * Returns: 0 on equal, non-zero otherwise
 804  */
 805 int crypto_ec_point_cmp(const struct crypto_ec *e,
 806                         const struct crypto_ec_point *a,
 807                         const struct crypto_ec_point *b);
 808
 809 #endif /* CRYPTO_H */