/[dtapublic]/projs/trunk/shared_source/c_datd/esrg_md5.c
ViewVC logotype

Contents of /projs/trunk/shared_source/c_datd/esrg_md5.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 56 - (show annotations) (download)
Sat Oct 29 01:53:01 2016 UTC (7 years, 8 months ago) by dashley
File MIME type: text/plain
File size: 16350 byte(s)
License and property (keyword) changes.
1 //$Header$
2 //-------------------------------------------------------------------------------------------------
3 //This file is part of "David T. Ashley's Shared Source Code", a set of shared components
4 //integrated into many of David T. Ashley's projects.
5 //-------------------------------------------------------------------------------------------------
6 //This source code and any program in which it is compiled/used is provided under the MIT License,
7 //reproduced below.
8 //-------------------------------------------------------------------------------------------------
9 //Permission is hereby granted, free of charge, to any person obtaining a copy of
10 //this software and associated documentation files(the "Software"), to deal in the
11 //Software without restriction, including without limitation the rights to use,
12 //copy, modify, merge, publish, distribute, sublicense, and / or sell copies of the
13 //Software, and to permit persons to whom the Software is furnished to do so,
14 //subject to the following conditions :
15 //
16 //The above copyright notice and this permission notice shall be included in all
17 //copies or substantial portions of the Software.
18 //
19 //THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 //IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 //FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
22 //AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 //LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 //OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 //SOFTWARE.
26 //-------------------------------------------------------------------------------------------------
27 /* A description of the functionality of this module and the public interface
28 ** definition is contained in the associated .H file.
29 */
30
31 #define MODULE_ESRG_MD5
32
33 #include <assert.h>
34 #include <stddef.h>
35 #include <string.h>
36
37 #include "charfunc.h"
38 #include "esrg_md5.h"
39
40 //These are macros which are defined for efficiency. These
41 //functions come from RFC 1321.
42 #define ESRG_MD5_FUNC_F(x,y,z) (((x) & (y)) | ((~x) & (z)))
43 #define ESRG_MD5_FUNC_G(x,y,z) (((x) & (z)) | ( (y) & (~z)))
44 #define ESRG_MD5_FUNC_H(x,y,z) ((x) ^ (y) ^ (z))
45 #define ESRG_MD5_FUNC_I(x,y,z) ((y) ^ ((x) | (~z)))
46
47 //This is a left rotation macro, again for efficiency. This
48 //macro rotates a 32-bit quantity x left (cyclically) by
49 //n bits.
50 #define ESRG_MD5_FUNC_ROT_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
51
52 //These macros do one operation as described in the RFC. These allow
53 //the inlining of code for far more speed.
54 #define ESRG_MD5_FUNC_FF(a,b,c,d,x,s,ac) { \
55 (a) += ESRG_MD5_FUNC_F((b),(c),(d)) + (x) + (unsigned)(ac); \
56 (a) = ESRG_MD5_FUNC_ROT_LEFT((a),(s)); \
57 (a) += (b); \
58 }
59 #define ESRG_MD5_FUNC_GG(a,b,c,d,x,s,ac) { \
60 (a) += ESRG_MD5_FUNC_G((b),(c),(d)) + (x) + (unsigned)(ac); \
61 (a) = ESRG_MD5_FUNC_ROT_LEFT((a),(s)); \
62 (a) += (b); \
63 }
64 #define ESRG_MD5_FUNC_HH(a,b,c,d,x,s,ac) { \
65 (a) += ESRG_MD5_FUNC_H((b),(c),(d)) + (x) + (unsigned)(ac); \
66 (a) = ESRG_MD5_FUNC_ROT_LEFT((a),(s)); \
67 (a) += (b); \
68 }
69 #define ESRG_MD5_FUNC_II(a,b,c,d,x,s,ac) { \
70 (a) += ESRG_MD5_FUNC_I((b),(c),(d)) + (x) + (unsigned)(ac); \
71 (a) = ESRG_MD5_FUNC_ROT_LEFT((a),(s)); \
72 (a) += (b); \
73 }
74
75
76 //This is the padding table to append. It is done with
77 //an array for quickness.
78 static unsigned char ESRG_MD5_pad_table[] =
79 {
80 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
81 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
82 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
83 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
84 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
85 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
86 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
87 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
88 };
89
90
91 void ESRG_MD5_Md5StateStructOpen(struct ESRG_MD5_Md5StateStruct *arg)
92 {
93 assert(arg != NULL);
94
95 memset(arg, 0, sizeof(struct ESRG_MD5_Md5StateStruct));
96 //Everything to zero, processed bitcount automatically set to zero.
97
98 arg->A = 0x67452301; //These assignments directly from RFC.
99 arg->B = 0xEFCDAB89;
100 arg->C = 0x98BADCFE;
101 arg->D = 0x10325476;
102 }
103
104
105 //Copies the byte buffer to the word buffer within the state block.
106 //This is done in a way which hides big-endian/little-endian concerns.
107
108 static void ESRG_MD5_CopyBytesToWords(struct ESRG_MD5_Md5StateStruct *arg)
109 {
110 int i;
111
112 assert(arg != NULL);
113
114 //Copy the buffer contents into the words. We need to be careful
115 //to do this right, because of big-endian/little-endian concerns.
116 for (i=0; i<16; i++)
117 {
118 assert((i * 4 + 3) < 64);
119 arg->X[i] = (((unsigned int)(arg->buf[i*4+3])) << 24)
120 +
121 (((unsigned int)(arg->buf[i*4+2])) << 16)
122 +
123 (((unsigned int)(arg->buf[i*4+1])) << 8)
124 +
125 (((unsigned int)(arg->buf[i*4])) );
126 }
127 }
128
129
130 //Does the MD-5 rounds as specified by RFC 1321.
131
132 static void ESRG_MD5_DoMd5Rounds(struct ESRG_MD5_Md5StateStruct *arg)
133 {
134 unsigned AA, BB, CC, DD;
135 //Directly from RFC 1321.
136 unsigned A, B, C, D;
137 //We also want to buffer out the state variables, to eliminate
138 //the risk of repeated pointer dereferences.
139 unsigned X[16];
140 //Buffer to avoid repeated dereferences.
141
142 assert(arg != NULL);
143
144 //Copy bytes into words.
145 ESRG_MD5_CopyBytesToWords(arg);
146
147 //Copy out the buffer for speed.
148 X[ 0] = arg->X[ 0];
149 X[ 1] = arg->X[ 1];
150 X[ 2] = arg->X[ 2];
151 X[ 3] = arg->X[ 3];
152 X[ 4] = arg->X[ 4];
153 X[ 5] = arg->X[ 5];
154 X[ 6] = arg->X[ 6];
155 X[ 7] = arg->X[ 7];
156 X[ 8] = arg->X[ 8];
157 X[ 9] = arg->X[ 9];
158 X[10] = arg->X[10];
159 X[11] = arg->X[11];
160 X[12] = arg->X[12];
161 X[13] = arg->X[13];
162 X[14] = arg->X[14];
163 X[15] = arg->X[15];
164
165 //Buffer out the state for speed.
166 A = arg->A;
167 B = arg->B;
168 C = arg->C;
169 D = arg->D;
170
171 //Make the assignments to temporary variables as described by the RFC.
172 AA = A;
173 BB = B;
174 CC = C;
175 DD = D;
176
177 //We can now do the MD-5 rounds directly as described in the RFC. The
178 //most effective way to do this is with macros. I tried using a tabulated
179 //approach, but the speed hit was unbelievably bad. This approach is
180 //about the best known.
181 //
182 //Round 1
183 //
184 ESRG_MD5_FUNC_FF(A,B,C,D,X[ 0], 7,0xd76aa478); /* 1 */
185 ESRG_MD5_FUNC_FF(D,A,B,C,X[ 1],12,0xe8c7b756); /* 2 */
186 ESRG_MD5_FUNC_FF(C,D,A,B,X[ 2],17,0x242070db); /* 3 */
187 ESRG_MD5_FUNC_FF(B,C,D,A,X[ 3],22,0xc1bdceee); /* 4 */
188 ESRG_MD5_FUNC_FF(A,B,C,D,X[ 4], 7,0xf57c0faf); /* 5 */
189 ESRG_MD5_FUNC_FF(D,A,B,C,X[ 5],12,0x4787c62a); /* 6 */
190 ESRG_MD5_FUNC_FF(C,D,A,B,X[ 6],17,0xa8304613); /* 7 */
191 ESRG_MD5_FUNC_FF(B,C,D,A,X[ 7],22,0xfd469501); /* 8 */
192 ESRG_MD5_FUNC_FF(A,B,C,D,X[ 8], 7,0x698098d8); /* 9 */
193 ESRG_MD5_FUNC_FF(D,A,B,C,X[ 9],12,0x8b44f7af); /* 10 */
194 ESRG_MD5_FUNC_FF(C,D,A,B,X[10],17,0xffff5bb1); /* 11 */
195 ESRG_MD5_FUNC_FF(B,C,D,A,X[11],22,0x895cd7be); /* 12 */
196 ESRG_MD5_FUNC_FF(A,B,C,D,X[12], 7,0x6b901122); /* 13 */
197 ESRG_MD5_FUNC_FF(D,A,B,C,X[13],12,0xfd987193); /* 14 */
198 ESRG_MD5_FUNC_FF(C,D,A,B,X[14],17,0xa679438e); /* 15 */
199 ESRG_MD5_FUNC_FF(B,C,D,A,X[15],22,0x49b40821); /* 16 */
200 //
201 //Round 2
202 //
203 ESRG_MD5_FUNC_GG(A,B,C,D,X[ 1], 5,0xf61e2562); /* 17 */
204 ESRG_MD5_FUNC_GG(D,A,B,C,X[ 6], 9,0xc040b340); /* 18 */
205 ESRG_MD5_FUNC_GG(C,D,A,B,X[11],14,0x265e5a51); /* 19 */
206 ESRG_MD5_FUNC_GG(B,C,D,A,X[ 0],20,0xe9b6c7aa); /* 20 */
207 ESRG_MD5_FUNC_GG(A,B,C,D,X[ 5], 5,0xd62f105d); /* 21 */
208 ESRG_MD5_FUNC_GG(D,A,B,C,X[10], 9,0x02441453); /* 22 */
209 ESRG_MD5_FUNC_GG(C,D,A,B,X[15],14,0xd8a1e681); /* 23 */
210 ESRG_MD5_FUNC_GG(B,C,D,A,X[ 4],20,0xe7d3fbc8); /* 24 */
211 ESRG_MD5_FUNC_GG(A,B,C,D,X[ 9], 5,0x21e1cde6); /* 25 */
212 ESRG_MD5_FUNC_GG(D,A,B,C,X[14], 9,0xc33707d6); /* 26 */
213 ESRG_MD5_FUNC_GG(C,D,A,B,X[ 3],14,0xf4d50d87); /* 27 */
214 ESRG_MD5_FUNC_GG(B,C,D,A,X[ 8],20,0x455a14ed); /* 28 */
215 ESRG_MD5_FUNC_GG(A,B,C,D,X[13], 5,0xa9e3e905); /* 29 */
216 ESRG_MD5_FUNC_GG(D,A,B,C,X[ 2], 9,0xfcefa3f8); /* 30 */
217 ESRG_MD5_FUNC_GG(C,D,A,B,X[ 7],14,0x676f02d9); /* 31 */
218 ESRG_MD5_FUNC_GG(B,C,D,A,X[12],20,0x8d2a4c8a); /* 32 */
219 //
220 //Round 3
221 //
222 ESRG_MD5_FUNC_HH(A,B,C,D,X[ 5], 4,0xfffa3942); /* 33 */
223 ESRG_MD5_FUNC_HH(D,A,B,C,X[ 8],11,0x8771f681); /* 34 */
224 ESRG_MD5_FUNC_HH(C,D,A,B,X[11],16,0x6d9d6122); /* 35 */
225 ESRG_MD5_FUNC_HH(B,C,D,A,X[14],23,0xfde5380c); /* 36 */
226 ESRG_MD5_FUNC_HH(A,B,C,D,X[ 1], 4,0xa4beea44); /* 37 */
227 ESRG_MD5_FUNC_HH(D,A,B,C,X[ 4],11,0x4bdecfa9); /* 38 */
228 ESRG_MD5_FUNC_HH(C,D,A,B,X[ 7],16,0xf6bb4b60); /* 39 */
229 ESRG_MD5_FUNC_HH(B,C,D,A,X[10],23,0xbebfbc70); /* 40 */
230 ESRG_MD5_FUNC_HH(A,B,C,D,X[13], 4,0x289b7ec6); /* 41 */
231 ESRG_MD5_FUNC_HH(D,A,B,C,X[ 0],11,0xeaa127fa); /* 42 */
232 ESRG_MD5_FUNC_HH(C,D,A,B,X[ 3],16,0xd4ef3085); /* 43 */
233 ESRG_MD5_FUNC_HH(B,C,D,A,X[ 6],23,0x04881d05); /* 44 */
234 ESRG_MD5_FUNC_HH(A,B,C,D,X[ 9], 4,0xd9d4d039); /* 45 */
235 ESRG_MD5_FUNC_HH(D,A,B,C,X[12],11,0xe6db99e5); /* 46 */
236 ESRG_MD5_FUNC_HH(C,D,A,B,X[15],16,0x1fa27cf8); /* 47 */
237 ESRG_MD5_FUNC_HH(B,C,D,A,X[ 2],23,0xc4ac5665); /* 48 */
238 //
239 //Round 4
240 //
241 ESRG_MD5_FUNC_II(A,B,C,D,X[ 0], 6,0xf4292244); /* 49 */
242 ESRG_MD5_FUNC_II(D,A,B,C,X[ 7],10,0x432aff97); /* 50 */
243 ESRG_MD5_FUNC_II(C,D,A,B,X[14],15,0xab9423a7); /* 51 */
244 ESRG_MD5_FUNC_II(B,C,D,A,X[ 5],21,0xfc93a039); /* 52 */
245 ESRG_MD5_FUNC_II(A,B,C,D,X[12], 6,0x655b59c3); /* 53 */
246 ESRG_MD5_FUNC_II(D,A,B,C,X[ 3],10,0x8f0ccc92); /* 54 */
247 ESRG_MD5_FUNC_II(C,D,A,B,X[10],15,0xffeff47d); /* 55 */
248 ESRG_MD5_FUNC_II(B,C,D,A,X[ 1],21,0x85845dd1); /* 56 */
249 ESRG_MD5_FUNC_II(A,B,C,D,X[ 8], 6,0x6fa87e4f); /* 57 */
250 ESRG_MD5_FUNC_II(D,A,B,C,X[15],10,0xfe2ce6e0); /* 58 */
251 ESRG_MD5_FUNC_II(C,D,A,B,X[ 6],15,0xa3014314); /* 59 */
252 ESRG_MD5_FUNC_II(B,C,D,A,X[13],21,0x4e0811a1); /* 60 */
253 ESRG_MD5_FUNC_II(A,B,C,D,X[ 4], 6,0xf7537e82); /* 61 */
254 ESRG_MD5_FUNC_II(D,A,B,C,X[11],10,0xbd3af235); /* 62 */
255 ESRG_MD5_FUNC_II(C,D,A,B,X[ 2],15,0x2ad7d2bb); /* 63 */
256 ESRG_MD5_FUNC_II(B,C,D,A,X[ 9],21,0xeb86d391); /* 64 */
257 //End of Round 4.
258
259 //Perform the four additions as mandated by the RFC.
260 A += AA;
261 B += BB;
262 C += CC;
263 D += DD;
264
265 //Buffer the state vector back.
266 arg->A = A;
267 arg->B = B;
268 arg->C = C;
269 arg->D = D;
270 }
271
272
273 void ESRG_MD5_Md5StateStructAddData(struct ESRG_MD5_Md5StateStruct *arg,
274 void *pointer_in,
275 unsigned len)
276 {
277 unsigned int low_32;
278 unsigned int byte_offset;
279 unsigned char *data;
280
281 assert(arg != NULL);
282 assert(pointer_in != NULL);
283
284 data = (unsigned char *)pointer_in;
285 //It is easier to do it this way, rather than cast all the time.
286
287 low_32 = (unsigned int)arg->bit_count;
288 //Copy off the least significant bits. Easier to do once.
289
290 byte_offset = low_32 >> 3;
291 //This gives our byte offset, up to 500+Mb or so.
292
293 while(len--)
294 {
295 //We process rounds AFTER a byte is added to the buffer. So
296 //it is always safe to add a byte first.
297 arg->buf[byte_offset & 0x3F] = *data;
298
299 //Nothing to do unless this was the final byte of the buffer.
300 if ((byte_offset & 0x3F) == 63)
301 {
302 ESRG_MD5_DoMd5Rounds(arg);
303 }
304
305 //Increment.
306 data++;
307 byte_offset++;
308 arg->bit_count += 8;
309 }
310 }
311
312
313 void ESRG_MD5_Md5StateStructClose(struct ESRG_MD5_Md5StateStruct *state,
314 struct ESRG_MD5_Md5ResultStruct *result)
315 {
316 unsigned int low_32, high_32, high_32_copy, low_32_copy;
317 unsigned int byte_offset;
318 unsigned int buffer_offset;
319 unsigned char length_buf[8];
320 //int i;
321
322 assert(state != NULL);
323 assert(result != NULL);
324
325 //Obtain easier-to-use indices. These provide a snapshot of the
326 //length before padding is done.
327 low_32 = (unsigned int)state->bit_count;
328 high_32 = (unsigned int)(state->bit_count >> 32);
329 byte_offset = low_32 >> 3;
330 buffer_offset = byte_offset & 0x3F;
331
332 //We need to pad the buffer out to 8 bytes short of a multiple,
333 //per RFC 1321.
334 ESRG_MD5_Md5StateStructAddData(state,
335 ESRG_MD5_pad_table,
336 (buffer_offset==56) ? (64) : ((56 - buffer_offset) & 0x3F));
337
338 //At this point we are fully prepped to stuff in the length in bits.
339 //Prepare the length in a buffer.
340 high_32_copy = high_32;
341 low_32_copy = low_32;
342 length_buf[0] = (unsigned char)(low_32_copy);
343 length_buf[1] = (unsigned char)(low_32_copy >> 8);
344 length_buf[2] = (unsigned char)(low_32_copy >> 16);
345 length_buf[3] = (unsigned char)(low_32_copy >> 24);
346 length_buf[4] = (unsigned char)(high_32_copy);
347 length_buf[5] = (unsigned char)(high_32_copy >> 8);
348 length_buf[6] = (unsigned char)(high_32_copy >> 16);
349 length_buf[7] = (unsigned char)(high_32_copy >> 24);
350
351 //Tack on the length. This is guaranteed to generate end up with
352 //the last thing being done the compute plus the index being zero.
353 //
354 ESRG_MD5_Md5StateStructAddData(state,
355 length_buf,
356 8);
357
358 //Be absolutely sure we are rolled over to zero.
359 assert((((int)state->bit_count) & 0x1FF) == 0);
360
361 //Zero out the return state, just to be sure.
362 memset(result, 0, sizeof(struct ESRG_MD5_Md5ResultStruct));
363
364 //Give caller the binary version.
365 result->md5_words[0] = state->A;
366 result->md5_words[1] = state->B;
367 result->md5_words[2] = state->C;
368 result->md5_words[3] = state->D;
369
370 //Convert to string for caller.
371 CHARFUNC_int_to_lc_hex_rev(state->A, result->md5_chars + 0);
372 CHARFUNC_int_to_lc_hex_rev(state->B, result->md5_chars + 8);
373 CHARFUNC_int_to_lc_hex_rev(state->C, result->md5_chars + 16);
374 CHARFUNC_int_to_lc_hex_rev(state->D, result->md5_chars + 24);
375
376 //Because of the way the CHARFUNC_int_to_lc_hex_rev() function
377 //works, it produces the mirror image of the sequence of nibbles.
378 //This is not quite what we want. What we want (least significant
379 //byte first, but within each byte most significant nibble first)
380 //from each integer is this:
381 //
382 // n1 n0 n3 n2 n5 n4 n7 n6
383 //
384 //but what we get from that function is this:
385 //
386 // n0 n1 n2 n3 n4 n5 n6 n6,
387 //
388 //so we have to swap nibbles in each byte.
389 //
390 {
391 int i;
392 char temp;
393
394 for (i=0; i<16; i++)
395 {
396 temp = result->md5_chars[i*2];
397 result->md5_chars[i*2] = result->md5_chars[i*2+1];
398 result->md5_chars[i*2+1] = temp;
399 }
400 }
401
402 result->md5_chars[32] = 0; //Terminator.
403
404 //Destroy the state, which may contain sensitive information.
405 //This idea came from Rivest's sample code.
406 memset(state, 0, sizeof(struct ESRG_MD5_Md5StateStruct));
407 }
408
409
410 //Returns version control string for file.
411 //
412 const char *ESRG_MD5_cvcinfo(void)
413 {
414 return ("$Header$");
415 }
416
417
418 //Returns version control string for associated .H file.
419 //
420 const char *ESRG_MD5_hvcinfo(void)
421 {
422 return (ESRG_MD5_H_VERSION);
423 }
424
425 //End of esrg_md5.c.

Properties

Name Value
svn:keywords Header

dashley@gmail.com
ViewVC Help
Powered by ViewVC 1.1.25