2 * Wrapper functions for crypto libraries
3 * Copyright (c) 2004-2017, Jouni Malinen <j@w1.fi>
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
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
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
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
32 int md4_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac);
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
42 int md5_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac);
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
53 int sha1_vector(size_t num_elem, const u8 *addr[], const size_t *len,
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
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.
68 int __must_check fips186_2_prf(const u8 *seed, size_t seed_len, u8 *x,
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
79 int sha256_vector(size_t num_elem, const u8 *addr[], const size_t *len,
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
90 int sha384_vector(size_t num_elem, const u8 *addr[], const size_t *len,
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
101 int sha512_vector(size_t num_elem, const u8 *addr[], const size_t *len,
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
111 int des_encrypt(const u8 *clear, const u8 *key, u8 *cypher);
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
119 void * aes_encrypt_init(const u8 *key, size_t len);
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
128 int aes_encrypt(void *ctx, const u8 *plain, u8 *crypt);
131 * aes_encrypt_deinit - Deinitialize AES encryption
132 * @ctx: Context pointer from aes_encrypt_init()
134 void aes_encrypt_deinit(void *ctx);
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
142 void * aes_decrypt_init(const u8 *key, size_t len);
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
151 int aes_decrypt(void *ctx, const u8 *crypt, u8 *plain);
154 * aes_decrypt_deinit - Deinitialize AES decryption
155 * @ctx: Context pointer from aes_encrypt_init()
157 void aes_decrypt_deinit(void *ctx);
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
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
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
181 struct crypto_hash * crypto_hash_init(enum crypto_hash_alg alg, const u8 *key,
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
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
194 void crypto_hash_update(struct crypto_hash *ctx, const u8 *data, size_t len);
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
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)
206 * This function calculates the hash value and frees the context buffer that
207 * was used for hash calculation.
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
213 int crypto_hash_finish(struct crypto_hash *ctx, u8 *hash, size_t *len);
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
221 struct crypto_cipher;
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
228 * @key_len: Length of key in bytes
229 * Returns: Pointer to cipher context to use with other cipher functions or
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
236 struct crypto_cipher * crypto_cipher_init(enum crypto_cipher_alg alg,
237 const u8 *iv, const u8 *key,
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
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
252 int __must_check crypto_cipher_encrypt(struct crypto_cipher *ctx,
253 const u8 *plain, u8 *crypt, size_t len);
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
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
267 int __must_check crypto_cipher_decrypt(struct crypto_cipher *ctx,
268 const u8 *crypt, u8 *plain, size_t len);
271 * crypto_cipher_decrypt - Free cipher context
272 * @ctx: Context pointer from crypto_cipher_init()
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
278 void crypto_cipher_deinit(struct crypto_cipher *ctx);
281 struct crypto_public_key;
282 struct crypto_private_key;
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
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.
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
298 struct crypto_public_key * crypto_public_key_import(const u8 *key, size_t len);
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);
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
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
315 struct crypto_private_key * crypto_private_key_import(const u8 *key,
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
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().
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
333 struct crypto_public_key * crypto_public_key_from_cert(const u8 *buf,
337 * crypto_public_key_encrypt_pkcs1_v15 - Public key encryption (PKCS #1 v1.5)
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
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
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);
354 * crypto_private_key_decrypt_pkcs1_v15 - Private key decryption (PKCS #1 v1.5)
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
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
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);
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
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
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);
388 * crypto_public_key_free - Free public key
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
395 void crypto_public_key_free(struct crypto_public_key *key);
398 * crypto_private_key_free - Free private key
399 * @key: Private key from crypto_private_key_import()
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
405 void crypto_private_key_free(struct crypto_private_key *key);
408 * crypto_public_key_decrypt_pkcs1 - Decrypt PKCS #1 signature
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
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);
420 int crypto_dh_init(u8 generator, const u8 *prime, size_t prime_len, u8 *privkey,
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);
429 * crypto_global_init - Initialize crypto wrapper
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
435 int __must_check crypto_global_init(void);
438 * crypto_global_deinit - Deinitialize crypto wrapper
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
444 void crypto_global_deinit(void);
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
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
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
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);
472 * rc4_skip - XOR RC4 stream to given data with skip-stream-start
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
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.
484 int rc4_skip(const u8 *key, size_t keylen, size_t skip,
485 u8 *data, size_t data_len);
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
493 * If the PRNG does not have enough entropy to ensure unpredictable byte
494 * sequence, this functions must return -1.
496 int crypto_get_random(void *buf, size_t len);
500 * struct crypto_bignum - bignum
502 * Internal data structure for bignum implementation. The contents is specific
503 * to the used crypto library.
505 struct crypto_bignum;
508 * crypto_bignum_init - Allocate memory for bignum
509 * Returns: Pointer to allocated bignum or %NULL on failure
511 struct crypto_bignum * crypto_bignum_init(void);
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
519 struct crypto_bignum * crypto_bignum_init_set(const u8 *buf, size_t len);
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
526 void crypto_bignum_deinit(struct crypto_bignum *n, int clear);
529 * crypto_bignum_to_bin - Set binary buffer to unsigned 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
536 int crypto_bignum_to_bin(const struct crypto_bignum *a,
537 u8 *buf, size_t buflen, size_t padlen);
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
545 int crypto_bignum_rand(struct crypto_bignum *r, const struct crypto_bignum *m);
548 * crypto_bignum_add - c = a + b
551 * @c: Bignum; used to store the result of a + b
552 * Returns: 0 on success, -1 on failure
554 int crypto_bignum_add(const struct crypto_bignum *a,
555 const struct crypto_bignum *b,
556 struct crypto_bignum *c);
559 * crypto_bignum_mod - c = a % b
562 * @c: Bignum; used to store the result of a % b
563 * Returns: 0 on success, -1 on failure
565 int crypto_bignum_mod(const struct crypto_bignum *a,
566 const struct crypto_bignum *b,
567 struct crypto_bignum *c);
570 * crypto_bignum_exptmod - Modular exponentiation: d = a^b (mod c)
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
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);
583 * crypto_bignum_inverse - Inverse a bignum so that a * c = 1 (mod b)
586 * @c: Bignum; used to store the result
587 * Returns: 0 on success, -1 on failure
589 int crypto_bignum_inverse(const struct crypto_bignum *a,
590 const struct crypto_bignum *b,
591 struct crypto_bignum *c);
594 * crypto_bignum_sub - c = a - b
597 * @c: Bignum; used to store the result of a - b
598 * Returns: 0 on success, -1 on failure
600 int crypto_bignum_sub(const struct crypto_bignum *a,
601 const struct crypto_bignum *b,
602 struct crypto_bignum *c);
605 * crypto_bignum_div - c = a / b
608 * @c: Bignum; used to store the result of a / b
609 * Returns: 0 on success, -1 on failure
611 int crypto_bignum_div(const struct crypto_bignum *a,
612 const struct crypto_bignum *b,
613 struct crypto_bignum *c);
616 * crypto_bignum_mulmod - d = a * b (mod c)
620 * @d: Bignum; used to store the result of (a * b) % c
621 * Returns: 0 on success, -1 on failure
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);
629 * crypto_bignum_rshift - r = a >> n
632 * @r: Bignum; used to store the result of a >> n
633 * Returns: 0 on success, -1 on failure
635 int crypto_bignum_rshift(const struct crypto_bignum *a, int n,
636 struct crypto_bignum *r);
639 * crypto_bignum_cmp - Compare two bignums
642 * Returns: -1 if a < b, 0 if a == b, or 1 if a > b
644 int crypto_bignum_cmp(const struct crypto_bignum *a,
645 const struct crypto_bignum *b);
648 * crypto_bignum_is_zero - Is the given bignum zero
650 * Returns: 1 if @a is zero or 0 if not
652 int crypto_bignum_is_zero(const struct crypto_bignum *a);
655 * crypto_bignum_is_one - Is the given bignum one
657 * Returns: 1 if @a is one or 0 if not
659 int crypto_bignum_is_one(const struct crypto_bignum *a);
662 * crypto_bignum_is_odd - Is the given bignum odd
664 * Returns: 1 if @a is odd or 0 if not
666 int crypto_bignum_is_odd(const struct crypto_bignum *a);
669 * crypto_bignum_legendre - Compute the Legendre symbol (a/p)
672 * Returns: Legendre symbol -1,0,1 on success; -2 on calculation failure
674 int crypto_bignum_legendre(const struct crypto_bignum *a,
675 const struct crypto_bignum *p);
678 * struct crypto_ec - Elliptic curve context
680 * Internal data structure for EC implementation. The contents is specific
681 * to the used crypto library.
686 * crypto_ec_init - Initialize elliptic curve context
687 * @group: Identifying number for the ECC group (IANA "Group Description"
688 * attribute registrty for RFC 2409)
689 * Returns: Pointer to EC context or %NULL on failure
691 struct crypto_ec * crypto_ec_init(int group);
694 * crypto_ec_deinit - Deinitialize elliptic curve context
695 * @e: EC context from crypto_ec_init()
697 void crypto_ec_deinit(struct crypto_ec *e);
700 * crypto_ec_prime_len - Get length of the prime in octets
701 * @e: EC context from crypto_ec_init()
702 * Returns: Length of the prime defining the group
704 size_t crypto_ec_prime_len(struct crypto_ec *e);
707 * crypto_ec_prime_len_bits - Get length of the prime in bits
708 * @e: EC context from crypto_ec_init()
709 * Returns: Length of the prime defining the group in bits
711 size_t crypto_ec_prime_len_bits(struct crypto_ec *e);
714 * crypto_ec_order_len - Get length of the order in octets
715 * @e: EC context from crypto_ec_init()
716 * Returns: Length of the order defining the group
718 size_t crypto_ec_order_len(struct crypto_ec *e);
721 * crypto_ec_get_prime - Get prime defining an EC group
722 * @e: EC context from crypto_ec_init()
723 * Returns: Prime (bignum) defining the group
725 const struct crypto_bignum * crypto_ec_get_prime(struct crypto_ec *e);
728 * crypto_ec_get_order - Get order of an EC group
729 * @e: EC context from crypto_ec_init()
730 * Returns: Order (bignum) of the group
732 const struct crypto_bignum * crypto_ec_get_order(struct crypto_ec *e);
735 * struct crypto_ec_point - Elliptic curve point
737 * Internal data structure for EC implementation to represent a point. The
738 * contents is specific to the used crypto library.
740 struct crypto_ec_point;
743 * crypto_ec_point_init - Initialize data for an EC point
744 * @e: EC context from crypto_ec_init()
745 * Returns: Pointer to EC point data or %NULL on failure
747 struct crypto_ec_point * crypto_ec_point_init(struct crypto_ec *e);
750 * crypto_ec_point_deinit - Deinitialize EC point data
751 * @p: EC point data from crypto_ec_point_init()
752 * @clear: Whether to clear the EC point value from memory
754 void crypto_ec_point_deinit(struct crypto_ec_point *p, int clear);
757 * crypto_ec_point_x - Copies the x-ordinate point into big number
758 * @e: EC context from crypto_ec_init()
760 * @x: Big number to set to the copy of x-ordinate
761 * Returns: 0 on success, -1 on failure
763 int crypto_ec_point_x(struct crypto_ec *e, const struct crypto_ec_point *p,
764 struct crypto_bignum *x);
767 * crypto_ec_point_to_bin - Write EC point value as binary data
768 * @e: EC context from crypto_ec_init()
769 * @p: EC point data from crypto_ec_point_init()
770 * @x: Buffer for writing the binary data for x coordinate or %NULL if not used
771 * @y: Buffer for writing the binary data for y coordinate or %NULL if not used
772 * Returns: 0 on success, -1 on failure
774 * This function can be used to write an EC point as binary data in a format
775 * that has the x and y coordinates in big endian byte order fields padded to
776 * the length of the prime defining the group.
778 int crypto_ec_point_to_bin(struct crypto_ec *e,
779 const struct crypto_ec_point *point, u8 *x, u8 *y);
782 * crypto_ec_point_from_bin - Create EC point from binary data
783 * @e: EC context from crypto_ec_init()
784 * @val: Binary data to read the EC point from
785 * Returns: Pointer to EC point data or %NULL on failure
787 * This function readers x and y coordinates of the EC point from the provided
788 * buffer assuming the values are in big endian byte order with fields padded to
789 * the length of the prime defining the group.
791 struct crypto_ec_point * crypto_ec_point_from_bin(struct crypto_ec *e,
795 * crypto_ec_point_add - c = a + b
796 * @e: EC context from crypto_ec_init()
799 * @c: Bignum; used to store the result of a + b
800 * Returns: 0 on success, -1 on failure
802 int crypto_ec_point_add(struct crypto_ec *e, const struct crypto_ec_point *a,
803 const struct crypto_ec_point *b,
804 struct crypto_ec_point *c);
807 * crypto_ec_point_mul - res = b * p
808 * @e: EC context from crypto_ec_init()
811 * @res: EC point; used to store the result of b * p
812 * Returns: 0 on success, -1 on failure
814 int crypto_ec_point_mul(struct crypto_ec *e, const struct crypto_ec_point *p,
815 const struct crypto_bignum *b,
816 struct crypto_ec_point *res);
819 * crypto_ec_point_invert - Compute inverse of an EC point
820 * @e: EC context from crypto_ec_init()
821 * @p: EC point to invert (and result of the operation)
822 * Returns: 0 on success, -1 on failure
824 int crypto_ec_point_invert(struct crypto_ec *e, struct crypto_ec_point *p);
827 * crypto_ec_point_solve_y_coord - Solve y coordinate for an x coordinate
828 * @e: EC context from crypto_ec_init()
829 * @p: EC point to use for the returning the result
831 * @y_bit: y-bit (0 or 1) for selecting the y value to use
832 * Returns: 0 on success, -1 on failure
834 int crypto_ec_point_solve_y_coord(struct crypto_ec *e,
835 struct crypto_ec_point *p,
836 const struct crypto_bignum *x, int y_bit);
839 * crypto_ec_point_compute_y_sqr - Compute y^2 = x^3 + ax + b
840 * @e: EC context from crypto_ec_init()
842 * Returns: y^2 on success, %NULL failure
844 struct crypto_bignum *
845 crypto_ec_point_compute_y_sqr(struct crypto_ec *e,
846 const struct crypto_bignum *x);
849 * crypto_ec_point_is_at_infinity - Check whether EC point is neutral element
850 * @e: EC context from crypto_ec_init()
852 * Returns: 1 if the specified EC point is the neutral element of the group or
855 int crypto_ec_point_is_at_infinity(struct crypto_ec *e,
856 const struct crypto_ec_point *p);
859 * crypto_ec_point_is_on_curve - Check whether EC point is on curve
860 * @e: EC context from crypto_ec_init()
862 * Returns: 1 if the specified EC point is on the curve or 0 if not
864 int crypto_ec_point_is_on_curve(struct crypto_ec *e,
865 const struct crypto_ec_point *p);
868 * crypto_ec_point_cmp - Compare two EC points
869 * @e: EC context from crypto_ec_init()
872 * Returns: 0 on equal, non-zero otherwise
874 int crypto_ec_point_cmp(const struct crypto_ec *e,
875 const struct crypto_ec_point *a,
876 const struct crypto_ec_point *b);
880 struct crypto_ecdh * crypto_ecdh_init(int group);
881 struct wpabuf * crypto_ecdh_get_pubkey(struct crypto_ecdh *ecdh, int inc_y);
882 struct wpabuf * crypto_ecdh_set_peerkey(struct crypto_ecdh *ecdh, int inc_y,
883 const u8 *key, size_t len);
884 void crypto_ecdh_deinit(struct crypto_ecdh *ecdh);
886 #endif /* CRYPTO_H */