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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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

Legend:
Removed from v.56  
changed lines
  Added in v.71

dashley@gmail.com
ViewVC Help
Powered by ViewVC 1.1.25