1 /* MD4C.C - RSA Data Security, Inc., MD4 message-digest algorithm
2 */
3
4 /*-
5 SPDX-License-Identifier: RSA-MD
6
7 Copyright (C) 1990-2, RSA Data Security, Inc. All rights reserved.
8
9 License to copy and use this software is granted provided that it
10 is identified as the "RSA Data Security, Inc. MD4 Message-Digest
11 Algorithm" in all material mentioning or referencing this software
12 or this function.
13
14 License is also granted to make and use derivative works provided
15 that such works are identified as "derived from the RSA Data
16 Security, Inc. MD4 Message-Digest Algorithm" in all material
17 mentioning or referencing the derived work.
18
19 RSA Data Security, Inc. makes no representations concerning either
20 the merchantability of this software or the suitability of this
21 software for any particular purpose. It is provided "as is"
22 without express or implied warranty of any kind.
23
24 These notices must be retained in any copies of any part of this
25 documentation and/or software.
26 */
27
28 #include <sys/param.h>
29 #ifdef _KERNEL
30 #include <sys/systm.h>
31 #else
32 #include <string.h>
33 #endif
34 #include <sys/md4.h>
35
36 typedef unsigned char *POINTER;
37 typedef uint16_t UINT2;
38 typedef uint32_t UINT4;
39
40 #define PROTO_LIST(list) list
41
42 /* Constants for MD4Transform routine.
43 */
44 #define S11 3
45 #define S12 7
46 #define S13 11
47 #define S14 19
48 #define S21 3
49 #define S22 5
50 #define S23 9
51 #define S24 13
52 #define S31 3
53 #define S32 9
54 #define S33 11
55 #define S34 15
56
57 static void MD4Transform PROTO_LIST ((UINT4 [4], const unsigned char [64]));
58 static void Encode PROTO_LIST
59 ((unsigned char *, UINT4 *, unsigned int));
60 static void Decode PROTO_LIST
61 ((UINT4 *, const unsigned char *, unsigned int));
62
63 static unsigned char PADDING[64] = {
64 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
65 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
66 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
67 };
68
69 /* F, G and H are basic MD4 functions.
70 */
71 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
72 #define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
73 #define H(x, y, z) ((x) ^ (y) ^ (z))
74
75 /* ROTATE_LEFT rotates x left n bits.
76 */
77 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
78
79 /* FF, GG and HH are transformations for rounds 1, 2 and 3 */
80 /* Rotation is separate from addition to prevent recomputation */
81 #define FF(a, b, c, d, x, s) { \
82 (a) += F ((b), (c), (d)) + (x); \
83 (a) = ROTATE_LEFT ((a), (s)); \
84 }
85 #define GG(a, b, c, d, x, s) { \
86 (a) += G ((b), (c), (d)) + (x) + (UINT4)0x5a827999; \
87 (a) = ROTATE_LEFT ((a), (s)); \
88 }
89 #define HH(a, b, c, d, x, s) { \
90 (a) += H ((b), (c), (d)) + (x) + (UINT4)0x6ed9eba1; \
91 (a) = ROTATE_LEFT ((a), (s)); \
92 }
93
94 /* MD4 initialization. Begins an MD4 operation, writing a new context.
95 */
96 void
MD4Init(MD4_CTX * context)97 MD4Init(MD4_CTX *context)
98 {
99 context->count[0] = context->count[1] = 0;
100
101 /* Load magic initialization constants.
102 */
103 context->state[0] = 0x67452301;
104 context->state[1] = 0xefcdab89;
105 context->state[2] = 0x98badcfe;
106 context->state[3] = 0x10325476;
107 }
108
109 /* MD4 block update operation. Continues an MD4 message-digest
110 operation, processing another message block, and updating the
111 context.
112 */
113 void
MD4Update(MD4_CTX * context,const unsigned char * input,unsigned int inputLen)114 MD4Update(MD4_CTX *context, const unsigned char *input,
115 unsigned int inputLen)
116 {
117 unsigned int i, index, partLen;
118
119 /* Compute number of bytes mod 64 */
120 index = (unsigned int)((context->count[0] >> 3) & 0x3F);
121 /* Update number of bits */
122 if ((context->count[0] += ((UINT4)inputLen << 3))
123 < ((UINT4)inputLen << 3))
124 context->count[1]++;
125 context->count[1] += ((UINT4)inputLen >> 29);
126
127 partLen = 64 - index;
128 /* Transform as many times as possible.
129 */
130 if (inputLen >= partLen) {
131 bcopy(input, &context->buffer[index], partLen);
132 MD4Transform (context->state, context->buffer);
133
134 for (i = partLen; i + 63 < inputLen; i += 64)
135 MD4Transform (context->state, &input[i]);
136
137 index = 0;
138 }
139 else
140 i = 0;
141
142 /* Buffer remaining input */
143 bcopy(&input[i], &context->buffer[index], inputLen-i);
144 }
145
146 /* MD4 padding. */
147 void
MD4Pad(MD4_CTX * context)148 MD4Pad(MD4_CTX *context)
149 {
150 unsigned char bits[8];
151 unsigned int index, padLen;
152
153 /* Save number of bits */
154 Encode (bits, context->count, 8);
155
156 /* Pad out to 56 mod 64.
157 */
158 index = (unsigned int)((context->count[0] >> 3) & 0x3f);
159 padLen = (index < 56) ? (56 - index) : (120 - index);
160 MD4Update (context, PADDING, padLen);
161
162 /* Append length (before padding) */
163 MD4Update (context, bits, 8);
164 }
165
166 /* MD4 finalization. Ends an MD4 message-digest operation, writing the
167 the message digest and zeroizing the context.
168 */
169 void
MD4Final(unsigned char digest[static16],MD4_CTX * context)170 MD4Final(unsigned char digest[static 16], MD4_CTX *context)
171 {
172 /* Do padding */
173 MD4Pad (context);
174
175 /* Store state in digest */
176 Encode (digest, context->state, 16);
177
178 /* Zeroize sensitive information.
179 */
180 bzero(context, sizeof (*context));
181 }
182
183 /* MD4 basic transformation. Transforms state based on block.
184 */
185 static void
MD4Transform(UINT4 state[4],const unsigned char block[64])186 MD4Transform(UINT4 state[4], const unsigned char block[64])
187 {
188 UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
189
190 Decode (x, block, 64);
191
192 /* Round 1 */
193 FF (a, b, c, d, x[ 0], S11); /* 1 */
194 FF (d, a, b, c, x[ 1], S12); /* 2 */
195 FF (c, d, a, b, x[ 2], S13); /* 3 */
196 FF (b, c, d, a, x[ 3], S14); /* 4 */
197 FF (a, b, c, d, x[ 4], S11); /* 5 */
198 FF (d, a, b, c, x[ 5], S12); /* 6 */
199 FF (c, d, a, b, x[ 6], S13); /* 7 */
200 FF (b, c, d, a, x[ 7], S14); /* 8 */
201 FF (a, b, c, d, x[ 8], S11); /* 9 */
202 FF (d, a, b, c, x[ 9], S12); /* 10 */
203 FF (c, d, a, b, x[10], S13); /* 11 */
204 FF (b, c, d, a, x[11], S14); /* 12 */
205 FF (a, b, c, d, x[12], S11); /* 13 */
206 FF (d, a, b, c, x[13], S12); /* 14 */
207 FF (c, d, a, b, x[14], S13); /* 15 */
208 FF (b, c, d, a, x[15], S14); /* 16 */
209
210 /* Round 2 */
211 GG (a, b, c, d, x[ 0], S21); /* 17 */
212 GG (d, a, b, c, x[ 4], S22); /* 18 */
213 GG (c, d, a, b, x[ 8], S23); /* 19 */
214 GG (b, c, d, a, x[12], S24); /* 20 */
215 GG (a, b, c, d, x[ 1], S21); /* 21 */
216 GG (d, a, b, c, x[ 5], S22); /* 22 */
217 GG (c, d, a, b, x[ 9], S23); /* 23 */
218 GG (b, c, d, a, x[13], S24); /* 24 */
219 GG (a, b, c, d, x[ 2], S21); /* 25 */
220 GG (d, a, b, c, x[ 6], S22); /* 26 */
221 GG (c, d, a, b, x[10], S23); /* 27 */
222 GG (b, c, d, a, x[14], S24); /* 28 */
223 GG (a, b, c, d, x[ 3], S21); /* 29 */
224 GG (d, a, b, c, x[ 7], S22); /* 30 */
225 GG (c, d, a, b, x[11], S23); /* 31 */
226 GG (b, c, d, a, x[15], S24); /* 32 */
227
228 /* Round 3 */
229 HH (a, b, c, d, x[ 0], S31); /* 33 */
230 HH (d, a, b, c, x[ 8], S32); /* 34 */
231 HH (c, d, a, b, x[ 4], S33); /* 35 */
232 HH (b, c, d, a, x[12], S34); /* 36 */
233 HH (a, b, c, d, x[ 2], S31); /* 37 */
234 HH (d, a, b, c, x[10], S32); /* 38 */
235 HH (c, d, a, b, x[ 6], S33); /* 39 */
236 HH (b, c, d, a, x[14], S34); /* 40 */
237 HH (a, b, c, d, x[ 1], S31); /* 41 */
238 HH (d, a, b, c, x[ 9], S32); /* 42 */
239 HH (c, d, a, b, x[ 5], S33); /* 43 */
240 HH (b, c, d, a, x[13], S34); /* 44 */
241 HH (a, b, c, d, x[ 3], S31); /* 45 */
242 HH (d, a, b, c, x[11], S32); /* 46 */
243 HH (c, d, a, b, x[ 7], S33); /* 47 */
244 HH (b, c, d, a, x[15], S34); /* 48 */
245
246 state[0] += a;
247 state[1] += b;
248 state[2] += c;
249 state[3] += d;
250
251 /* Zeroize sensitive information.
252 */
253 bzero((POINTER)x, sizeof (x));
254 }
255
256 /* Encodes input (UINT4) into output (unsigned char). Assumes len is
257 a multiple of 4.
258 */
259 static void
Encode(unsigned char * output,UINT4 * input,unsigned int len)260 Encode(unsigned char *output, UINT4 *input, unsigned int len)
261 {
262 unsigned int i, j;
263
264 for (i = 0, j = 0; j < len; i++, j += 4) {
265 output[j] = (unsigned char)(input[i] & 0xff);
266 output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
267 output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
268 output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
269 }
270 }
271
272 /* Decodes input (unsigned char) into output (UINT4). Assumes len is
273 a multiple of 4.
274 */
275 static void
Decode(UINT4 * output,const unsigned char * input,unsigned int len)276 Decode(UINT4 *output, const unsigned char *input, unsigned int len)
277 {
278 unsigned int i, j;
279
280 for (i = 0, j = 0; j < len; i++, j += 4)
281 output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
282 (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
283 }
284
285 #ifdef WEAK_REFS
286 /* When building libmd, provide weak references. Note: this is not
287 activated in the context of compiling these sources for internal
288 use in libcrypt.
289 */
290 #undef MD4Init
291 __weak_reference(_libmd_MD4Init, MD4Init);
292 #undef MD4Update
293 __weak_reference(_libmd_MD4Update, MD4Update);
294 #undef MD4Pad
295 __weak_reference(_libmd_MD4Pad, MD4Pad);
296 #undef MD4Final
297 __weak_reference(_libmd_MD4Final, MD4Final);
298 #endif
299