dist/wpa/src/crypto/crypto.h

   1 /*
   2  * WPA Supplicant / wrapper functions for crypto libraries
   3  * Copyright (c) 2004-2007, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  *
  14  * This file defines the cryptographic functions that need to be implemented
  15  * for wpa_supplicant and hostapd. When TLS is not used, internal
  16  * implementation of MD5, SHA1, and AES is used and no external libraries are
  17  * required. When TLS is enabled (e.g., by enabling EAP-TLS or EAP-PEAP), the
  18  * crypto library used by the TLS implementation is expected to be used for
  19  * non-TLS needs, too, in order to save space by not implementing these
  20  * functions twice.
  21  *
  22  * Wrapper code for using each crypto library is in its own file (crypto*.c)
  23  * and one of these files is build and linked in to provide the functions
  24  * defined here.
  25  */
  26
  27 #ifndef CRYPTO_H
  28 #define CRYPTO_H
  29
  30 /**
  31  * md4_vector - MD4 hash for data vector
  32  * @num_elem: Number of elements in the data vector
  33  * @addr: Pointers to the data areas
  34  * @len: Lengths of the data blocks
  35  * @mac: Buffer for the hash
  36  */
  37 void md4_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac);
  38
  39 /**
  40  * md5_vector - MD5 hash for data vector
  41  * @num_elem: Number of elements in the data vector
  42  * @addr: Pointers to the data areas
  43  * @len: Lengths of the data blocks
  44  * @mac: Buffer for the hash
  45  */
  46 void md5_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac);
  47
  48 /**
  49  * sha1_vector - SHA-1 hash for data vector
  50  * @num_elem: Number of elements in the data vector
  51  * @addr: Pointers to the data areas
  52  * @len: Lengths of the data blocks
  53  * @mac: Buffer for the hash
  54  */
  55 void sha1_vector(size_t num_elem, const u8 *addr[], const size_t *len,
  56                  u8 *mac);
  57
  58 /**
  59  * fips186_2-prf - NIST FIPS Publication 186-2 change notice 1 PRF
  60  * @seed: Seed/key for the PRF
  61  * @seed_len: Seed length in bytes
  62  * @x: Buffer for PRF output
  63  * @xlen: Output length in bytes
  64  * Returns: 0 on success, -1 on failure
  65  *
  66  * This function implements random number generation specified in NIST FIPS
  67  * Publication 186-2 for EAP-SIM. This PRF uses a function that is similar to
  68  * SHA-1, but has different message padding.
  69  */
  70 int __must_check fips186_2_prf(const u8 *seed, size_t seed_len, u8 *x,
  71                                size_t xlen);
  72
  73 /**
  74  * sha256_vector - SHA256 hash for data vector
  75  * @num_elem: Number of elements in the data vector
  76  * @addr: Pointers to the data areas
  77  * @len: Lengths of the data blocks
  78  * @mac: Buffer for the hash
  79  */
  80 void sha256_vector(size_t num_elem, const u8 *addr[], const size_t *len,
  81                    u8 *mac);
  82
  83 /**
  84  * des_encrypt - Encrypt one block with DES
  85  * @clear: 8 octets (in)
  86  * @key: 7 octets (in) (no parity bits included)
  87  * @cypher: 8 octets (out)
  88  */
  89 void des_encrypt(const u8 *clear, const u8 *key, u8 *cypher);
  90
  91 /**
  92  * aes_encrypt_init - Initialize AES for encryption
  93  * @key: Encryption key
  94  * @len: Key length in bytes (usually 16, i.e., 128 bits)
  95  * Returns: Pointer to context data or %NULL on failure
  96  */
  97 void * aes_encrypt_init(const u8 *key, size_t len);
  98
  99 /**
 100  * aes_encrypt - Encrypt one AES block
 101  * @ctx: Context pointer from aes_encrypt_init()
 102  * @plain: Plaintext data to be encrypted (16 bytes)
 103  * @crypt: Buffer for the encrypted data (16 bytes)
 104  */
 105 void aes_encrypt(void *ctx, const u8 *plain, u8 *crypt);
 106
 107 /**
 108  * aes_encrypt_deinit - Deinitialize AES encryption
 109  * @ctx: Context pointer from aes_encrypt_init()
 110  */
 111 void aes_encrypt_deinit(void *ctx);
 112
 113 /**
 114  * aes_decrypt_init - Initialize AES for decryption
 115  * @key: Decryption 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_decrypt_init(const u8 *key, size_t len);
 120
 121 /**
 122  * aes_decrypt - Decrypt one AES block
 123  * @ctx: Context pointer from aes_encrypt_init()
 124  * @crypt: Encrypted data (16 bytes)
 125  * @plain: Buffer for the decrypted data (16 bytes)
 126  */
 127 void aes_decrypt(void *ctx, const u8 *crypt, u8 *plain);
 128
 129 /**
 130  * aes_decrypt_deinit - Deinitialize AES decryption
 131  * @ctx: Context pointer from aes_encrypt_init()
 132  */
 133 void aes_decrypt_deinit(void *ctx);
 134
 135
 136 enum crypto_hash_alg {
 137         CRYPTO_HASH_ALG_MD5, CRYPTO_HASH_ALG_SHA1,
 138         CRYPTO_HASH_ALG_HMAC_MD5, CRYPTO_HASH_ALG_HMAC_SHA1
 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 /**
 275  * crypto_private_key_import - Import an RSA private key
 276  * @key: Key buffer (DER encoded RSA private key)
 277  * @len: Key buffer length in bytes
 278  * Returns: Pointer to the private key or %NULL on failure
 279  *
 280  * This function is only used with internal TLSv1 implementation
 281  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 282  * to implement this.
 283  */
 284 struct crypto_private_key * crypto_private_key_import(const u8 *key,
 285                                                       size_t len);
 286
 287 /**
 288  * crypto_public_key_from_cert - Import an RSA public key from a certificate
 289  * @buf: DER encoded X.509 certificate
 290  * @len: Certificate buffer length in bytes
 291  * Returns: Pointer to public key or %NULL on failure
 292  *
 293  * This function can just return %NULL if the crypto library does not support
 294  * X.509 parsing. In that case, internal code will be used to parse the
 295  * certificate and public key is imported using crypto_public_key_import().
 296  *
 297  * This function is only used with internal TLSv1 implementation
 298  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 299  * to implement this.
 300  */
 301 struct crypto_public_key * crypto_public_key_from_cert(const u8 *buf,
 302                                                        size_t len);
 303
 304 /**
 305  * crypto_public_key_encrypt_pkcs1_v15 - Public key encryption (PKCS #1 v1.5)
 306  * @key: Public key
 307  * @in: Plaintext buffer
 308  * @inlen: Length of plaintext buffer in bytes
 309  * @out: Output buffer for encrypted data
 310  * @outlen: Length of output buffer in bytes; set to used length on success
 311  * Returns: 0 on success, -1 on failure
 312  *
 313  * This function is only used with internal TLSv1 implementation
 314  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 315  * to implement this.
 316  */
 317 int __must_check crypto_public_key_encrypt_pkcs1_v15(
 318         struct crypto_public_key *key, const u8 *in, size_t inlen,
 319         u8 *out, size_t *outlen);
 320
 321 /**
 322  * crypto_private_key_decrypt_pkcs1_v15 - Private key decryption (PKCS #1 v1.5)
 323  * @key: Private key
 324  * @in: Encrypted buffer
 325  * @inlen: Length of encrypted buffer in bytes
 326  * @out: Output buffer for encrypted data
 327  * @outlen: Length of output buffer in bytes; set to used length on success
 328  * Returns: 0 on success, -1 on failure
 329  *
 330  * This function is only used with internal TLSv1 implementation
 331  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 332  * to implement this.
 333  */
 334 int __must_check crypto_private_key_decrypt_pkcs1_v15(
 335         struct crypto_private_key *key, const u8 *in, size_t inlen,
 336         u8 *out, size_t *outlen);
 337
 338 /**
 339  * crypto_private_key_sign_pkcs1 - Sign with private key (PKCS #1)
 340  * @key: Private key from crypto_private_key_import()
 341  * @in: Plaintext buffer
 342  * @inlen: Length of plaintext buffer in bytes
 343  * @out: Output buffer for encrypted (signed) data
 344  * @outlen: Length of output buffer in bytes; set to used length on success
 345  * Returns: 0 on success, -1 on failure
 346  *
 347  * This function is only used with internal TLSv1 implementation
 348  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 349  * to implement this.
 350  */
 351 int __must_check crypto_private_key_sign_pkcs1(struct crypto_private_key *key,
 352                                                const u8 *in, size_t inlen,
 353                                                u8 *out, size_t *outlen);
 354
 355 /**
 356  * crypto_public_key_free - Free public key
 357  * @key: Public key
 358  *
 359  * This function is only used with internal TLSv1 implementation
 360  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 361  * to implement this.
 362  */
 363 void crypto_public_key_free(struct crypto_public_key *key);
 364
 365 /**
 366  * crypto_private_key_free - Free private key
 367  * @key: Private key from crypto_private_key_import()
 368  *
 369  * This function is only used with internal TLSv1 implementation
 370  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 371  * to implement this.
 372  */
 373 void crypto_private_key_free(struct crypto_private_key *key);
 374
 375 /**
 376  * crypto_public_key_decrypt_pkcs1 - Decrypt PKCS #1 signature
 377  * @key: Public key
 378  * @crypt: Encrypted signature data (using the private key)
 379  * @crypt_len: Encrypted signature data length
 380  * @plain: Buffer for plaintext (at least crypt_len bytes)
 381  * @plain_len: Plaintext length (max buffer size on input, real len on output);
 382  * Returns: 0 on success, -1 on failure
 383  */
 384 int __must_check crypto_public_key_decrypt_pkcs1(
 385         struct crypto_public_key *key, const u8 *crypt, size_t crypt_len,
 386         u8 *plain, size_t *plain_len);
 387
 388 /**
 389  * crypto_global_init - Initialize crypto wrapper
 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 int __must_check crypto_global_init(void);
 396
 397 /**
 398  * crypto_global_deinit - Deinitialize crypto wrapper
 399  *
 400  * This function is only used with internal TLSv1 implementation
 401  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 402  * to implement this.
 403  */
 404 void crypto_global_deinit(void);
 405
 406 /**
 407  * crypto_mod_exp - Modular exponentiation of large integers
 408  * @base: Base integer (big endian byte array)
 409  * @base_len: Length of base integer in bytes
 410  * @power: Power integer (big endian byte array)
 411  * @power_len: Length of power integer in bytes
 412  * @modulus: Modulus integer (big endian byte array)
 413  * @modulus_len: Length of modulus integer in bytes
 414  * @result: Buffer for the result
 415  * @result_len: Result length (max buffer size on input, real len on output)
 416  * Returns: 0 on success, -1 on failure
 417  *
 418  * This function calculates result = base ^ power mod modulus. modules_len is
 419  * used as the maximum size of modulus buffer. It is set to the used size on
 420  * success.
 421  *
 422  * This function is only used with internal TLSv1 implementation
 423  * (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need
 424  * to implement this.
 425  */
 426 int __must_check crypto_mod_exp(const u8 *base, size_t base_len,
 427                                 const u8 *power, size_t power_len,
 428                                 const u8 *modulus, size_t modulus_len,
 429                                 u8 *result, size_t *result_len);
 430
 431 #endif /* CRYPTO_H */