435e662a42abf99262d5220bab4532af6789e484
[openafs.git] / src / external / heimdal / hcrypto / md4.c
1 /*
2  * Copyright (c) 1995 - 2001 Kungliga Tekniska Högskolan
3  * (Royal Institute of Technology, Stockholm, Sweden).
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  *
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * 3. Neither the name of the Institute nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  */
33
34 #include "config.h"
35
36 #include "hash.h"
37 #include "md4.h"
38
39 #define A m->counter[0]
40 #define B m->counter[1]
41 #define C m->counter[2]
42 #define D m->counter[3]
43 #define X data
44
45 void
46 MD4_Init (struct md4 *m)
47 {
48   m->sz[0] = 0;
49   m->sz[1] = 0;
50   D = 0x10325476;
51   C = 0x98badcfe;
52   B = 0xefcdab89;
53   A = 0x67452301;
54 }
55
56 #define F(x,y,z) CRAYFIX((x & y) | (~x & z))
57 #define G(x,y,z) ((x & y) | (x & z) | (y & z))
58 #define H(x,y,z) (x ^ y ^ z)
59
60 #define DOIT(a,b,c,d,k,s,i,OP) \
61 a = cshift(a + OP(b,c,d) + X[k] + i, s)
62
63 #define DO1(a,b,c,d,k,s,i) DOIT(a,b,c,d,k,s,i,F)
64 #define DO2(a,b,c,d,k,s,i) DOIT(a,b,c,d,k,s,i,G)
65 #define DO3(a,b,c,d,k,s,i) DOIT(a,b,c,d,k,s,i,H)
66
67 static inline void
68 calc (struct md4 *m, uint32_t *data)
69 {
70   uint32_t AA, BB, CC, DD;
71
72   AA = A;
73   BB = B;
74   CC = C;
75   DD = D;
76
77   /* Round 1 */
78
79   DO1(A,B,C,D,0,3,0);
80   DO1(D,A,B,C,1,7,0);
81   DO1(C,D,A,B,2,11,0);
82   DO1(B,C,D,A,3,19,0);
83
84   DO1(A,B,C,D,4,3,0);
85   DO1(D,A,B,C,5,7,0);
86   DO1(C,D,A,B,6,11,0);
87   DO1(B,C,D,A,7,19,0);
88
89   DO1(A,B,C,D,8,3,0);
90   DO1(D,A,B,C,9,7,0);
91   DO1(C,D,A,B,10,11,0);
92   DO1(B,C,D,A,11,19,0);
93
94   DO1(A,B,C,D,12,3,0);
95   DO1(D,A,B,C,13,7,0);
96   DO1(C,D,A,B,14,11,0);
97   DO1(B,C,D,A,15,19,0);
98
99   /* Round 2 */
100
101   DO2(A,B,C,D,0,3,0x5A827999);
102   DO2(D,A,B,C,4,5,0x5A827999);
103   DO2(C,D,A,B,8,9,0x5A827999);
104   DO2(B,C,D,A,12,13,0x5A827999);
105
106   DO2(A,B,C,D,1,3,0x5A827999);
107   DO2(D,A,B,C,5,5,0x5A827999);
108   DO2(C,D,A,B,9,9,0x5A827999);
109   DO2(B,C,D,A,13,13,0x5A827999);
110
111   DO2(A,B,C,D,2,3,0x5A827999);
112   DO2(D,A,B,C,6,5,0x5A827999);
113   DO2(C,D,A,B,10,9,0x5A827999);
114   DO2(B,C,D,A,14,13,0x5A827999);
115
116   DO2(A,B,C,D,3,3,0x5A827999);
117   DO2(D,A,B,C,7,5,0x5A827999);
118   DO2(C,D,A,B,11,9,0x5A827999);
119   DO2(B,C,D,A,15,13,0x5A827999);
120
121   /* Round 3 */
122
123   DO3(A,B,C,D,0,3,0x6ED9EBA1);
124   DO3(D,A,B,C,8,9,0x6ED9EBA1);
125   DO3(C,D,A,B,4,11,0x6ED9EBA1);
126   DO3(B,C,D,A,12,15,0x6ED9EBA1);
127
128   DO3(A,B,C,D,2,3,0x6ED9EBA1);
129   DO3(D,A,B,C,10,9,0x6ED9EBA1);
130   DO3(C,D,A,B,6,11,0x6ED9EBA1);
131   DO3(B,C,D,A,14,15,0x6ED9EBA1);
132
133   DO3(A,B,C,D,1,3,0x6ED9EBA1);
134   DO3(D,A,B,C,9,9,0x6ED9EBA1);
135   DO3(C,D,A,B,5,11,0x6ED9EBA1);
136   DO3(B,C,D,A,13,15,0x6ED9EBA1);
137
138   DO3(A,B,C,D,3,3,0x6ED9EBA1);
139   DO3(D,A,B,C,11,9,0x6ED9EBA1);
140   DO3(C,D,A,B,7,11,0x6ED9EBA1);
141   DO3(B,C,D,A,15,15,0x6ED9EBA1);
142
143   A += AA;
144   B += BB;
145   C += CC;
146   D += DD;
147 }
148
149 /*
150  * From `Performance analysis of MD5' by Joseph D. Touch <touch@isi.edu>
151  */
152
153 #if defined(WORDS_BIGENDIAN)
154 static inline uint32_t
155 swap_uint32_t (uint32_t t)
156 {
157   uint32_t temp1, temp2;
158
159   temp1   = cshift(t, 16);
160   temp2   = temp1 >> 8;
161   temp1  &= 0x00ff00ff;
162   temp2  &= 0x00ff00ff;
163   temp1 <<= 8;
164   return temp1 | temp2;
165 }
166 #endif
167
168 struct x32{
169   unsigned int a:32;
170   unsigned int b:32;
171 };
172
173 void
174 MD4_Update (struct md4 *m, const void *v, size_t len)
175 {
176     const unsigned char *p = v;
177     size_t old_sz = m->sz[0];
178     size_t offset;
179
180     m->sz[0] += len * 8;
181     if (m->sz[0] < old_sz)
182         ++m->sz[1];
183     offset = (old_sz / 8)  % 64;
184     while(len > 0) {
185         size_t l = min(len, 64 - offset);
186         memcpy(m->save + offset, p, l);
187         offset += l;
188         p += l;
189         len -= l;
190         if(offset == 64) {
191 #if defined(WORDS_BIGENDIAN)
192             int i;
193             uint32_t current[16];
194             struct x32 *u = (struct x32*)m->save;
195             for(i = 0; i < 8; i++){
196                 current[2*i+0] = swap_uint32_t(u[i].a);
197                 current[2*i+1] = swap_uint32_t(u[i].b);
198             }
199             calc(m, current);
200 #else
201             calc(m, (uint32_t*)m->save);
202 #endif
203             offset = 0;
204         }
205     }
206 }
207
208 void
209 MD4_Final (void *res, struct md4 *m)
210 {
211   unsigned char zeros[72];
212   unsigned offset = (m->sz[0] / 8) % 64;
213   unsigned int dstart = (120 - offset - 1) % 64 + 1;
214
215   *zeros = 0x80;
216   memset (zeros + 1, 0, sizeof(zeros) - 1);
217   zeros[dstart+0] = (m->sz[0] >> 0) & 0xff;
218   zeros[dstart+1] = (m->sz[0] >> 8) & 0xff;
219   zeros[dstart+2] = (m->sz[0] >> 16) & 0xff;
220   zeros[dstart+3] = (m->sz[0] >> 24) & 0xff;
221   zeros[dstart+4] = (m->sz[1] >> 0) & 0xff;
222   zeros[dstart+5] = (m->sz[1] >> 8) & 0xff;
223   zeros[dstart+6] = (m->sz[1] >> 16) & 0xff;
224   zeros[dstart+7] = (m->sz[1] >> 24) & 0xff;
225   MD4_Update (m, zeros, dstart + 8);
226   {
227       int i;
228       unsigned char *r = (unsigned char *)res;
229
230       for (i = 0; i < 4; ++i) {
231           r[4*i]   = m->counter[i] & 0xFF;
232           r[4*i+1] = (m->counter[i] >> 8) & 0xFF;
233           r[4*i+2] = (m->counter[i] >> 16) & 0xFF;
234           r[4*i+3] = (m->counter[i] >> 24) & 0xFF;
235       }
236   }
237 #if 0
238   {
239     int i;
240     uint32_t *r = (uint32_t *)res;
241
242     for (i = 0; i < 4; ++i)
243       r[i] = swap_uint32_t (m->counter[i]);
244   }
245 #endif
246 }