CHDK_DE Vorschauversion  Trunk Rev. 5218
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
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.

104 {
105  hmac_md5_vector(key, key_len, 1, &data, &data_len, mac);
106 }
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.

32 {
33  u8 k_pad[64]; /* padding - key XORd with ipad/opad */
34  u8 tk[16];
35  const u8 *_addr[6];
36  size_t i, _len[6];
37 
38  if (num_elem > 5) {
39  /*
40  * Fixed limit on the number of fragments to avoid having to
41  * allocate memory (which could fail).
42  */
43  return;
44  }
45 
46  /* if key is longer than 64 bytes reset it to key = MD5(key) */
47  if (key_len > 64) {
48  md5_vector(1, &key, &key_len, tk);
49  key = tk;
50  key_len = 16;
51  }
52 
53  /* the HMAC_MD5 transform looks like:
54  *
55  * MD5(K XOR opad, MD5(K XOR ipad, text))
56  *
57  * where K is an n byte key
58  * ipad is the byte 0x36 repeated 64 times
59  * opad is the byte 0x5c repeated 64 times
60  * and text is the data being protected */
61 
62  /* start out by storing key in ipad */
63  os_memset(k_pad, 0, sizeof(k_pad));
64  os_memcpy(k_pad, key, key_len);
65 
66  /* XOR key with ipad values */
67  for (i = 0; i < 64; i++)
68  k_pad[i] ^= 0x36;
69 
70  /* perform inner MD5 */
71  _addr[0] = k_pad;
72  _len[0] = 64;
73  for (i = 0; i < num_elem; i++) {
74  _addr[i + 1] = addr[i];
75  _len[i + 1] = len[i];
76  }
77  md5_vector(1 + num_elem, _addr, _len, mac);
78 
79  os_memset(k_pad, 0, sizeof(k_pad));
80  os_memcpy(k_pad, key, key_len);
81  /* XOR key with opad values */
82  for (i = 0; i < 64; i++)
83  k_pad[i] ^= 0x5c;
84 
85  /* perform outer MD5 */
86  _addr[0] = k_pad;
87  _len[0] = 64;
88  _addr[1] = mac;
89  _len[1] = MD5_MAC_LEN;
90  md5_vector(2, _addr, _len, mac);
91 }
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.

138 {
139  MD5_CTX ctx;
140  size_t i;
141 
142  MD5Init(&ctx);
143  for (i = 0; i < num_elem; i++)
144  MD5Update(&ctx, addr[i], len[i]);
145  MD5Final(mac, &ctx);
146 }
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.

354 {
355  unsigned int count = 0;
356  unsigned char *pos = buf;
357  size_t left = buflen, plen;
358  unsigned char digest[SHA1_MAC_LEN];
359 
360  while (left > 0) {
361  count++;
362  pbkdf2_sha1_f(passphrase, ssid, ssid_len, iterations, count,
363  digest);
364  plen = left > SHA1_MAC_LEN ? SHA1_MAC_LEN : left;
365  memcpy(pos, digest, plen);
366  pos += plen;
367  left -= plen;
368  }
369 }