source: trunk/gsdl/packages/wv-0.5.44-gs/src/md5.c@ 1468

Last change on this file since 1468 was 1468, checked in by paynter, 24 years ago

The wv Packages from www.wvware.com is used to convert Word documents into
HTML. This is an adaptation of wv version 0.5.44 for greenstone; it is
called by the gsConvert.pl script.
  • Property svn:keywords set to Author Date Id Revision
File size: 10.1 KB
Line 
1/*
2 **********************************************************************
3 ** md5.c **
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 Version **
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 the following line if the md5.h header file is separate -- */
35#include "md5.h"
36
37/* forward declaration */
38void Transform ();
39
40static unsigned char PADDING[64] = {
41 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
42 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
43 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
44 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
45 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
46 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
47 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
48 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
49};
50
51/* F, G and H are basic MD5 functions: selection, majority, parity */
52#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
53#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
54#define H(x, y, z) ((x) ^ (y) ^ (z))
55#define I(x, y, z) ((y) ^ ((x) | (~z)))
56
57/* ROTATE_LEFT rotates x left n bits */
58#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
59
60/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4 */
61/* Rotation is separate from addition to prevent recomputation */
62#define FF(a, b, c, d, x, s, ac) \
63 {(a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
64 (a) = ROTATE_LEFT ((a), (s)); \
65 (a) += (b); \
66 }
67#define GG(a, b, c, d, x, s, ac) \
68 {(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
69 (a) = ROTATE_LEFT ((a), (s)); \
70 (a) += (b); \
71 }
72#define HH(a, b, c, d, x, s, ac) \
73 {(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
74 (a) = ROTATE_LEFT ((a), (s)); \
75 (a) += (b); \
76 }
77#define II(a, b, c, d, x, s, ac) \
78 {(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
79 (a) = ROTATE_LEFT ((a), (s)); \
80 (a) += (b); \
81 }
82
83void MD5Init (mdContext)
84MD5_CTX *mdContext;
85{
86 mdContext->i[0] = mdContext->i[1] = (UINT4)0;
87
88 /* Load magic initialization constants.
89 */
90 mdContext->buf[0] = (UINT4)0x67452301;
91 mdContext->buf[1] = (UINT4)0xefcdab89;
92 mdContext->buf[2] = (UINT4)0x98badcfe;
93 mdContext->buf[3] = (UINT4)0x10325476;
94}
95
96void MD5Update (mdContext, inBuf, inLen)
97MD5_CTX *mdContext;
98unsigned char *inBuf;
99unsigned int inLen;
100{
101 UINT4 in[16];
102 int mdi;
103 unsigned int i, ii;
104
105 /* compute number of bytes mod 64 */
106 mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
107
108 /* update number of bits */
109 if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0])
110 mdContext->i[1]++;
111 mdContext->i[0] += ((UINT4)inLen << 3);
112 mdContext->i[1] += ((UINT4)inLen >> 29);
113
114 while (inLen--) {
115 /* add new character to buffer, increment mdi */
116 mdContext->in[mdi++] = *inBuf++;
117
118 /* transform if necessary */
119 if (mdi == 0x40) {
120 for (i = 0, ii = 0; i < 16; i++, ii += 4)
121 in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
122 (((UINT4)mdContext->in[ii+2]) << 16) |
123 (((UINT4)mdContext->in[ii+1]) << 8) |
124 ((UINT4)mdContext->in[ii]);
125 Transform (mdContext->buf, in);
126 mdi = 0;
127 }
128 }
129}
130
131void MD5Final (mdContext)
132MD5_CTX *mdContext;
133{
134 UINT4 in[16];
135 int mdi;
136 unsigned int i, ii;
137 unsigned int padLen;
138
139 /* save number of bits */
140 in[14] = mdContext->i[0];
141 in[15] = mdContext->i[1];
142
143 /* compute number of bytes mod 64 */
144 mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
145
146 /* pad out to 56 mod 64 */
147 padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
148 MD5Update (mdContext, PADDING, padLen);
149
150 /* append length in bits and transform */
151 for (i = 0, ii = 0; i < 14; i++, ii += 4)
152 in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
153 (((UINT4)mdContext->in[ii+2]) << 16) |
154 (((UINT4)mdContext->in[ii+1]) << 8) |
155 ((UINT4)mdContext->in[ii]);
156 Transform (mdContext->buf, in);
157
158 /* store buffer in digest */
159 for (i = 0, ii = 0; i < 4; i++, ii += 4) {
160 mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF);
161 mdContext->digest[ii+1] =
162 (unsigned char)((mdContext->buf[i] >> 8) & 0xFF);
163 mdContext->digest[ii+2] =
164 (unsigned char)((mdContext->buf[i] >> 16) & 0xFF);
165 mdContext->digest[ii+3] =
166 (unsigned char)((mdContext->buf[i] >> 24) & 0xFF);
167 }
168}
169
170/* Basic MD5 step. Transform buf based on in.
171 */
172void Transform (buf, in)
173UINT4 *buf;
174UINT4 *in;
175{
176 UINT4 a = buf[0], b = buf[1], c = buf[2], d = buf[3];
177
178 /* Round 1 */
179#define S11 7
180#define S12 12
181#define S13 17
182#define S14 22
183 FF ( a, b, c, d, in[ 0], S11, 3614090360UL); /* 1 */
184 FF ( d, a, b, c, in[ 1], S12, 3905402710UL); /* 2 */
185 FF ( c, d, a, b, in[ 2], S13, 606105819UL); /* 3 */
186 FF ( b, c, d, a, in[ 3], S14, 3250441966UL); /* 4 */
187 FF ( a, b, c, d, in[ 4], S11, 4118548399UL); /* 5 */
188 FF ( d, a, b, c, in[ 5], S12, 1200080426UL); /* 6 */
189 FF ( c, d, a, b, in[ 6], S13, 2821735955UL); /* 7 */
190 FF ( b, c, d, a, in[ 7], S14, 4249261313UL); /* 8 */
191 FF ( a, b, c, d, in[ 8], S11, 1770035416UL); /* 9 */
192 FF ( d, a, b, c, in[ 9], S12, 2336552879UL); /* 10 */
193 FF ( c, d, a, b, in[10], S13, 4294925233UL); /* 11 */
194 FF ( b, c, d, a, in[11], S14, 2304563134UL); /* 12 */
195 FF ( a, b, c, d, in[12], S11, 1804603682UL); /* 13 */
196 FF ( d, a, b, c, in[13], S12, 4254626195UL); /* 14 */
197 FF ( c, d, a, b, in[14], S13, 2792965006UL); /* 15 */
198 FF ( b, c, d, a, in[15], S14, 1236535329UL); /* 16 */
199
200 /* Round 2 */
201#define S21 5
202#define S22 9
203#define S23 14
204#define S24 20
205 GG ( a, b, c, d, in[ 1], S21, 4129170786UL); /* 17 */
206 GG ( d, a, b, c, in[ 6], S22, 3225465664UL); /* 18 */
207 GG ( c, d, a, b, in[11], S23, 643717713UL); /* 19 */
208 GG ( b, c, d, a, in[ 0], S24, 3921069994UL); /* 20 */
209 GG ( a, b, c, d, in[ 5], S21, 3593408605UL); /* 21 */
210 GG ( d, a, b, c, in[10], S22, 38016083UL); /* 22 */
211 GG ( c, d, a, b, in[15], S23, 3634488961UL); /* 23 */
212 GG ( b, c, d, a, in[ 4], S24, 3889429448UL); /* 24 */
213 GG ( a, b, c, d, in[ 9], S21, 568446438UL); /* 25 */
214 GG ( d, a, b, c, in[14], S22, 3275163606UL); /* 26 */
215 GG ( c, d, a, b, in[ 3], S23, 4107603335UL); /* 27 */
216 GG ( b, c, d, a, in[ 8], S24, 1163531501UL); /* 28 */
217 GG ( a, b, c, d, in[13], S21, 2850285829UL); /* 29 */
218 GG ( d, a, b, c, in[ 2], S22, 4243563512UL); /* 30 */
219 GG ( c, d, a, b, in[ 7], S23, 1735328473UL); /* 31 */
220 GG ( b, c, d, a, in[12], S24, 2368359562UL); /* 32 */
221
222 /* Round 3 */
223#define S31 4
224#define S32 11
225#define S33 16
226#define S34 23
227 HH ( a, b, c, d, in[ 5], S31, 4294588738UL); /* 33 */
228 HH ( d, a, b, c, in[ 8], S32, 2272392833UL); /* 34 */
229 HH ( c, d, a, b, in[11], S33, 1839030562UL); /* 35 */
230 HH ( b, c, d, a, in[14], S34, 4259657740UL); /* 36 */
231 HH ( a, b, c, d, in[ 1], S31, 2763975236UL); /* 37 */
232 HH ( d, a, b, c, in[ 4], S32, 1272893353UL); /* 38 */
233 HH ( c, d, a, b, in[ 7], S33, 4139469664UL); /* 39 */
234 HH ( b, c, d, a, in[10], S34, 3200236656UL); /* 40 */
235 HH ( a, b, c, d, in[13], S31, 681279174UL); /* 41 */
236 HH ( d, a, b, c, in[ 0], S32, 3936430074UL); /* 42 */
237 HH ( c, d, a, b, in[ 3], S33, 3572445317UL); /* 43 */
238 HH ( b, c, d, a, in[ 6], S34, 76029189UL); /* 44 */
239 HH ( a, b, c, d, in[ 9], S31, 3654602809UL); /* 45 */
240 HH ( d, a, b, c, in[12], S32, 3873151461UL); /* 46 */
241 HH ( c, d, a, b, in[15], S33, 530742520UL); /* 47 */
242 HH ( b, c, d, a, in[ 2], S34, 3299628645UL); /* 48 */
243
244 /* Round 4 */
245#define S41 6
246#define S42 10
247#define S43 15
248#define S44 21
249 II ( a, b, c, d, in[ 0], S41, 4096336452UL); /* 49 */
250 II ( d, a, b, c, in[ 7], S42, 1126891415UL); /* 50 */
251 II ( c, d, a, b, in[14], S43, 2878612391UL); /* 51 */
252 II ( b, c, d, a, in[ 5], S44, 4237533241UL); /* 52 */
253 II ( a, b, c, d, in[12], S41, 1700485571UL); /* 53 */
254 II ( d, a, b, c, in[ 3], S42, 2399980690UL); /* 54 */
255 II ( c, d, a, b, in[10], S43, 4293915773UL); /* 55 */
256 II ( b, c, d, a, in[ 1], S44, 2240044497UL); /* 56 */
257 II ( a, b, c, d, in[ 8], S41, 1873313359UL); /* 57 */
258 II ( d, a, b, c, in[15], S42, 4264355552UL); /* 58 */
259 II ( c, d, a, b, in[ 6], S43, 2734768916UL); /* 59 */
260 II ( b, c, d, a, in[13], S44, 1309151649UL); /* 60 */
261 II ( a, b, c, d, in[ 4], S41, 4149444226UL); /* 61 */
262 II ( d, a, b, c, in[11], S42, 3174756917UL); /* 62 */
263 II ( c, d, a, b, in[ 2], S43, 718787259UL); /* 63 */
264 II ( b, c, d, a, in[ 9], S44, 3951481745UL); /* 64 */
265
266 buf[0] += a;
267 buf[1] += b;
268 buf[2] += c;
269 buf[3] += d;
270}
271
272/*
273 **********************************************************************
274 ** End of md5.c **
275 ******************************* (cut) ********************************
276 */
Note: See TracBrowser for help on using the repository browser.