doom3-gpl
Doom 3 GPL source release
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
md5.c
Go to the documentation of this file.
1 /***************************************************************************
2  * _ _ ____ _
3  * Project ___| | | | _ \| |
4  * / __| | | | |_) | |
5  * | (__| |_| | _ <| |___
6  * \___|\___/|_| \_\_____|
7  *
8  * Copyright (C) 1998 - 2004, Daniel Stenberg, <daniel@haxx.se>, et al.
9  *
10  * This software is licensed as described in the file COPYING, which
11  * you should have received as part of this distribution. The terms
12  * are also available at http://curl.haxx.se/docs/copyright.html.
13  *
14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15  * copies of the Software, and permit persons to whom the Software is
16  * furnished to do so, under the terms of the COPYING file.
17  *
18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19  * KIND, either express or implied.
20  *
21  * $Id: md5.c,v 1.7 2004/02/20 16:18:26 bagder Exp $
22  ***************************************************************************/
23 
24 #include "setup.h"
25 
26 #ifndef USE_SSLEAY
27 /* This code segment is only used if OpenSSL is not provided, as if it is
28  we use the MD5-function provided there instead. No good duplicating
29  code! */
30 
31 /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
32 rights reserved.
33 
34 License to copy and use this software is granted provided that it
35 is identified as the "RSA Data Security, Inc. MD5 Message-Digest
36 Algorithm" in all material mentioning or referencing this software
37 or this function.
38 
39 License is also granted to make and use derivative works provided
40 that such works are identified as "derived from the RSA Data
41 Security, Inc. MD5 Message-Digest Algorithm" in all material
42 mentioning or referencing the derived work.
43 
44 RSA Data Security, Inc. makes no representations concerning either
45 the merchantability of this software or the suitability of this
46 software for any particular purpose. It is provided "as is"
47 without express or implied warranty of any kind.
48 
49 These notices must be retained in any copies of any part of this
50 documentation and/or software.
51  */
52 
53 #include <string.h>
54 
55 /* UINT4 defines a four byte word */
56 typedef unsigned int UINT4;
57 
58 /* MD5 context. */
59 struct md5_ctx {
60  UINT4 state[4]; /* state (ABCD) */
61  UINT4 count[2]; /* number of bits, modulo 2^64 (lsb first) */
62  unsigned char buffer[64]; /* input buffer */
63 };
64 
65 typedef struct md5_ctx MD5_CTX;
66 
67 static void MD5_Init(struct md5_ctx *);
68 static void MD5_Update(struct md5_ctx *, unsigned char *, unsigned int);
69 static void MD5_Final(unsigned char [16], struct md5_ctx *);
70 
71 /* Constants for MD5Transform routine.
72  */
73 
74 #define S11 7
75 #define S12 12
76 #define S13 17
77 #define S14 22
78 #define S21 5
79 #define S22 9
80 #define S23 14
81 #define S24 20
82 #define S31 4
83 #define S32 11
84 #define S33 16
85 #define S34 23
86 #define S41 6
87 #define S42 10
88 #define S43 15
89 #define S44 21
90 
91 static void MD5Transform(UINT4 [4], unsigned char [64]);
92 static void Encode(unsigned char *, UINT4 *, unsigned int);
93 static void Decode(UINT4 *, unsigned char *, unsigned int);
94 
95 static unsigned char PADDING[64] = {
96  0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
97  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
98  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
99 };
100 
101 /* F, G, H and I are basic MD5 functions.
102  */
103 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
104 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
105 #define H(x, y, z) ((x) ^ (y) ^ (z))
106 #define I(x, y, z) ((y) ^ ((x) | (~z)))
107 
108 /* ROTATE_LEFT rotates x left n bits.
109  */
110 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
111 
112 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
113 Rotation is separate from addition to prevent recomputation.
114  */
115 #define FF(a, b, c, d, x, s, ac) { \
116  (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
117  (a) = ROTATE_LEFT ((a), (s)); \
118  (a) += (b); \
119  }
120 #define GG(a, b, c, d, x, s, ac) { \
121  (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
122  (a) = ROTATE_LEFT ((a), (s)); \
123  (a) += (b); \
124  }
125 #define HH(a, b, c, d, x, s, ac) { \
126  (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
127  (a) = ROTATE_LEFT ((a), (s)); \
128  (a) += (b); \
129  }
130 #define II(a, b, c, d, x, s, ac) { \
131  (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
132  (a) = ROTATE_LEFT ((a), (s)); \
133  (a) += (b); \
134  }
135 
136 /* MD5 initialization. Begins an MD5 operation, writing a new context.
137  */
138 static void MD5_Init(struct md5_ctx *context)
139 {
140  context->count[0] = context->count[1] = 0;
141  /* Load magic initialization constants. */
142  context->state[0] = 0x67452301;
143  context->state[1] = 0xefcdab89;
144  context->state[2] = 0x98badcfe;
145  context->state[3] = 0x10325476;
146 }
147 
148 /* MD5 block update operation. Continues an MD5 message-digest
149  operation, processing another message block, and updating the
150  context.
151  */
152 static void MD5_Update (struct md5_ctx *context, /* context */
153  unsigned char *input, /* input block */
154  unsigned int inputLen)/* length of input block */
155 {
156  unsigned int i, bufindex, partLen;
157 
158  /* Compute number of bytes mod 64 */
159  bufindex = (unsigned int)((context->count[0] >> 3) & 0x3F);
160 
161  /* Update number of bits */
162  if ((context->count[0] += ((UINT4)inputLen << 3))
163  < ((UINT4)inputLen << 3))
164  context->count[1]++;
165  context->count[1] += ((UINT4)inputLen >> 29);
166 
167  partLen = 64 - bufindex;
168 
169  /* Transform as many times as possible. */
170  if (inputLen >= partLen) {
171  memcpy((void *)&context->buffer[bufindex], (void *)input, partLen);
172  MD5Transform(context->state, context->buffer);
173 
174  for (i = partLen; i + 63 < inputLen; i += 64)
175  MD5Transform(context->state, &input[i]);
176 
177  bufindex = 0;
178  }
179  else
180  i = 0;
181 
182  /* Buffer remaining input */
183  memcpy((void *)&context->buffer[bufindex], (void *)&input[i], inputLen-i);
184 }
185 
186 /* MD5 finalization. Ends an MD5 message-digest operation, writing the
187  the message digest and zeroizing the context.
188 */
189 static void MD5_Final(unsigned char digest[16], /* message digest */
190  struct md5_ctx *context) /* context */
191 {
192  unsigned char bits[8];
193  unsigned int count, padLen;
194 
195  /* Save number of bits */
196  Encode (bits, context->count, 8);
197 
198  /* Pad out to 56 mod 64. */
199  count = (unsigned int)((context->count[0] >> 3) & 0x3f);
200  padLen = (count < 56) ? (56 - count) : (120 - count);
201  MD5_Update (context, PADDING, padLen);
202 
203  /* Append length (before padding) */
204  MD5_Update (context, bits, 8);
205 
206  /* Store state in digest */
207  Encode (digest, context->state, 16);
208 
209  /* Zeroize sensitive information. */
210  memset ((void *)context, 0, sizeof (*context));
211 }
212 
213 /* MD5 basic transformation. Transforms state based on block. */
214 static void MD5Transform(UINT4 state[4],
215  unsigned char block[64])
216 {
217  UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
218 
219  Decode (x, block, 64);
220 
221  /* Round 1 */
222  FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
223  FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
224  FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
225  FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
226  FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
227  FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
228  FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
229  FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
230  FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
231  FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
232  FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
233  FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
234  FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
235  FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
236  FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
237  FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
238 
239  /* Round 2 */
240  GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
241  GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
242  GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
243  GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
244  GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
245  GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
246  GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
247  GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
248  GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
249  GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
250  GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
251  GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
252  GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
253  GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
254  GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
255  GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
256 
257  /* Round 3 */
258  HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
259  HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
260  HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
261  HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
262  HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
263  HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
264  HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
265  HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
266  HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
267  HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
268  HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
269  HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
270  HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
271  HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
272  HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
273  HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
274 
275  /* Round 4 */
276  II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
277  II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
278  II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
279  II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
280  II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
281  II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
282  II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
283  II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
284  II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
285  II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
286  II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
287  II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
288  II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
289  II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
290  II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
291  II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
292 
293  state[0] += a;
294  state[1] += b;
295  state[2] += c;
296  state[3] += d;
297 
298  /* Zeroize sensitive information. */
299  memset((void *)x, 0, sizeof (x));
300 }
301 
302 /* Encodes input (UINT4) into output (unsigned char). Assumes len is
303  a multiple of 4.
304  */
305 static void Encode (unsigned char *output,
306  UINT4 *input,
307  unsigned int len)
308 {
309  unsigned int i, j;
310 
311  for (i = 0, j = 0; j < len; i++, j += 4) {
312  output[j] = (unsigned char)(input[i] & 0xff);
313  output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
314  output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
315  output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
316  }
317 }
318 
319 /* Decodes input (unsigned char) into output (UINT4). Assumes len is
320  a multiple of 4.
321 */
322 static void Decode (UINT4 *output,
323  unsigned char *input,
324  unsigned int len)
325 {
326  unsigned int i, j;
327 
328  for (i = 0, j = 0; j < len; i++, j += 4)
329  output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
330  (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
331 }
332 
333 #else
334 /* If OpenSSL is present */
335 #include <openssl/md5.h>
336 #include <string.h>
337 #endif
338 
339 #include "md5.h"
340 
341 void Curl_md5it(unsigned char *outbuffer, /* 16 bytes */
342  unsigned char *input)
343 {
344  MD5_CTX ctx;
345  MD5_Init(&ctx);
346  MD5_Update(&ctx, input, strlen((char *)input));
347  MD5_Final(outbuffer, &ctx);
348 }
void Curl_md5it(unsigned char *outbuffer, unsigned char *input)
Definition: md5.c:341
#define S44
Definition: md5.c:89
#define S43
Definition: md5.c:88
#define S32
Definition: md5.c:83
void MD5_Final(MD5_CTX *ctx, unsigned char digest[16])
Definition: MD5.cpp:215
UINT4 count[2]
Definition: md5.c:61
case const int
Definition: Callbacks.cpp:52
#define GG(a, b, c, d, x, s, ac)
Definition: md5.c:120
#define S31
Definition: md5.c:82
void MD5_Update(MD5_CTX *ctx, unsigned char const *buf, unsigned int len)
Definition: MD5.cpp:166
GLenum GLsizei len
Definition: glext.h:3472
GLenum GLint x
Definition: glext.h:2849
int i
Definition: process.py:33
#define II(a, b, c, d, x, s, ac)
Definition: md5.c:130
Definition: MD5.cpp:29
#define S21
Definition: md5.c:78
GLuint GLuint GLsizei count
Definition: glext.h:2845
#define S12
Definition: md5.c:75
const GLubyte * c
Definition: glext.h:4677
#define S22
Definition: md5.c:79
#define HH(a, b, c, d, x, s, ac)
Definition: md5.c:125
unsigned char buffer[64]
Definition: md5.c:62
#define S14
Definition: md5.c:77
GLuint buffer
Definition: glext.h:3108
void MD5_Init(MD5_CTX *ctx)
Definition: MD5.cpp:148
#define S23
Definition: md5.c:80
UINT4 state[4]
Definition: md5.c:60
unsigned int UINT4
Definition: md5.c:56
GLenum GLenum GLenum input
Definition: glext.h:4803
#define S24
Definition: md5.c:81
GLubyte GLubyte GLubyte a
Definition: glext.h:4662
#define context
Definition: getdate.c:236
#define S42
Definition: md5.c:87
#define FF(a, b, c, d, x, s, ac)
Definition: md5.c:115
#define S41
Definition: md5.c:86
GLubyte GLubyte b
Definition: glext.h:4662
#define S33
Definition: md5.c:84
#define bits
Definition: Unzip.cpp:3797
#define S13
Definition: md5.c:76
GLint j
Definition: qgl.h:264
#define S11
Definition: md5.c:74
#define S34
Definition: md5.c:85
Definition: md5.c:59