ReactOS  0.4.15-dev-1207-g698a8e6
md5.c
Go to the documentation of this file.
1 /*
2  ***********************************************************************
3  ** md5.c -- the source code for MD5 routines **
4  ** RSA Data Security, Inc. MD5 Message-Digest Algorithm **
5  ** Created: 2/17/90 RLR **
6  ** Revised: 1/91 SRD,AJ,BSK,JT Reference C ver., 7/10 constant corr. **
7  ***********************************************************************
8  */
9 
10 /*
11  ***********************************************************************
12  ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. **
13  ** **
14  ** License to copy and use this software is granted provided that **
15  ** it is identified as the "RSA Data Security, Inc. MD5 Message- **
16  ** Digest Algorithm" in all material mentioning or referencing this **
17  ** software or this function. **
18  ** **
19  ** License is also granted to make and use derivative works **
20  ** provided that such works are identified as "derived from the RSA **
21  ** Data Security, Inc. MD5 Message-Digest Algorithm" in all **
22  ** material mentioning or referencing the derived work. **
23  ** **
24  ** RSA Data Security, Inc. makes no representations concerning **
25  ** either the merchantability of this software or the suitability **
26  ** of this software for any particular purpose. It is provided "as **
27  ** is" without express or implied warranty of any kind. **
28  ** **
29  ** These notices must be retained in any copies of any part of this **
30  ** documentation and/or software. **
31  ***********************************************************************
32  */
33 
34 #include "lwip/opt.h"
35 
36 #if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */
37 
38 #if CHAP_SUPPORT || MD5_SUPPORT
39 
40 #include "ppp_impl.h"
41 #include "pppdebug.h"
42 
43 #include "md5.h"
44 
45 #include <string.h>
46 
47 /*
48  ***********************************************************************
49  ** Message-digest routines: **
50  ** To form the message digest for a message M **
51  ** (1) Initialize a context buffer mdContext using MD5Init **
52  ** (2) Call MD5Update on mdContext and M **
53  ** (3) Call MD5Final on mdContext **
54  ** The message digest is now in mdContext->digest[0...15] **
55  ***********************************************************************
56  */
57 
58 /* forward declaration */
59 static void Transform (u32_t *buf, u32_t *in);
60 
61 static unsigned char PADDING[64] = {
62  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
63  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
64  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
65  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
66  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
67  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
68  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
69  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
70 };
71 
72 /* F, G, H and I are basic MD5 functions */
73 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
74 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
75 #define H(x, y, z) ((x) ^ (y) ^ (z))
76 #define I(x, y, z) ((y) ^ ((x) | (~z)))
77 
78 /* ROTATE_LEFT rotates x left n bits */
79 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
80 
81 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4 */
82 /* Rotation is separate from addition to prevent recomputation */
83 #define FF(a, b, c, d, x, s, ac) \
84  {(a) += F ((b), (c), (d)) + (x) + (u32_t)(ac); \
85  (a) = ROTATE_LEFT ((a), (s)); \
86  (a) += (b); \
87  }
88 #define GG(a, b, c, d, x, s, ac) \
89  {(a) += G ((b), (c), (d)) + (x) + (u32_t)(ac); \
90  (a) = ROTATE_LEFT ((a), (s)); \
91  (a) += (b); \
92  }
93 #define HH(a, b, c, d, x, s, ac) \
94  {(a) += H ((b), (c), (d)) + (x) + (u32_t)(ac); \
95  (a) = ROTATE_LEFT ((a), (s)); \
96  (a) += (b); \
97  }
98 #define II(a, b, c, d, x, s, ac) \
99  {(a) += I ((b), (c), (d)) + (x) + (u32_t)(ac); \
100  (a) = ROTATE_LEFT ((a), (s)); \
101  (a) += (b); \
102  }
103 
104 #ifdef __STDC__
105 #define UL(x) x##UL
106 #else
107 #ifdef WIN32
108 #define UL(x) x##UL
109 #else
110 #define UL(x) x
111 #endif
112 #endif
113 
114 /* The routine MD5Init initializes the message-digest context
115  mdContext. All fields are set to zero.
116  */
117 void
118 MD5Init (MD5_CTX *mdContext)
119 {
120  mdContext->i[0] = mdContext->i[1] = (u32_t)0;
121 
122  /* Load magic initialization constants. */
123  mdContext->buf[0] = (u32_t)0x67452301UL;
124  mdContext->buf[1] = (u32_t)0xefcdab89UL;
125  mdContext->buf[2] = (u32_t)0x98badcfeUL;
126  mdContext->buf[3] = (u32_t)0x10325476UL;
127 }
128 
129 /* The routine MD5Update updates the message-digest context to
130  account for the presence of each of the characters inBuf[0..inLen-1]
131  in the message whose digest is being computed.
132  */
133 void
134 MD5Update(MD5_CTX *mdContext, unsigned char *inBuf, unsigned int inLen)
135 {
136  u32_t in[16];
137  int mdi;
138  unsigned int i, ii;
139 
140 #if 0
141  PPPDEBUG(LOG_INFO, ("MD5Update: %u:%.*H\n", inLen, LWIP_MIN(inLen, 20) * 2, inBuf));
142  PPPDEBUG(LOG_INFO, ("MD5Update: %u:%s\n", inLen, inBuf));
143 #endif
144 
145  /* compute number of bytes mod 64 */
146  mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
147 
148  /* update number of bits */
149  if ((mdContext->i[0] + ((u32_t)inLen << 3)) < mdContext->i[0]) {
150  mdContext->i[1]++;
151  }
152  mdContext->i[0] += ((u32_t)inLen << 3);
153  mdContext->i[1] += ((u32_t)inLen >> 29);
154 
155  while (inLen--) {
156  /* add new character to buffer, increment mdi */
157  mdContext->in[mdi++] = *inBuf++;
158 
159  /* transform if necessary */
160  if (mdi == 0x40) {
161  for (i = 0, ii = 0; i < 16; i++, ii += 4) {
162  in[i] = (((u32_t)mdContext->in[ii+3]) << 24) |
163  (((u32_t)mdContext->in[ii+2]) << 16) |
164  (((u32_t)mdContext->in[ii+1]) << 8) |
165  ((u32_t)mdContext->in[ii]);
166  }
167  Transform (mdContext->buf, in);
168  mdi = 0;
169  }
170  }
171 }
172 
173 /* The routine MD5Final terminates the message-digest computation and
174  ends with the desired message digest in mdContext->digest[0...15].
175  */
176 void
177 MD5Final (unsigned char hash[], MD5_CTX *mdContext)
178 {
179  u32_t in[16];
180  int mdi;
181  unsigned int i, ii;
182  unsigned int padLen;
183 
184  /* save number of bits */
185  in[14] = mdContext->i[0];
186  in[15] = mdContext->i[1];
187 
188  /* compute number of bytes mod 64 */
189  mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
190 
191  /* pad out to 56 mod 64 */
192  padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
193  MD5Update (mdContext, PADDING, padLen);
194 
195  /* append length in bits and transform */
196  for (i = 0, ii = 0; i < 14; i++, ii += 4) {
197  in[i] = (((u32_t)mdContext->in[ii+3]) << 24) |
198  (((u32_t)mdContext->in[ii+2]) << 16) |
199  (((u32_t)mdContext->in[ii+1]) << 8) |
200  ((u32_t)mdContext->in[ii]);
201  }
202  Transform (mdContext->buf, in);
203 
204  /* store buffer in digest */
205  for (i = 0, ii = 0; i < 4; i++, ii += 4) {
206  mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF);
207  mdContext->digest[ii+1] =
208  (unsigned char)((mdContext->buf[i] >> 8) & 0xFF);
209  mdContext->digest[ii+2] =
210  (unsigned char)((mdContext->buf[i] >> 16) & 0xFF);
211  mdContext->digest[ii+3] =
212  (unsigned char)((mdContext->buf[i] >> 24) & 0xFF);
213  }
214  SMEMCPY(hash, mdContext->digest, 16);
215 }
216 
217 /* Basic MD5 step. Transforms buf based on in.
218  */
219 static void
220 Transform (u32_t *buf, u32_t *in)
221 {
222  u32_t a = buf[0], b = buf[1], c = buf[2], d = buf[3];
223 
224  /* Round 1 */
225 #define S11 7
226 #define S12 12
227 #define S13 17
228 #define S14 22
229  FF ( a, b, c, d, in[ 0], S11, UL(3614090360)); /* 1 */
230  FF ( d, a, b, c, in[ 1], S12, UL(3905402710)); /* 2 */
231  FF ( c, d, a, b, in[ 2], S13, UL( 606105819)); /* 3 */
232  FF ( b, c, d, a, in[ 3], S14, UL(3250441966)); /* 4 */
233  FF ( a, b, c, d, in[ 4], S11, UL(4118548399)); /* 5 */
234  FF ( d, a, b, c, in[ 5], S12, UL(1200080426)); /* 6 */
235  FF ( c, d, a, b, in[ 6], S13, UL(2821735955)); /* 7 */
236  FF ( b, c, d, a, in[ 7], S14, UL(4249261313)); /* 8 */
237  FF ( a, b, c, d, in[ 8], S11, UL(1770035416)); /* 9 */
238  FF ( d, a, b, c, in[ 9], S12, UL(2336552879)); /* 10 */
239  FF ( c, d, a, b, in[10], S13, UL(4294925233)); /* 11 */
240  FF ( b, c, d, a, in[11], S14, UL(2304563134)); /* 12 */
241  FF ( a, b, c, d, in[12], S11, UL(1804603682)); /* 13 */
242  FF ( d, a, b, c, in[13], S12, UL(4254626195)); /* 14 */
243  FF ( c, d, a, b, in[14], S13, UL(2792965006)); /* 15 */
244  FF ( b, c, d, a, in[15], S14, UL(1236535329)); /* 16 */
245 
246  /* Round 2 */
247 #define S21 5
248 #define S22 9
249 #define S23 14
250 #define S24 20
251  GG ( a, b, c, d, in[ 1], S21, UL(4129170786)); /* 17 */
252  GG ( d, a, b, c, in[ 6], S22, UL(3225465664)); /* 18 */
253  GG ( c, d, a, b, in[11], S23, UL( 643717713)); /* 19 */
254  GG ( b, c, d, a, in[ 0], S24, UL(3921069994)); /* 20 */
255  GG ( a, b, c, d, in[ 5], S21, UL(3593408605)); /* 21 */
256  GG ( d, a, b, c, in[10], S22, UL( 38016083)); /* 22 */
257  GG ( c, d, a, b, in[15], S23, UL(3634488961)); /* 23 */
258  GG ( b, c, d, a, in[ 4], S24, UL(3889429448)); /* 24 */
259  GG ( a, b, c, d, in[ 9], S21, UL( 568446438)); /* 25 */
260  GG ( d, a, b, c, in[14], S22, UL(3275163606)); /* 26 */
261  GG ( c, d, a, b, in[ 3], S23, UL(4107603335)); /* 27 */
262  GG ( b, c, d, a, in[ 8], S24, UL(1163531501)); /* 28 */
263  GG ( a, b, c, d, in[13], S21, UL(2850285829)); /* 29 */
264  GG ( d, a, b, c, in[ 2], S22, UL(4243563512)); /* 30 */
265  GG ( c, d, a, b, in[ 7], S23, UL(1735328473)); /* 31 */
266  GG ( b, c, d, a, in[12], S24, UL(2368359562)); /* 32 */
267 
268  /* Round 3 */
269 #define S31 4
270 #define S32 11
271 #define S33 16
272 #define S34 23
273  HH ( a, b, c, d, in[ 5], S31, UL(4294588738)); /* 33 */
274  HH ( d, a, b, c, in[ 8], S32, UL(2272392833)); /* 34 */
275  HH ( c, d, a, b, in[11], S33, UL(1839030562)); /* 35 */
276  HH ( b, c, d, a, in[14], S34, UL(4259657740)); /* 36 */
277  HH ( a, b, c, d, in[ 1], S31, UL(2763975236)); /* 37 */
278  HH ( d, a, b, c, in[ 4], S32, UL(1272893353)); /* 38 */
279  HH ( c, d, a, b, in[ 7], S33, UL(4139469664)); /* 39 */
280  HH ( b, c, d, a, in[10], S34, UL(3200236656)); /* 40 */
281  HH ( a, b, c, d, in[13], S31, UL( 681279174)); /* 41 */
282  HH ( d, a, b, c, in[ 0], S32, UL(3936430074)); /* 42 */
283  HH ( c, d, a, b, in[ 3], S33, UL(3572445317)); /* 43 */
284  HH ( b, c, d, a, in[ 6], S34, UL( 76029189)); /* 44 */
285  HH ( a, b, c, d, in[ 9], S31, UL(3654602809)); /* 45 */
286  HH ( d, a, b, c, in[12], S32, UL(3873151461)); /* 46 */
287  HH ( c, d, a, b, in[15], S33, UL( 530742520)); /* 47 */
288  HH ( b, c, d, a, in[ 2], S34, UL(3299628645)); /* 48 */
289 
290  /* Round 4 */
291 #define S41 6
292 #define S42 10
293 #define S43 15
294 #define S44 21
295  II ( a, b, c, d, in[ 0], S41, UL(4096336452)); /* 49 */
296  II ( d, a, b, c, in[ 7], S42, UL(1126891415)); /* 50 */
297  II ( c, d, a, b, in[14], S43, UL(2878612391)); /* 51 */
298  II ( b, c, d, a, in[ 5], S44, UL(4237533241)); /* 52 */
299  II ( a, b, c, d, in[12], S41, UL(1700485571)); /* 53 */
300  II ( d, a, b, c, in[ 3], S42, UL(2399980690)); /* 54 */
301  II ( c, d, a, b, in[10], S43, UL(4293915773)); /* 55 */
302  II ( b, c, d, a, in[ 1], S44, UL(2240044497)); /* 56 */
303  II ( a, b, c, d, in[ 8], S41, UL(1873313359)); /* 57 */
304  II ( d, a, b, c, in[15], S42, UL(4264355552)); /* 58 */
305  II ( c, d, a, b, in[ 6], S43, UL(2734768916)); /* 59 */
306  II ( b, c, d, a, in[13], S44, UL(1309151649)); /* 60 */
307  II ( a, b, c, d, in[ 4], S41, UL(4149444226)); /* 61 */
308  II ( d, a, b, c, in[11], S42, UL(3174756917)); /* 62 */
309  II ( c, d, a, b, in[ 2], S43, UL( 718787259)); /* 63 */
310  II ( b, c, d, a, in[ 9], S44, UL(3951481745)); /* 64 */
311 
312  buf[0] += a;
313  buf[1] += b;
314  buf[2] += c;
315  buf[3] += d;
316 }
317 
318 #endif /* CHAP_SUPPORT || MD5_SUPPORT */
319 
320 #endif /* PPP_SUPPORT */
#define SMEMCPY(dst, src, len)
Definition: opt.h:92
#define PPPDEBUG(a, b)
Definition: pppdebug.h:69
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
VOID NTAPI MD5Update(MD5_CTX *ctx, const unsigned char *buf, unsigned int len)
Definition: md5.c:59
VOID NTAPI MD5Init(MD5_CTX *ctx)
Definition: md5.c:45
VOID NTAPI MD5Final(MD5_CTX *ctx)
Definition: md5.c:113
#define HH(a, b, c, d, x, s)
Definition: md4.c:173
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define a
Definition: ke_i.h:78
#define LWIP_MIN(x, y)
Definition: def.h:44
unsigned char
Definition: typeof.h:29
#define b
Definition: ke_i.h:79
signed int S32
Definition: xxhash.c:196
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define d
Definition: ke_i.h:81
unsigned char digest[16]
Definition: msi.c:4083
unsigned long u32_t
Definition: cc.h:25
const GLubyte * c
Definition: glext.h:8905
#define GG(a, b, c, d, x, s)
Definition: md4.c:169
unsigned int i[2]
Definition: msi.c:4080
GLuint in
Definition: glext.h:9616
#define FF(a, b, c, d, x, s)
Definition: md4.c:165
unsigned int buf[4]
Definition: msi.c:4081
unsigned char in[64]
Definition: msi.c:4082
#define c
Definition: ke_i.h:80
Definition: msi.c:4078
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
Definition: _hash_fun.h:40
#define UL
Definition: tui.h:82
#define LOG_INFO
Definition: syslog.h:51
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31