diff options
author | Gerald Combs <gerald@wireshark.org> | 2007-01-02 22:49:57 +0000 |
---|---|---|
committer | Gerald Combs <gerald@wireshark.org> | 2007-01-02 22:49:57 +0000 |
commit | 53689800e6eff70913b237b513ab5db7ce742da2 (patch) | |
tree | 67e32c486f4dfc1e2784b27c71eb2aadb8a2dd09 /epan/crypt | |
parent | 77694f8b8e69ac9c074e0ff1076bcda0a9a6877d (diff) | |
download | wireshark-53689800e6eff70913b237b513ab5db7ce742da2.tar.gz |
Move epan/crypt-md5.[ch] to epan/crypt. Remove
epan/crypt/airpdcap_md5.[ch]. Fix up whitespace.
svn path=/trunk/; revision=20277
Diffstat (limited to 'epan/crypt')
-rw-r--r-- | epan/crypt/Makefile.common | 6 | ||||
-rw-r--r-- | epan/crypt/airpdcap.c | 35 | ||||
-rw-r--r-- | epan/crypt/airpdcap_md5.c | 450 | ||||
-rw-r--r-- | epan/crypt/airpdcap_md5.h | 0 | ||||
-rw-r--r-- | epan/crypt/airpdcap_system.h | 90 | ||||
-rw-r--r-- | epan/crypt/crypt-md5.c | 449 | ||||
-rw-r--r-- | epan/crypt/crypt-md5.h | 94 |
7 files changed, 598 insertions, 526 deletions
diff --git a/epan/crypt/Makefile.common b/epan/crypt/Makefile.common index bcf3d28c9e..15ec8e226b 100644 --- a/epan/crypt/Makefile.common +++ b/epan/crypt/Makefile.common @@ -27,18 +27,17 @@ LIBAIRPDCAP_SRC = \ airpdcap.c \ airpdcap_ccmp.c \ airpdcap_debug.c \ - airpdcap_md5.c \ airpdcap_rijndael.c \ airpdcap_sha1.c \ airpdcap_tkip.c \ - airpdcap_wep.c + airpdcap_wep.c \ + crypt-md5.c LIBAIRPDCAP_INCLUDES = \ airpdcap_ccmp.h \ airpdcap_debug.h \ airpdcap_interop.h \ airpdcap_int.h \ - airpdcap_md5.h \ airpdcap_rijndael.h \ airpdcap_sha1.h \ airpdcap_system.h \ @@ -46,4 +45,5 @@ LIBAIRPDCAP_INCLUDES = \ airpdcap_user.h \ airpdcap_wep.h \ airpdcap_ws.h \ + crypt-md5.h \ wep-wpadefs.h diff --git a/epan/crypt/airpdcap.c b/epan/crypt/airpdcap.c index 88ee57d24e..ce4909549b 100644 --- a/epan/crypt/airpdcap.c +++ b/epan/crypt/airpdcap.c @@ -6,6 +6,7 @@ #include "airpdcap_wep.h" #include "airpdcap_sha1.h" +#include "crypt-md5.h" #include "airpdcap_debug.h" @@ -151,9 +152,9 @@ INT AirPDcapValidateKey( INT AirPDcapRsnaMicCheck( UCHAR *eapol, - const USHORT eapol_len, - const UCHAR KCK[AIRPDCAP_WPA_KCK_LEN], - const USHORT key_ver) + USHORT eapol_len, + UCHAR KCK[AIRPDCAP_WPA_KCK_LEN], + USHORT key_ver) ; /** @@ -317,12 +318,12 @@ INT AirPDcapPacketProcess( /* check if the packet as an LLC header and the packet is 802.1X authentication (IEEE 802.1X-2004, pg. 24) */ if (data[offset]==0xAA && /* DSAP=SNAP */ - data[offset+1]==0xAA && /* SSAP=SNAP */ - data[offset+2]==0x03 && /* Control field=Unnumbered frame */ - data[offset+3]==0x00 && /* Org. code=encaps. Ethernet */ + data[offset+1]==0xAA && /* SSAP=SNAP */ + data[offset+2]==0x03 && /* Control field=Unnumbered frame */ + data[offset+3]==0x00 && /* Org. code=encaps. Ethernet */ data[offset+4]==0x00 && data[offset+5]==0x00 && - data[offset+6]==0x88 && /* Type: 802.1X authentication */ + data[offset+6]==0x88 && /* Type: 802.1X authentication */ data[offset+7]==0x8E) { AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "Authentication: EAPOL packet", AIRPDCAP_DEBUG_LEVEL_3); @@ -967,30 +968,30 @@ INT AirPDcapRsna4WHandshake( INT AirPDcapRsnaMicCheck( UCHAR *eapol, - const USHORT eapol_len, - const UCHAR KCK[AIRPDCAP_WPA_KCK_LEN], - const USHORT key_ver) + USHORT eapol_len, + UCHAR KCK[AIRPDCAP_WPA_KCK_LEN], + USHORT key_ver) { UCHAR mic[AIRPDCAP_WPA_MICKEY_LEN]; - UCHAR c_mic[20]; /* MIC 16 byte, the HMAC-SHA1 use a buffer of 20 bytes */ + UCHAR c_mic[20]; /* MIC 16 byte, the HMAC-SHA1 use a buffer of 20 bytes */ /* copy the MIC from the EAPOL packet */ memcpy(mic, eapol+AIRPDCAP_WPA_MICKEY_OFFSET+4, AIRPDCAP_WPA_MICKEY_LEN); - /* set to 0 the MIC in the EAPOL packet (to calculate the MIC) */ + /* set to 0 the MIC in the EAPOL packet (to calculate the MIC) */ memset(eapol+AIRPDCAP_WPA_MICKEY_OFFSET+4, 0, AIRPDCAP_WPA_MICKEY_LEN); if (key_ver==AIRPDCAP_WPA_KEY_VER_CCMP) { - /* use HMAC-MD5 for the EAPOL-Key MIC */ - AirPDcapAlgHmacMd5((UCHAR *)KCK, AIRPDCAP_WPA_KCK_LEN, eapol, eapol_len, c_mic); + /* use HMAC-MD5 for the EAPOL-Key MIC */ + md5_hmac(eapol, eapol_len, KCK, AIRPDCAP_WPA_KCK_LEN, c_mic); } else if (key_ver==AIRPDCAP_WPA_KEY_VER_AES_CCMP) { - /* use HMAC-SHA1-128 for the EAPOL-Key MIC */ + /* use HMAC-SHA1-128 for the EAPOL-Key MIC */ AirPDcapAlgHmacSha1(KCK, AIRPDCAP_WPA_KCK_LEN, eapol, eapol_len, c_mic); } else - /* key descriptor version not recognized */ + /* key descriptor version not recognized */ return AIRPDCAP_RET_UNSUCCESS; - /* compare calculated MIC with the Key MIC and return result (0 means success) */ + /* compare calculated MIC with the Key MIC and return result (0 means success) */ return memcmp(mic, c_mic, AIRPDCAP_WPA_MICKEY_LEN); } diff --git a/epan/crypt/airpdcap_md5.c b/epan/crypt/airpdcap_md5.c deleted file mode 100644 index aa7a6727ac..0000000000 --- a/epan/crypt/airpdcap_md5.c +++ /dev/null @@ -1,450 +0,0 @@ -/******************************************************************************/ -/* File includes */ -/* */ -#include "airpdcap_system.h" -#include "airpdcap_int.h" - -#include "airpdcap_debug.h" -/* */ -/******************************************************************************/ - -/******************************************************************************/ -/* NOTE: All the code listed here has been taken from IETF RFC 1321 (MD5 */ -/* functions) and IETF RFC 2104 (HMAC_MD5 function). Refer to that */ -/* standard for any further information. */ -/******************************************************************************/ - -/******************************************************************************/ -/* Internal definitions */ -/* */ -#define S11 7 -#define S12 12 -#define S13 17 -#define S14 22 -#define S21 5 -#define S22 9 -#define S23 14 -#define S24 20 -#define S31 4 -#define S32 11 -#define S33 16 -#define S34 23 -#define S41 6 -#define S42 10 -#define S43 15 -#define S44 21 -/* */ -/******************************************************************************/ - -/******************************************************************************/ -/* Internal macros */ -/* */ -/* F, G, H and I are basic MD5 functions. -*/ -#define F(x, y, z) (((x) & (y)) | ((~x) & (z))) -#define G(x, y, z) (((x) & (z)) | ((y) & (~z))) -#define H(x, y, z) ((x) ^ (y) ^ (z)) -#define I(x, y, z) ((y) ^ ((x) | (~z))) - -/* ROTATE_LEFT rotates x left n bits. -*/ -#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) - -/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. -Rotation is separate from addition to prevent recomputation. -*/ -#define FF(a, b, c, d, x, s, ac) { \ - (a) += F ((b), (c), (d)) + (x) + (ULONG)(ac); \ - (a) = ROTATE_LEFT ((a), (s)); \ - (a) += (b); \ - } -#define GG(a, b, c, d, x, s, ac) { \ - (a) += G ((b), (c), (d)) + (x) + (ULONG)(ac); \ - (a) = ROTATE_LEFT ((a), (s)); \ - (a) += (b); \ - } -#define HH(a, b, c, d, x, s, ac) { \ - (a) += H ((b), (c), (d)) + (x) + (ULONG)(ac); \ - (a) = ROTATE_LEFT ((a), (s)); \ - (a) += (b); \ - } -#define II(a, b, c, d, x, s, ac) { \ - (a) += I ((b), (c), (d)) + (x) + (ULONG)(ac); \ - (a) = ROTATE_LEFT ((a), (s)); \ - (a) += (b); \ - } -/* */ -/******************************************************************************/ - -/******************************************************************************/ -/* Internal type definitions */ -/* */ -/* MD5 context. */ -typedef struct { - ULONG state[4]; /* state (ABCD) */ - ULONG count[2]; /* number of bits, modulo 2^64 (lsb first) */ - UCHAR buffer[64]; /* input buffer */ -} MD5_CTX; - - -static UCHAR PADDING[64] = { - 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -}; -/* */ -/******************************************************************************/ - -/******************************************************************************/ -/* Internal function prototypes declarations */ -/* */ -void MD5Final( - UCHAR digest[16], - MD5_CTX *context) - ; -void MD5Update( - MD5_CTX *context, - UCHAR *input, - UINT inputLen) - ; -void MD5Init( - MD5_CTX *context) - ; -static void MD5_memset( - UCHAR *output, - INT value, - UINT len) - ; -static void MD5_memcpy( - UCHAR *output, - UCHAR *input, - UINT len) - ; -static void Decode( - ULONG *output, - UCHAR *input, - UINT len) - ; -static void Encode( - UCHAR *output, - ULONG *input, - UINT len) - ; -/* */ -/******************************************************************************/ - -/******************************************************************************/ -/* Function definitions */ -/* */ -/* Encodes input (ULONG) into output (UCHAR). Assumes len is -a multiple of 4. -*/ -static void Encode( - UCHAR *output, - ULONG *input, - UINT len) -{ - UINT i, j; - - for (i = 0, j = 0; j < len; i++, j += 4) { - output[j] = (UCHAR)(input[i] & 0xff); - output[j+1] = (UCHAR)((input[i] >> 8) & 0xff); - output[j+2] = (UCHAR)((input[i] >> 16) & 0xff); - output[j+3] = (UCHAR)((input[i] >> 24) & 0xff); - } -} - -/* Decodes input (UCHAR) into output (ULONG). Assumes len is -a multiple of 4. -*/ -static void Decode( - ULONG *output, - UCHAR *input, - UINT len) -{ - UINT i, j; - - for (i = 0, j = 0; j < len; i++, j += 4) - output[i] = ((ULONG)input[j]) | (((ULONG)input[j+1]) << 8) | - (((ULONG)input[j+2]) << 16) | (((ULONG)input[j+3]) << 24); -} - -/* Note: Replace "for loop" with standard memcpy if possible. -*/ - -static void MD5_memcpy( - UCHAR *output, - UCHAR *input, - UINT len) -{ - UINT i; - - for (i = 0; i < len; i++) - output[i] = input[i]; -} - -/* Note: Replace "for loop" with standard memset if possible. -*/ -static void MD5_memset( - UCHAR *output, - INT value, - UINT len) -{ - UINT i; - - for (i = 0; i < len; i++) - ((CHAR *)output)[i] = (CHAR)value; -} - -/* MD5 basic transformation. Transforms state based on block. -*/ -static void MD5Transform( - ULONG state[4], - UCHAR block[64]) -{ - ULONG a = state[0], b = state[1], c = state[2], d = state[3], x[16]; - - Decode (x, block, 64); - - /* Round 1 */ - FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */ - FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */ - FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */ - FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */ - FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */ - FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */ - FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */ - FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */ - FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */ - FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */ - FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */ - FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */ - FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */ - FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */ - FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */ - FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */ - - /* Round 2 */ - GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */ - GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */ - GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */ - GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */ - GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */ - GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */ - GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */ - GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */ - GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */ - GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */ - GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */ - GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */ - GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */ - GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */ - GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */ - GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ - - /* Round 3 */ - HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */ - HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */ - HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */ - HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */ - HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */ - HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */ - HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */ - HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */ - HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */ - HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */ - HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */ - HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */ - HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */ - HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */ - HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */ - HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */ - - /* Round 4 */ - II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */ - II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */ - II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */ - II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */ - II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */ - II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */ - II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */ - II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */ - II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */ - II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */ - II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */ - II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */ - II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */ - II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */ - II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */ - II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */ - - state[0] += a; - state[1] += b; - state[2] += c; - state[3] += d; - - /* Zeroize sensitive information. - */ - MD5_memset ((UCHAR *)x, 0, sizeof (x)); -} - -/* MD5 initialization. Begins an MD5 operation, writing a new context. -*/ -void MD5Init( - MD5_CTX *context) -{ - memset(context, 0, sizeof(context)); - - context->count[0] = context->count[1] = 0; - /* Load magic initialization constants. - */ - context->state[0] = 0x67452301; - context->state[1] = 0xefcdab89; - context->state[2] = 0x98badcfe; - context->state[3] = 0x10325476; -} - -/* MD5 block update operation. Continues an MD5 message-digest -operation, processing another message block, and updating the -context. -*/ -void MD5Update( - MD5_CTX *context, - UCHAR *input, - UINT inputLen) -{ - UINT i, index, partLen; - - /* Compute number of bytes mod 64 */ - index = (UINT)((context->count[0] >> 3) & 0x3F); - - /* Update number of bits */ - if ((context->count[0] += ((ULONG)inputLen << 3)) - < ((ULONG)inputLen << 3)) - context->count[1]++; - context->count[1] += ((ULONG)inputLen >> 29); - - partLen = 64 - index; - - /* Transform as many times as possible. - */ - if (inputLen >= partLen) { - MD5_memcpy - ((UCHAR *)&context->buffer[index], (UCHAR *)input, partLen); - MD5Transform (context->state, context->buffer); - - for (i = partLen; i + 63 < inputLen; i += 64) - MD5Transform (context->state, &input[i]); - - index = 0; - } - else - i = 0; - - /* Buffer remaining input */ - MD5_memcpy - ((UCHAR *)&context->buffer[index], (UCHAR *)&input[i], - inputLen-i); -} - -/* MD5 finalization. Ends an MD5 message-digest operation, writing the -the message digest and zeroizing the context. -*/ -void MD5Final( - UCHAR digest[16], - MD5_CTX *context) -{ - UCHAR bits[8]; - UINT index, padLen; - - /* Save number of bits */ - Encode (bits, context->count, 8); - - /* Pad out to 56 mod 64. - */ - index = (UINT)((context->count[0] >> 3) & 0x3f); - padLen = (index < 56) ? (56 - index) : (120 - index); - MD5Update (context, PADDING, padLen); - - /* Append length (before padding) */ - MD5Update (context, bits, 8); - - /* Store state in digest */ - Encode (digest, context->state, 16); - - /* Zeroize sensitive information. - */ - MD5_memset ((UCHAR *)context, 0, sizeof (*context)); -} - -void AirPDcapAlgHmacMd5( - UCHAR *key, /* pointer to authentication key */ - INT key_len, /* length of authentication key */ - const UCHAR *text, /* pointer to data stream */ - const INT text_len, /* length of data stream */ - UCHAR *digest) /* caller digest to be filled in */ -{ - MD5_CTX context; - UCHAR k_ipad[65]; /* inner padding - - * key XORd with ipad - */ - UCHAR k_opad[65]; /* outer padding - - * key XORd with opad - */ - UCHAR tk[16]; - INT i; - /* if key is longer than 64 bytes reset it to key=MD5(key) */ - if (key_len > 64) { - - MD5_CTX tctx; - - MD5Init(&tctx); - MD5Update(&tctx, key, key_len); - MD5Final(tk, &tctx); - - 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 pads */ - memset( k_ipad, 0, sizeof k_ipad); - memset( k_opad, 0, sizeof k_opad); - memcpy( k_ipad, key, key_len); - memcpy( k_opad, key, key_len); - - /* XOR key with ipad and opad values */ - for (i=0; i<64; i++) { - k_ipad[i] ^= 0x36; - k_opad[i] ^= 0x5c; - } - /* - * perform inner MD5 - */ - MD5Init(&context); /* init context for 1st - * pass */ - MD5Update(&context, k_ipad, 64); /* start with inner pad */ - MD5Update(&context, (UCHAR *)text, text_len); /* then text of datagram */ - MD5Final(digest, &context); /* finish up 1st pass */ - /* - * perform outer MD5 - */ - MD5Init(&context); /* init context for 2nd - * pass */ - MD5Update(&context, k_opad, 64); /* start with outer pad */ - MD5Update(&context, digest, 16); /* then results of 1st - * hash */ - MD5Final(digest, &context); /* finish up 2nd pass */ -} -/* */ -/******************************************************************************/ diff --git a/epan/crypt/airpdcap_md5.h b/epan/crypt/airpdcap_md5.h deleted file mode 100644 index e69de29bb2..0000000000 --- a/epan/crypt/airpdcap_md5.h +++ /dev/null diff --git a/epan/crypt/airpdcap_system.h b/epan/crypt/airpdcap_system.h index 4c8d42bc59..52fc57d3fe 100644 --- a/epan/crypt/airpdcap_system.h +++ b/epan/crypt/airpdcap_system.h @@ -1,19 +1,16 @@ #ifndef _AIRPDCAP_SYSTEM_H #define _AIRPDCAP_SYSTEM_H -/******************************************************************************/ -/* File includes */ -/* */ +/************************************************************************/ +/* File includes */ + #include "airpdcap_interop.h" #include "airpdcap_user.h" -/* */ -/* */ -/******************************************************************************/ - -/******************************************************************************/ -/* Constant definitions */ -/* */ -/* General definitions */ + +/************************************************************************/ +/* Constant definitions */ + +/* General definitions */ #ifndef TRUE #define TRUE 1 #endif @@ -35,14 +32,14 @@ #define AIRPDCAP_MAX_KEYS_NR 64 #define AIRPDCAP_MAX_SEC_ASSOCIATIONS_NR 256 -/* Decryption algorithms fields size definition (bytes) */ +/* Decryption algorithms fields size definition (bytes) */ #define AIRPDCAP_WPA_NONCE_LEN 32 #define AIRPDCAP_WPA_PTK_LEN 64 /* TKIP uses 48 bytes, CCMP uses 64 bytes */ #define AIRPDCAP_WPA_MICKEY_LEN 16 #define AIRPDCAP_WEP_128_KEY_LEN 16 /* 128 bits */ -/* General 802.11 constants */ +/* General 802.11 constants */ #define AIRPDCAP_MAC_LEN 6 #define AIRPDCAP_RADIOTAP_HEADER_LEN 24 @@ -50,7 +47,7 @@ #define AIRPDCAP_TK_LEN 16 -/* Max length of capture data */ +/* Max length of capture data */ #define AIRPDCAP_MAX_CAPLEN 8192 #define AIRPDCAP_WEP_IVLEN 3 /* 24bit */ @@ -60,12 +57,12 @@ #define AIRPDCAP_WEP_TRAILER AIRPDCAP_WEP_ICV /* -* 802.11i defines an extended IV for use with non-WEP ciphers. -* When the EXTIV bit is set in the key id byte an additional -* 4 bytes immediately follow the IV for TKIP. For CCMP the -* EXTIV bit is likewise set but the 8 bytes represent the -* CCMP header rather than IV+extended-IV. -*/ + * 802.11i defines an extended IV for use with non-WEP ciphers. + * When the EXTIV bit is set in the key id byte an additional + * 4 bytes immediately follow the IV for TKIP. For CCMP the + * EXTIV bit is likewise set but the 8 bytes represent the + * CCMP header rather than IV+extended-IV. + */ #define AIRPDCAP_RSNA_EXTIV 0x20 #define AIRPDCAP_RSNA_EXTIVLEN 4 /* extended IV length */ #define AIRPDCAP_RSNA_MICLEN 8 /* trailing MIC */ @@ -79,29 +76,23 @@ #define AIRPDCAP_TKIP_TRAILER AIRPDCAP_RSNA_MICLEN + AIRPDCAP_WEP_ICV #define AIRPDCAP_CRC_LEN 4 -/* */ -/* */ -/******************************************************************************/ - -/******************************************************************************/ -/* Macro definitions */ -/* */ -/* */ -/* */ -/******************************************************************************/ - -/******************************************************************************/ -/* Type definitions */ -/* */ + +/************************************************************************/ +/* Macro definitions */ + +/************************************************************************/ +/* Type definitions */ + typedef struct _AIRPDCAP_SEC_ASSOCIATION_ID { UCHAR bssid[AIRPDCAP_MAC_LEN]; UCHAR sta[AIRPDCAP_MAC_LEN]; } AIRPDCAP_SEC_ASSOCIATION_ID, *PAIRPDCAP_SEC_ASSOCIATION_ID; typedef struct _AIRPDCAP_SEC_ASSOCIATION { - /*! - This flag define whether this item is used or not. Accepted values are TRUE and FALSE - */ + /** + * This flag define whether this item is used or not. Accepted + * values are TRUE and FALSE + */ UINT8 used; AIRPDCAP_SEC_ASSOCIATION_ID saId; AIRPDCAP_KEY_ITEM *key; @@ -110,10 +101,10 @@ typedef struct _AIRPDCAP_SEC_ASSOCIATION { struct { UINT8 key_ver; /* Key descriptor version */ - UINT64 pn; /* only used with CCMP AES -if needed replay check- */ + UINT64 pn; /* only used with CCMP AES -if needed replay check- */ UCHAR nonce[AIRPDCAP_WPA_NONCE_LEN]; - /* used to derive PTK, ANonce stored, SNonce taken */ - /* the 2nd packet of the 4W handshake */ + /* used to derive PTK, ANonce stored, SNonce taken */ + /* the 2nd packet of the 4W handshake */ UCHAR ptk[AIRPDCAP_WPA_PTK_LEN]; /* session key used in decryption algorithm */ } wpa; @@ -129,13 +120,10 @@ typedef struct _AIRPDCAP_CONTEXT { INT first_free_index; INT last_stored_index; } AIRPDCAP_CONTEXT, *PAIRPDCAP_CONTEXT; -/* */ -/* */ -/******************************************************************************/ -/******************************************************************************/ -/* Function prototype declarations */ -/* */ +/************************************************************************/ +/* Function prototype declarations */ + #ifdef __cplusplus extern "C" { #endif @@ -324,13 +312,6 @@ extern INT AirPDcapTkipDecrypt( UCHAR TA[AIRPDCAP_MAC_LEN], UCHAR TK[AIRPDCAP_TK_LEN]) ; -extern void AirPDcapAlgHmacMd5( - UCHAR *key, /* pointer to authentication key */ - INT key_len, /* length of authentication key */ - const UCHAR *text, /* pointer to data stream */ - const INT text_len, /* length of data stream */ - UCHAR *digest) /* caller digest to be filled in */ - ; extern void AirPDcapAlgHmacSha1( const UCHAR *key_len, const size_t keylen, @@ -343,8 +324,5 @@ extern void AirPDcapAlgHmacSha1( #ifdef __cplusplus } #endif -/* */ -/* */ -/******************************************************************************/ #endif /* _AIRPDCAP_SYSTEM_H */ diff --git a/epan/crypt/crypt-md5.c b/epan/crypt/crypt-md5.c new file mode 100644 index 0000000000..afb8fc0abc --- /dev/null +++ b/epan/crypt/crypt-md5.c @@ -0,0 +1,449 @@ +/* + Copyright (C) 1999, 2000, 2002 Aladdin Enterprises. All rights reserved. + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + L. Peter Deutsch + ghost@aladdin.com + + */ +/* $Id$ */ +/* + Independent implementation of MD5 (RFC 1321). + + This code implements the MD5 Algorithm defined in RFC 1321, whose + text is available at + http://www.ietf.org/rfc/rfc1321.txt + The code is derived from the text of the RFC, including the test suite + (section A.5) but excluding the rest of Appendix A. It does not include + any code or documentation that is identified in the RFC as being + copyrighted. + + The original and principal author of md5.c is L. Peter Deutsch + <ghost@aladdin.com>. Other authors are noted in the change history + that follows (in reverse chronological order): + + 2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order + either statically or dynamically; added missing #include <string.h> + in library. + 2002-03-11 lpd Corrected argument list for main(), and added int return + type, in test program and T value program. + 2002-02-21 lpd Added missing #include <stdio.h> in test program. + 2000-07-03 lpd Patched to eliminate warnings about "constant is + unsigned in ANSI C, signed in traditional"; made test program + self-checking. + 1999-11-04 lpd Edited comments slightly for automatic TOC extraction. + 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5). + 1999-05-03 lpd Original version. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <string.h> +#include <glib.h> /* for g_malloc() */ + +#include "crypt-md5.h" + +#undef BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown */ +#ifdef WORDS_BIGENDIAN +# define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1) +#else +# define BYTE_ORDER 0 +#endif + +#define T_MASK ((md5_word_t)~0) +#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87) +#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9) +#define T3 0x242070db +#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111) +#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050) +#define T6 0x4787c62a +#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec) +#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe) +#define T9 0x698098d8 +#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850) +#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e) +#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841) +#define T13 0x6b901122 +#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c) +#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71) +#define T16 0x49b40821 +#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d) +#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf) +#define T19 0x265e5a51 +#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855) +#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2) +#define T22 0x02441453 +#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e) +#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437) +#define T25 0x21e1cde6 +#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829) +#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278) +#define T28 0x455a14ed +#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa) +#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07) +#define T31 0x676f02d9 +#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375) +#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd) +#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e) +#define T35 0x6d9d6122 +#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3) +#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb) +#define T38 0x4bdecfa9 +#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f) +#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f) +#define T41 0x289b7ec6 +#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805) +#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a) +#define T44 0x04881d05 +#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6) +#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a) +#define T47 0x1fa27cf8 +#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a) +#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb) +#define T50 0x432aff97 +#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58) +#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6) +#define T53 0x655b59c3 +#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d) +#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82) +#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e) +#define T57 0x6fa87e4f +#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f) +#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb) +#define T60 0x4e0811a1 +#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d) +#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca) +#define T63 0x2ad7d2bb +#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e) + + +static void +md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/) +{ + md5_word_t + a = pms->abcd[0], b = pms->abcd[1], + c = pms->abcd[2], d = pms->abcd[3]; + md5_word_t t; +#if BYTE_ORDER > 0 + /* Define storage only for big-endian CPUs. */ + md5_word_t X[16]; +#else + /* Define storage for little-endian or both types of CPUs. */ + md5_word_t xbuf[16]; + const md5_word_t *X; +#endif + + { +#if BYTE_ORDER == 0 + /* + * Determine dynamically whether this is a big-endian or + * little-endian machine, since we can use a more efficient + * algorithm on the latter. + */ + static const int w = 1; + + if (*((const md5_byte_t *)&w)) /* dynamic little-endian */ +#endif +#if BYTE_ORDER <= 0 /* little-endian */ + { + /* + * On little-endian machines, we can process properly aligned + * data without copying it. + */ + if (!((data - (const md5_byte_t *)0) & 3)) { + /* data are properly aligned */ + X = (const md5_word_t *)data; + } else { + /* not aligned */ + memcpy(xbuf, data, 64); + X = xbuf; + } + } +#endif +#if BYTE_ORDER == 0 + else /* dynamic big-endian */ +#endif +#if BYTE_ORDER >= 0 /* big-endian */ + { + /* + * On big-endian machines, we must arrange the bytes in the + * right order. + */ + const md5_byte_t *xp = data; + int i; + +# if BYTE_ORDER == 0 + X = xbuf; /* (dynamic only) */ +# else +# define xbuf X /* (static only) */ +# endif + for (i = 0; i < 16; ++i, xp += 4) + xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24); + } +#endif + } + +#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n)))) + + /* Round 1. */ + /* Let [abcd k s i] denote the operation + a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */ +#define F(x, y, z) (((x) & (y)) | (~(x) & (z))) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + F(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 0, 7, T1); + SET(d, a, b, c, 1, 12, T2); + SET(c, d, a, b, 2, 17, T3); + SET(b, c, d, a, 3, 22, T4); + SET(a, b, c, d, 4, 7, T5); + SET(d, a, b, c, 5, 12, T6); + SET(c, d, a, b, 6, 17, T7); + SET(b, c, d, a, 7, 22, T8); + SET(a, b, c, d, 8, 7, T9); + SET(d, a, b, c, 9, 12, T10); + SET(c, d, a, b, 10, 17, T11); + SET(b, c, d, a, 11, 22, T12); + SET(a, b, c, d, 12, 7, T13); + SET(d, a, b, c, 13, 12, T14); + SET(c, d, a, b, 14, 17, T15); + SET(b, c, d, a, 15, 22, T16); +#undef SET + + /* Round 2. */ + /* Let [abcd k s i] denote the operation + a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */ +#define G(x, y, z) (((x) & (z)) | ((y) & ~(z))) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + G(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 1, 5, T17); + SET(d, a, b, c, 6, 9, T18); + SET(c, d, a, b, 11, 14, T19); + SET(b, c, d, a, 0, 20, T20); + SET(a, b, c, d, 5, 5, T21); + SET(d, a, b, c, 10, 9, T22); + SET(c, d, a, b, 15, 14, T23); + SET(b, c, d, a, 4, 20, T24); + SET(a, b, c, d, 9, 5, T25); + SET(d, a, b, c, 14, 9, T26); + SET(c, d, a, b, 3, 14, T27); + SET(b, c, d, a, 8, 20, T28); + SET(a, b, c, d, 13, 5, T29); + SET(d, a, b, c, 2, 9, T30); + SET(c, d, a, b, 7, 14, T31); + SET(b, c, d, a, 12, 20, T32); +#undef SET + + /* Round 3. */ + /* Let [abcd k s t] denote the operation + a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */ +#define H(x, y, z) ((x) ^ (y) ^ (z)) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + H(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 5, 4, T33); + SET(d, a, b, c, 8, 11, T34); + SET(c, d, a, b, 11, 16, T35); + SET(b, c, d, a, 14, 23, T36); + SET(a, b, c, d, 1, 4, T37); + SET(d, a, b, c, 4, 11, T38); + SET(c, d, a, b, 7, 16, T39); + SET(b, c, d, a, 10, 23, T40); + SET(a, b, c, d, 13, 4, T41); + SET(d, a, b, c, 0, 11, T42); + SET(c, d, a, b, 3, 16, T43); + SET(b, c, d, a, 6, 23, T44); + SET(a, b, c, d, 9, 4, T45); + SET(d, a, b, c, 12, 11, T46); + SET(c, d, a, b, 15, 16, T47); + SET(b, c, d, a, 2, 23, T48); +#undef SET + + /* Round 4. */ + /* Let [abcd k s t] denote the operation + a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */ +#define I(x, y, z) ((y) ^ ((x) | ~(z))) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + I(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 0, 6, T49); + SET(d, a, b, c, 7, 10, T50); + SET(c, d, a, b, 14, 15, T51); + SET(b, c, d, a, 5, 21, T52); + SET(a, b, c, d, 12, 6, T53); + SET(d, a, b, c, 3, 10, T54); + SET(c, d, a, b, 10, 15, T55); + SET(b, c, d, a, 1, 21, T56); + SET(a, b, c, d, 8, 6, T57); + SET(d, a, b, c, 15, 10, T58); + SET(c, d, a, b, 6, 15, T59); + SET(b, c, d, a, 13, 21, T60); + SET(a, b, c, d, 4, 6, T61); + SET(d, a, b, c, 11, 10, T62); + SET(c, d, a, b, 2, 15, T63); + SET(b, c, d, a, 9, 21, T64); +#undef SET + + /* Then perform the following additions. (That is increment each + of the four registers by the value it had before this block + was started.) */ + pms->abcd[0] += a; + pms->abcd[1] += b; + pms->abcd[2] += c; + pms->abcd[3] += d; +} + +void +md5_init(md5_state_t *pms) +{ + pms->count[0] = pms->count[1] = 0; + pms->abcd[0] = 0x67452301; + pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476; + pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301; + pms->abcd[3] = 0x10325476; +} + +void +md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes) +{ + const md5_byte_t *p = data; + int left = nbytes; + int offset = (pms->count[0] >> 3) & 63; + md5_word_t nbits = (md5_word_t)(nbytes << 3); + + if (nbytes <= 0) + return; + + /* Update the message length. */ + pms->count[1] += nbytes >> 29; + pms->count[0] += nbits; + if (pms->count[0] < nbits) + pms->count[1]++; + + /* Process an initial partial block. */ + if (offset) { + int copy = (offset + nbytes > 64 ? 64 - offset : nbytes); + + memcpy(pms->buf + offset, p, copy); + if (offset + copy < 64) + return; + p += copy; + left -= copy; + md5_process(pms, pms->buf); + } + + /* Process full blocks. */ + for (; left >= 64; p += 64, left -= 64) + md5_process(pms, p); + + /* Process a final partial block. */ + if (left) + memcpy(pms->buf, p, left); +} + +void +md5_finish(md5_state_t *pms, md5_byte_t digest[16]) +{ + static const md5_byte_t pad[64] = { + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + md5_byte_t data[8]; + int i; + + /* Save the length before padding. */ + for (i = 0; i < 8; ++i) + data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3)); + /* Pad to 56 bytes mod 64. */ + md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1); + /* Append the length. */ + md5_append(pms, data, 8); + for (i = 0; i < 16; ++i) + digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3)); +} + +static void +md5_checksum(const md5_byte_t *data, + int len, + md5_byte_t digest[16]) +{ + md5_state_t ms; + + md5_init(&ms); + md5_append(&ms, data, len); + md5_finish(&ms, digest); +} + +void +md5_hmac(const md5_byte_t *data, + int len, + md5_byte_t *key_data, + int key_length, + md5_byte_t digest[16]) +{ + md5_byte_t *ipad; + md5_byte_t *key; + md5_byte_t opad[80]; + int key_len; + int i; + + ipad = g_malloc(64 + len); + if (ipad == NULL) + g_assert_not_reached(); + + memset(ipad, 0x36, 64); + memset(opad, 0x5c, 64); + + if(key_length > 65){ + md5_checksum( + key_data, + key_length, + digest); + key = digest; + key_len = 16; + } else { + key = key_data; + key_len = key_length; + } + for(i = 0; i < key_len; i++){ + ipad[i] ^= key[i]; + opad[i] ^= key[i]; + } + memcpy(ipad + 64, data, len); + md5_checksum( + ipad, + 64+len, + digest); + memcpy(opad + 64, digest, + 16); + md5_checksum( + opad, + 64+16, + digest); + g_free(ipad); +} + diff --git a/epan/crypt/crypt-md5.h b/epan/crypt/crypt-md5.h new file mode 100644 index 0000000000..57c1553b37 --- /dev/null +++ b/epan/crypt/crypt-md5.h @@ -0,0 +1,94 @@ +/* + Copyright (C) 1999, 2002 Aladdin Enterprises. All rights reserved. + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + L. Peter Deutsch + ghost@aladdin.com + + */ +/* $Id$ */ +/* + Independent implementation of MD5 (RFC 1321). + + This code implements the MD5 Algorithm defined in RFC 1321, whose + text is available at + http://www.ietf.org/rfc/rfc1321.txt + The code is derived from the text of the RFC, including the test suite + (section A.5) but excluding the rest of Appendix A. It does not include + any code or documentation that is identified in the RFC as being + copyrighted. + + The original and principal author of md5.h is L. Peter Deutsch + <ghost@aladdin.com>. Other authors are noted in the change history + that follows (in reverse chronological order): + + 2002-04-13 lpd Removed support for non-ANSI compilers; removed + references to Ghostscript; clarified derivation from RFC 1321; + now handles byte order either statically or dynamically. + 1999-11-04 lpd Edited comments slightly for automatic TOC extraction. + 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5); + added conditionalization for C++ compilation from Martin + Purschke <purschke@bnl.gov>. + 1999-05-03 lpd Original version. + */ + +#ifndef md5_INCLUDED +# define md5_INCLUDED + +/* + * This package supports both compile-time and run-time determination of CPU + * byte order. If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be + * compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is + * defined as non-zero, the code will be compiled to run only on big-endian + * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to + * run on either big- or little-endian CPUs, but will run slightly less + * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined. + */ + +typedef unsigned char md5_byte_t; /* 8-bit byte */ +typedef unsigned int md5_word_t; /* 32-bit word */ + +/* Define the state of the MD5 Algorithm. */ +typedef struct md5_state_s { + md5_word_t count[2]; /* message length in bits, lsw first */ + md5_word_t abcd[4]; /* digest buffer */ + md5_byte_t buf[64]; /* accumulate block */ +} md5_state_t; + +#ifdef __cplusplus +extern "C" +{ +#endif + +/* Initialize the algorithm. */ +void md5_init(md5_state_t *pms); + +/* Append a string to the message. */ +void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes); + +/* Finish the message and return the digest. */ +void md5_finish(md5_state_t *pms, md5_byte_t digest[16]); + + /* compute the MD5 HMAC */ +void md5_hmac(const md5_byte_t *data, int len, md5_byte_t *key_data, int key_length, md5_byte_t digest[16]); + +#ifdef __cplusplus +} /* end extern "C" */ +#endif + +#endif /* md5_INCLUDED */ |