Classes | Defines | Functions
crypto_cryptoapi.c File Reference
#include "includes.h"
#include <windows.h>
#include <wincrypt.h>
#include "common.h"
#include "crypto.h"
Include dependency graph for crypto_cryptoapi.c:

Go to the source code of this file.

Classes

struct  aes_context
struct  crypto_cipher
struct  crypto_hash
struct  crypto_private_key
struct  crypto_public_key

Defines

#define CALG_HMAC   (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_HMAC)
#define CRYPT_IPSEC_HMAC_KEY   0x00000100
#define MS_ENH_RSA_AES_PROV   "Microsoft Enhanced RSA and AES Cryptographic Provider (Prototype)"

Functions

void aes_decrypt (void *ctx, const u8 *crypt, u8 *plain)
void aes_decrypt_deinit (void *ctx)
void * aes_decrypt_init (const u8 *key, size_t len)
void aes_encrypt (void *ctx, const u8 *plain, u8 *crypt)
void aes_encrypt_deinit (void *ctx)
void * aes_encrypt_init (const u8 *key, size_t len)
int crypto_cipher_decrypt (struct crypto_cipher *ctx, const u8 *crypt, u8 *plain, size_t len)
void crypto_cipher_deinit (struct crypto_cipher *ctx)
int crypto_cipher_encrypt (struct crypto_cipher *ctx, const u8 *plain, u8 *crypt, size_t len)
struct crypto_ciphercrypto_cipher_init (enum crypto_cipher_alg alg, const u8 *iv, const u8 *key, size_t key_len)
void crypto_global_deinit (void)
int crypto_global_init (void)
int crypto_hash_finish (struct crypto_hash *ctx, u8 *mac, size_t *len)
struct crypto_hashcrypto_hash_init (enum crypto_hash_alg alg, const u8 *key, size_t key_len)
void crypto_hash_update (struct crypto_hash *ctx, const u8 *data, size_t len)
int crypto_mod_exp (const u8 *base, size_t base_len, const u8 *power, size_t power_len, const u8 *modulus, size_t modulus_len, u8 *result, size_t *result_len)
void crypto_private_key_free (struct crypto_private_key *key)
struct crypto_private_keycrypto_private_key_import (const u8 *key, size_t len, const char *passwd)
int crypto_private_key_sign_pkcs1 (struct crypto_private_key *key, const u8 *in, size_t inlen, u8 *out, size_t *outlen)
int crypto_public_key_encrypt_pkcs1_v15 (struct crypto_public_key *key, const u8 *in, size_t inlen, u8 *out, size_t *outlen)
void crypto_public_key_free (struct crypto_public_key *key)
struct crypto_public_keycrypto_public_key_from_cert (const u8 *buf, size_t len)
struct crypto_public_keycrypto_public_key_import (const u8 *key, size_t len)
int cryptoapi_hash_vector (ALG_ID alg, size_t hash_len, size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
static void cryptoapi_report_error (const char *msg)
void des_encrypt (const u8 *clear, const u8 *key, u8 *cypher)
int md4_vector (size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
int md5_vector (size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
static int mingw_load_crypto_func (void)
int sha1_vector (size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)

Define Documentation

#define CALG_HMAC   (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_HMAC)

Definition at line 33 of file crypto_cryptoapi.c.

#define CRYPT_IPSEC_HMAC_KEY   0x00000100
#define MS_ENH_RSA_AES_PROV   "Microsoft Enhanced RSA and AES Cryptographic Provider (Prototype)"

Definition at line 27 of file crypto_cryptoapi.c.


Function Documentation

void aes_decrypt ( void *  ctx,
const u8 *  crypt,
u8 *  plain 
)

aes_decrypt - Decrypt one AES block : Context pointer from aes_encrypt_init() : Encrypted data (16 bytes) : Buffer for the decrypted data (16 bytes)

Definition at line 329 of file crypto_cryptoapi.c.

void aes_decrypt_deinit ( void *  ctx)

aes_decrypt_deinit - Deinitialize AES decryption : Context pointer from aes_encrypt_init()

Definition at line 344 of file crypto_cryptoapi.c.

void* aes_decrypt_init ( const u8 *  key,
size_t  len 
)

aes_decrypt_init - Initialize AES for decryption : Decryption key : Key length in bytes (usually 16, i.e., 128 bits) Returns: Pointer to context data or NULL on failure

Definition at line 323 of file crypto_cryptoapi.c.

void aes_encrypt ( void *  ctx,
const u8 *  plain,
u8 *  crypt 
)

aes_encrypt - Encrypt one AES block : Context pointer from aes_encrypt_init() : Plaintext data to be encrypted (16 bytes) : Buffer for the encrypted data (16 bytes)

Definition at line 297 of file crypto_cryptoapi.c.

void aes_encrypt_deinit ( void *  ctx)

aes_encrypt_deinit - Deinitialize AES encryption : Context pointer from aes_encrypt_init()

Definition at line 312 of file crypto_cryptoapi.c.

void* aes_encrypt_init ( const u8 *  key,
size_t  len 
)

aes_encrypt_init - Initialize AES for encryption : Encryption key : Key length in bytes (usually 16, i.e., 128 bits) Returns: Pointer to context data or NULL on failure

Definition at line 242 of file crypto_cryptoapi.c.

int crypto_cipher_decrypt ( struct crypto_cipher ctx,
const u8 *  crypt,
u8 *  plain,
size_t  len 
)

crypto_cipher_decrypt - Cipher decrypt : Context pointer from crypto_cipher_init() : Ciphertext to decrypt : Resulting plaintext : Length of the cipher text Returns: 0 on success, -1 on failure

This function is only used with internal TLSv1 implementation (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need to implement this.

Definition at line 613 of file crypto_cryptoapi.c.

void crypto_cipher_deinit ( struct crypto_cipher ctx)

crypto_cipher_decrypt - Free cipher context : Context pointer from crypto_cipher_init()

This function is only used with internal TLSv1 implementation (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need to implement this.

Definition at line 629 of file crypto_cryptoapi.c.

int crypto_cipher_encrypt ( struct crypto_cipher ctx,
const u8 *  plain,
u8 *  crypt,
size_t  len 
)

crypto_cipher_encrypt - Cipher encrypt : Context pointer from crypto_cipher_init() : Plaintext to cipher : Resulting ciphertext : Length of the plaintext Returns: 0 on success, -1 on failure

This function is only used with internal TLSv1 implementation (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need to implement this.

Definition at line 596 of file crypto_cryptoapi.c.

struct crypto_cipher* crypto_cipher_init ( enum crypto_cipher_alg  alg,
const u8 *  iv,
const u8 *  key,
size_t  key_len 
) [read]

crypto_cipher_init - Initialize block/stream cipher function : Cipher algorithm : Initialization vector for block ciphers or NULL for stream ciphers : Cipher key : Length of key in bytes Returns: Pointer to cipher context to use with other cipher functions or NULL on failure

This function is only used with internal TLSv1 implementation (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need to implement this.

Definition at line 513 of file crypto_cryptoapi.c.

void crypto_global_deinit ( void  )

crypto_global_deinit - Deinitialize crypto wrapper

This function is only used with internal TLSv1 implementation (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need to implement this.

Definition at line 777 of file crypto_cryptoapi.c.

int crypto_global_init ( void  )

crypto_global_init - Initialize crypto wrapper

This function is only used with internal TLSv1 implementation (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need to implement this.

Definition at line 771 of file crypto_cryptoapi.c.

int crypto_hash_finish ( struct crypto_hash ctx,
u8 *  hash,
size_t *  len 
)

crypto_hash_finish - Complete hash calculation : Context pointer from crypto_hash_init() : Buffer for hash value or NULL if caller is just freeing the hash context : Pointer to length of the buffer or NULL if caller is just freeing the hash context; on return, this is set to the actual length of the hash value Returns: 0 on success, -1 if buffer is too small (len set to needed length), or -2 on other failures (including failed crypto_hash_update() operations)

This function calculates the hash value and frees the context buffer that was used for hash calculation.

This function is only used with internal TLSv1 implementation (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need to implement this.

Definition at line 473 of file crypto_cryptoapi.c.

struct crypto_hash* crypto_hash_init ( enum crypto_hash_alg  alg,
const u8 *  key,
size_t  key_len 
) [read]

crypto_hash_init - Initialize hash/HMAC function : Hash algorithm : Key for keyed hash (e.g., HMAC) or NULL if not needed : Length of the key in bytes Returns: Pointer to hash context to use with other hash functions or NULL on failure

This function is only used with internal TLSv1 implementation (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need to implement this.

Definition at line 358 of file crypto_cryptoapi.c.

void crypto_hash_update ( struct crypto_hash ctx,
const u8 *  data,
size_t  len 
)

crypto_hash_update - Add data to hash calculation : Context pointer from crypto_hash_init() : Data buffer to add : Length of the buffer

This function is only used with internal TLSv1 implementation (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need to implement this.

Definition at line 461 of file crypto_cryptoapi.c.

int crypto_mod_exp ( const u8 *  base,
size_t  base_len,
const u8 *  power,
size_t  power_len,
const u8 *  modulus,
size_t  modulus_len,
u8 *  result,
size_t *  result_len 
)

crypto_mod_exp - Modular exponentiation of large integers : Base integer (big endian byte array) : Length of base integer in bytes : Power integer (big endian byte array) : Length of power integer in bytes : Modulus integer (big endian byte array) : Length of modulus integer in bytes

Returns:
: Buffer for the result : Result length (max buffer size on input, real len on output) Returns: 0 on success, -1 on failure

This function calculates result = base ^ power mod modulus. modules_len is used as the maximum size of modulus buffer. It is set to the used size on success.

This function is only used with internal TLSv1 implementation (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need to implement this.

Definition at line 782 of file crypto_cryptoapi.c.

crypto_private_key_free - Free private key : Private key from crypto_private_key_import()

This function is only used with internal TLSv1 implementation (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need to implement this.

Definition at line 761 of file crypto_cryptoapi.c.

struct crypto_private_key* crypto_private_key_import ( const u8 *  key,
size_t  len,
const char *  passwd 
) [read]

crypto_private_key_import - Import an RSA private key : Key buffer (DER encoded RSA private key) : Key buffer length in bytes : Key encryption password or NULL if key is not encrypted Returns: Pointer to the private key or NULL on failure

This function is only used with internal TLSv1 implementation (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need to implement this.

Definition at line 655 of file crypto_cryptoapi.c.

int crypto_private_key_sign_pkcs1 ( struct crypto_private_key key,
const u8 *  in,
size_t  inlen,
u8 *  out,
size_t *  outlen 
)

crypto_private_key_sign_pkcs1 - Sign with private key (PKCS #1) : Private key from crypto_private_key_import() : Plaintext buffer : Length of plaintext buffer in bytes : Output buffer for encrypted (signed) data : Length of output buffer in bytes; set to used length on success Returns: 0 on success, -1 on failure

This function is only used with internal TLSv1 implementation (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need to implement this.

Definition at line 742 of file crypto_cryptoapi.c.

int crypto_public_key_encrypt_pkcs1_v15 ( struct crypto_public_key key,
const u8 *  in,
size_t  inlen,
u8 *  out,
size_t *  outlen 
)

crypto_public_key_encrypt_pkcs1_v15 - Public key encryption (PKCS #1 v1.5) : Public key : Plaintext buffer : Length of plaintext buffer in bytes : Output buffer for encrypted data : Length of output buffer in bytes; set to used length on success Returns: 0 on success, -1 on failure

This function is only used with internal TLSv1 implementation (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need to implement this.

Definition at line 707 of file crypto_cryptoapi.c.

void crypto_public_key_free ( struct crypto_public_key key)

crypto_public_key_free - Free public key : Public key

This function is only used with internal TLSv1 implementation (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need to implement this.

Definition at line 751 of file crypto_cryptoapi.c.

struct crypto_public_key* crypto_public_key_from_cert ( const u8 *  buf,
size_t  len 
) [read]

crypto_public_key_from_cert - Import an RSA public key from a certificate : DER encoded X.509 certificate : Certificate buffer length in bytes Returns: Pointer to public key or NULL on failure

This function can just return NULL if the crypto library does not support X.509 parsing. In that case, internal code will be used to parse the certificate and public key is imported using crypto_public_key_import().

This function is only used with internal TLSv1 implementation (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need to implement this.

Definition at line 664 of file crypto_cryptoapi.c.

struct crypto_public_key* crypto_public_key_import ( const u8 *  key,
size_t  len 
) [read]

crypto_public_key_import - Import an RSA public key : Key buffer (DER encoded RSA public key) : Key buffer length in bytes Returns: Pointer to the public key or NULL on failure

This function can just return NULL if the crypto library supports X.509 parsing. In that case, crypto_public_key_from_cert() is used to import the public key from a certificate.

This function is only used with internal TLSv1 implementation (CONFIG_TLS=internal). If that is not used, the crypto wrapper does not need to implement this.

Definition at line 648 of file crypto_cryptoapi.c.

int cryptoapi_hash_vector ( ALG_ID  alg,
size_t  hash_len,
size_t  num_elem,
const u8 *  addr[],
const size_t *  len,
u8 *  mac 
)

Definition at line 112 of file crypto_cryptoapi.c.

static void cryptoapi_report_error ( const char *  msg) [static]

Definition at line 87 of file crypto_cryptoapi.c.

void des_encrypt ( const u8 *  clear,
const u8 *  key,
u8 *  cypher 
)

des_encrypt - Encrypt one block with DES : 8 octets (in) : 7 octets (in) (no parity bits included) : 8 octets (out)

Definition at line 159 of file crypto_cryptoapi.c.

int md4_vector ( size_t  num_elem,
const u8 *  addr[],
const size_t *  len,
u8 *  mac 
)

md4_vector - MD4 hash for data vector : Number of elements in the data vector : Pointers to the data areas : Lengths of the data blocks : Buffer for the hash Returns: 0 on success, -1 on failure

Definition at line 153 of file crypto_cryptoapi.c.

int md5_vector ( size_t  num_elem,
const u8 *  addr[],
const size_t *  len,
u8 *  mac 
)

md5_vector - MD5 hash for data vector : Number of elements in the data vector : Pointers to the data areas : Lengths of the data blocks : Buffer for the hash Returns: 0 on success, -1 on failure

Definition at line 224 of file crypto_cryptoapi.c.

static int mingw_load_crypto_func ( void  ) [static]

Definition at line 79 of file crypto_cryptoapi.c.

int sha1_vector ( size_t  num_elem,
const u8 *  addr[],
const size_t *  len,
u8 *  mac 
)

sha1_vector - SHA-1 hash for data vector : Number of elements in the data vector : Pointers to the data areas : Lengths of the data blocks : Buffer for the hash Returns: 0 on success, -1 on failure

Definition at line 230 of file crypto_cryptoapi.c.



wpa_supplicant_node
Author(s): Package maintained by Blaise Gassend
autogenerated on Thu Jan 2 2014 11:25:16