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