1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
|
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifdef FREEBL_NO_DEPEND
#include "stubs.h"
#endif
#include "prerr.h"
#include "secerr.h"
#include "prtypes.h"
#include "blapi.h"
#define MD2_DIGEST_LEN 16
#define MD2_BUFSIZE 16
#define MD2_X_SIZE 48 /* The X array, [CV | INPUT | TMP VARS] */
#define MD2_CV 0 /* index into X for chaining variables */
#define MD2_INPUT 16 /* index into X for input */
#define MD2_TMPVARS 32 /* index into X for temporary variables */
#define MD2_CHECKSUM_SIZE 16
struct MD2ContextStr {
unsigned char checksum[MD2_BUFSIZE];
unsigned char X[MD2_X_SIZE];
PRUint8 unusedBuffer;
};
static const PRUint8 MD2S[256] = {
0051, 0056, 0103, 0311, 0242, 0330, 0174, 0001,
0075, 0066, 0124, 0241, 0354, 0360, 0006, 0023,
0142, 0247, 0005, 0363, 0300, 0307, 0163, 0214,
0230, 0223, 0053, 0331, 0274, 0114, 0202, 0312,
0036, 0233, 0127, 0074, 0375, 0324, 0340, 0026,
0147, 0102, 0157, 0030, 0212, 0027, 0345, 0022,
0276, 0116, 0304, 0326, 0332, 0236, 0336, 0111,
0240, 0373, 0365, 0216, 0273, 0057, 0356, 0172,
0251, 0150, 0171, 0221, 0025, 0262, 0007, 0077,
0224, 0302, 0020, 0211, 0013, 0042, 0137, 0041,
0200, 0177, 0135, 0232, 0132, 0220, 0062, 0047,
0065, 0076, 0314, 0347, 0277, 0367, 0227, 0003,
0377, 0031, 0060, 0263, 0110, 0245, 0265, 0321,
0327, 0136, 0222, 0052, 0254, 0126, 0252, 0306,
0117, 0270, 0070, 0322, 0226, 0244, 0175, 0266,
0166, 0374, 0153, 0342, 0234, 0164, 0004, 0361,
0105, 0235, 0160, 0131, 0144, 0161, 0207, 0040,
0206, 0133, 0317, 0145, 0346, 0055, 0250, 0002,
0033, 0140, 0045, 0255, 0256, 0260, 0271, 0366,
0034, 0106, 0141, 0151, 0064, 0100, 0176, 0017,
0125, 0107, 0243, 0043, 0335, 0121, 0257, 0072,
0303, 0134, 0371, 0316, 0272, 0305, 0352, 0046,
0054, 0123, 0015, 0156, 0205, 0050, 0204, 0011,
0323, 0337, 0315, 0364, 0101, 0201, 0115, 0122,
0152, 0334, 0067, 0310, 0154, 0301, 0253, 0372,
0044, 0341, 0173, 0010, 0014, 0275, 0261, 0112,
0170, 0210, 0225, 0213, 0343, 0143, 0350, 0155,
0351, 0313, 0325, 0376, 0073, 0000, 0035, 0071,
0362, 0357, 0267, 0016, 0146, 0130, 0320, 0344,
0246, 0167, 0162, 0370, 0353, 0165, 0113, 0012,
0061, 0104, 0120, 0264, 0217, 0355, 0037, 0032,
0333, 0231, 0215, 0063, 0237, 0021, 0203, 0024
};
SECStatus
MD2_Hash(unsigned char *dest, const char *src)
{
unsigned int len;
MD2Context *cx = MD2_NewContext();
if (!cx) {
PORT_SetError(PR_OUT_OF_MEMORY_ERROR);
return SECFailure;
}
MD2_Begin(cx);
MD2_Update(cx, (const unsigned char *)src, PORT_Strlen(src));
MD2_End(cx, dest, &len, MD2_DIGEST_LEN);
MD2_DestroyContext(cx, PR_TRUE);
return SECSuccess;
}
MD2Context *
MD2_NewContext(void)
{
MD2Context *cx = (MD2Context *)PORT_ZAlloc(sizeof(MD2Context));
if (cx == NULL) {
PORT_SetError(PR_OUT_OF_MEMORY_ERROR);
return NULL;
}
return cx;
}
void
MD2_DestroyContext(MD2Context *cx, PRBool freeit)
{
if (freeit)
PORT_ZFree(cx, sizeof(*cx));
}
void
MD2_Begin(MD2Context *cx)
{
memset(cx, 0, sizeof(*cx));
cx->unusedBuffer = MD2_BUFSIZE;
}
static void
md2_compress(MD2Context *cx)
{
int j;
unsigned char P;
P = cx->checksum[MD2_CHECKSUM_SIZE - 1];
/* Compute the running checksum, and set the tmp variables to be
* CV[i] XOR input[i]
*/
#define CKSUMFN(n) \
P = cx->checksum[n] ^ MD2S[cx->X[MD2_INPUT + n] ^ P]; \
cx->checksum[n] = P; \
cx->X[MD2_TMPVARS + n] = cx->X[n] ^ cx->X[MD2_INPUT + n];
CKSUMFN(0);
CKSUMFN(1);
CKSUMFN(2);
CKSUMFN(3);
CKSUMFN(4);
CKSUMFN(5);
CKSUMFN(6);
CKSUMFN(7);
CKSUMFN(8);
CKSUMFN(9);
CKSUMFN(10);
CKSUMFN(11);
CKSUMFN(12);
CKSUMFN(13);
CKSUMFN(14);
CKSUMFN(15);
/* The compression function. */
#define COMPRESS(n) \
P = cx->X[n] ^ MD2S[P]; \
cx->X[n] = P;
P = 0x00;
for (j = 0; j < 18; j++) {
COMPRESS(0);
COMPRESS(1);
COMPRESS(2);
COMPRESS(3);
COMPRESS(4);
COMPRESS(5);
COMPRESS(6);
COMPRESS(7);
COMPRESS(8);
COMPRESS(9);
COMPRESS(10);
COMPRESS(11);
COMPRESS(12);
COMPRESS(13);
COMPRESS(14);
COMPRESS(15);
COMPRESS(16);
COMPRESS(17);
COMPRESS(18);
COMPRESS(19);
COMPRESS(20);
COMPRESS(21);
COMPRESS(22);
COMPRESS(23);
COMPRESS(24);
COMPRESS(25);
COMPRESS(26);
COMPRESS(27);
COMPRESS(28);
COMPRESS(29);
COMPRESS(30);
COMPRESS(31);
COMPRESS(32);
COMPRESS(33);
COMPRESS(34);
COMPRESS(35);
COMPRESS(36);
COMPRESS(37);
COMPRESS(38);
COMPRESS(39);
COMPRESS(40);
COMPRESS(41);
COMPRESS(42);
COMPRESS(43);
COMPRESS(44);
COMPRESS(45);
COMPRESS(46);
COMPRESS(47);
P = (P + j) % 256;
}
cx->unusedBuffer = MD2_BUFSIZE;
}
void
MD2_Update(MD2Context *cx, const unsigned char *input, unsigned int inputLen)
{
PRUint32 bytesToConsume;
/* Fill the remaining input buffer. */
if (cx->unusedBuffer != MD2_BUFSIZE) {
bytesToConsume = PR_MIN(inputLen, cx->unusedBuffer);
memcpy(&cx->X[MD2_INPUT + (MD2_BUFSIZE - cx->unusedBuffer)],
input, bytesToConsume);
if (cx->unusedBuffer + bytesToConsume >= MD2_BUFSIZE)
md2_compress(cx);
inputLen -= bytesToConsume;
input += bytesToConsume;
}
/* Iterate over 16-byte chunks of the input. */
while (inputLen >= MD2_BUFSIZE) {
memcpy(&cx->X[MD2_INPUT], input, MD2_BUFSIZE);
md2_compress(cx);
inputLen -= MD2_BUFSIZE;
input += MD2_BUFSIZE;
}
/* Copy any input that remains into the buffer. */
if (inputLen)
memcpy(&cx->X[MD2_INPUT], input, inputLen);
cx->unusedBuffer = MD2_BUFSIZE - inputLen;
}
void
MD2_End(MD2Context *cx, unsigned char *digest,
unsigned int *digestLen, unsigned int maxDigestLen)
{
PRUint8 padStart;
if (maxDigestLen < MD2_BUFSIZE) {
PORT_SetError(SEC_ERROR_INVALID_ARGS);
return;
}
padStart = MD2_BUFSIZE - cx->unusedBuffer;
memset(&cx->X[MD2_INPUT + padStart], cx->unusedBuffer,
cx->unusedBuffer);
md2_compress(cx);
memcpy(&cx->X[MD2_INPUT], cx->checksum, MD2_BUFSIZE);
md2_compress(cx);
*digestLen = MD2_DIGEST_LEN;
memcpy(digest, &cx->X[MD2_CV], MD2_DIGEST_LEN);
}
unsigned int
MD2_FlattenSize(MD2Context *cx)
{
return sizeof(*cx);
}
SECStatus
MD2_Flatten(MD2Context *cx, unsigned char *space)
{
memcpy(space, cx, sizeof(*cx));
return SECSuccess;
}
MD2Context *
MD2_Resurrect(unsigned char *space, void *arg)
{
MD2Context *cx = MD2_NewContext();
if (cx)
memcpy(cx, space, sizeof(*cx));
return cx;
}
void
MD2_Clone(MD2Context *dest, MD2Context *src)
{
memcpy(dest, src, sizeof *dest);
}
|
