eyefi.h-Dateireferenz

#include <stddef.h>
#include <stdlib.h>

Include-Abhängigkeitsdiagramm für eyefi.h:

Dieser Graph zeigt, welche Datei direkt oder indirekt diese Datei enthält:

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	host_to_be32(n)   __builtin_bswap32(n)
#define	os_memset   memset
#define	os_memcpy   memcpy
#define	os_strlen   strlen
#define	os_strcpy   strcpy
#define	SHA1_MAC_LEN   20
#define	MD5_MAC_LEN   16

Typdefinitionen
typedef unsigned int	u32
typedef unsigned short	u16
typedef unsigned char	u8

Funktionen
void	md5_vector (size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
void	hmac_md5_vector (const u8 *key, size_t key_len, size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
void	hmac_md5 (const u8 *key, size_t key_len, const u8 *data, size_t data_len, u8 *mac)
void	pbkdf2_sha1 (const char *passphrase, const char *ssid, size_t ssid_len, int iterations, u8 *buf, size_t buflen)

Makro-Dokumentation

#define host_to_be32

(

n)

__builtin_bswap32(n)

Definiert in Zeile 22 der Datei eyefi.h.

#define MD5_MAC_LEN   16

Definiert in Zeile 30 der Datei eyefi.h.

#define os_memcpy   memcpy

Definiert in Zeile 25 der Datei eyefi.h.

#define os_memset   memset

Definiert in Zeile 24 der Datei eyefi.h.

#define os_strcpy   strcpy

Definiert in Zeile 27 der Datei eyefi.h.

#define os_strlen   strlen

Definiert in Zeile 26 der Datei eyefi.h.

#define SHA1_MAC_LEN   20

Definiert in Zeile 29 der Datei eyefi.h.

Dokumentation der benutzerdefinierten Typen

typedef unsigned short u16

Definiert in Zeile 18 der Datei eyefi.h.

typedef unsigned int u32

Definiert in Zeile 17 der Datei eyefi.h.

typedef unsigned char u8

Definiert in Zeile 19 der Datei eyefi.h.

Dokumentation der Funktionen

void hmac_md5	(	const u8 *	key,
		size_t	key_len,
		const u8 *	data,
		size_t	data_len,
		u8 *	mac
	)

hmac_md5 - HMAC-MD5 over data buffer (RFC 2104) : Key for HMAC operations : Length of the key in bytes : Pointers to the data area : Length of the data area : Buffer for the hash (16 bytes)

Definiert in Zeile 102 der Datei md5.c.

{
    hmac_md5_vector(key, key_len, 1, &data, &data_len, mac);
}

void hmac_md5_vector	(	const u8 *	key,
		size_t	key_len,
		size_t	num_elem,
		const u8 *	addr[],
		const size_t *	len,
		u8 *	mac
	)

hmac_md5_vector - HMAC-MD5 over data vector (RFC 2104) : Key for HMAC operations : Length of the key in bytes : Number of elements in the data vector : Pointers to the data areas : Lengths of the data blocks : Buffer for the hash (16 bytes)

Definiert in Zeile 30 der Datei md5.c.

{
    u8 k_pad[64]; /* padding - key XORd with ipad/opad */
    u8 tk[16];
    const u8 *_addr[6];
    size_t i, _len[6];

    if (num_elem > 5) {
        /*
         * Fixed limit on the number of fragments to avoid having to
         * allocate memory (which could fail).
         */
        return;
    }

        /* if key is longer than 64 bytes reset it to key = MD5(key) */
        if (key_len > 64) {
        md5_vector(1, &key, &key_len, tk);
        key = tk;
        key_len = 16;
        }

    /* the HMAC_MD5 transform looks like:
     *
     * MD5(K XOR opad, MD5(K XOR ipad, text))
     *
     * where K is an n byte key
     * ipad is the byte 0x36 repeated 64 times
     * opad is the byte 0x5c repeated 64 times
     * and text is the data being protected */

    /* start out by storing key in ipad */
    os_memset(k_pad, 0, sizeof(k_pad));
    os_memcpy(k_pad, key, key_len);

    /* XOR key with ipad values */
    for (i = 0; i < 64; i++)
        k_pad[i] ^= 0x36;

    /* perform inner MD5 */
    _addr[0] = k_pad;
    _len[0] = 64;
    for (i = 0; i < num_elem; i++) {
        _addr[i + 1] = addr[i];
        _len[i + 1] = len[i];
    }
    md5_vector(1 + num_elem, _addr, _len, mac);

    os_memset(k_pad, 0, sizeof(k_pad));
    os_memcpy(k_pad, key, key_len);
    /* XOR key with opad values */
    for (i = 0; i < 64; i++)
        k_pad[i] ^= 0x5c;

    /* perform outer MD5 */
    _addr[0] = k_pad;
    _len[0] = 64;
    _addr[1] = mac;
    _len[1] = MD5_MAC_LEN;
    md5_vector(2, _addr, _len, mac);
}

void 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

Definiert in Zeile 137 der Datei md5.c.

{
    MD5_CTX ctx;
    size_t i;

    MD5Init(&ctx);
    for (i = 0; i < num_elem; i++)
        MD5Update(&ctx, addr[i], len[i]);
    MD5Final(mac, &ctx);
}

void pbkdf2_sha1	(	const char *	passphrase,
		const char *	ssid,
		size_t	ssid_len,
		int	iterations,
		u8 *	buf,
		size_t	buflen
	)

pbkdf2_sha1 - SHA1-based key derivation function (PBKDF2) for IEEE 802.11i : ASCII passphrase : SSID : SSID length in bytes : Number of iterations to run : Buffer for the generated key : Length of the buffer in bytes

This function is used to derive PSK for WPA-PSK. For this protocol, iterations is set to 4096 and buflen to 32. This function is described in IEEE Std 802.11-2004, Clause H.4. The main construction is from PKCS#5 v2.0.

Definiert in Zeile 352 der Datei sha1.c.

{
    unsigned int count = 0;
    unsigned char *pos = buf;
    size_t left = buflen, plen;
    unsigned char digest[SHA1_MAC_LEN];

    while (left > 0) {
        count++;
        pbkdf2_sha1_f(passphrase, ssid, ssid_len, iterations, count,
                  digest);
        plen = left > SHA1_MAC_LEN ? SHA1_MAC_LEN : left;
        memcpy(pos, digest, plen);
        pos += plen;
        left -= plen;
    }
}