|
3
|
1 /* ---- HASH FUNCTIONS ---- */ |
|
|
2 #ifdef SHA512 |
|
|
3 struct sha512_state { |
|
|
4 ulong64 length, state[8]; |
|
|
5 unsigned long curlen; |
|
|
6 unsigned char buf[128]; |
|
|
7 }; |
|
|
8 #endif |
|
|
9 |
|
|
10 #ifdef SHA256 |
|
|
11 struct sha256_state { |
|
|
12 ulong64 length; |
|
|
13 ulong32 state[8], curlen; |
|
|
14 unsigned char buf[64]; |
|
|
15 }; |
|
|
16 #endif |
|
|
17 |
|
|
18 #ifdef SHA1 |
|
|
19 struct sha1_state { |
|
|
20 ulong64 length; |
|
|
21 ulong32 state[5], curlen; |
|
|
22 unsigned char buf[64]; |
|
|
23 }; |
|
|
24 #endif |
|
|
25 |
|
|
26 #ifdef MD5 |
|
|
27 struct md5_state { |
|
|
28 ulong64 length; |
|
|
29 ulong32 state[4], curlen; |
|
|
30 unsigned char buf[64]; |
|
|
31 }; |
|
|
32 #endif |
|
|
33 |
|
|
34 #ifdef MD4 |
|
|
35 struct md4_state { |
|
|
36 ulong64 length; |
|
|
37 ulong32 state[4], curlen; |
|
|
38 unsigned char buf[64]; |
|
|
39 }; |
|
|
40 #endif |
|
|
41 |
|
|
42 #ifdef TIGER |
|
|
43 struct tiger_state { |
|
|
44 ulong64 state[3], length; |
|
|
45 unsigned long curlen; |
|
|
46 unsigned char buf[64]; |
|
|
47 }; |
|
|
48 #endif |
|
|
49 |
|
|
50 #ifdef MD2 |
|
|
51 struct md2_state { |
|
|
52 unsigned char chksum[16], X[48], buf[16]; |
|
|
53 unsigned long curlen; |
|
|
54 }; |
|
|
55 #endif |
|
|
56 |
|
|
57 #ifdef RIPEMD128 |
|
|
58 struct rmd128_state { |
|
|
59 ulong64 length; |
|
|
60 unsigned char buf[64]; |
|
|
61 ulong32 curlen, state[4]; |
|
|
62 }; |
|
|
63 #endif |
|
|
64 |
|
|
65 #ifdef RIPEMD160 |
|
|
66 struct rmd160_state { |
|
|
67 ulong64 length; |
|
|
68 unsigned char buf[64]; |
|
|
69 ulong32 curlen, state[5]; |
|
|
70 }; |
|
|
71 #endif |
|
|
72 |
|
|
73 #ifdef WHIRLPOOL |
|
|
74 struct whirlpool_state { |
|
|
75 ulong64 length, state[8]; |
|
|
76 unsigned char buf[64]; |
|
|
77 ulong32 curlen; |
|
|
78 }; |
|
|
79 #endif |
|
|
80 |
|
|
81 typedef union Hash_state { |
|
|
82 #ifdef WHIRLPOOL |
|
|
83 struct whirlpool_state whirlpool; |
|
|
84 #endif |
|
|
85 #ifdef SHA512 |
|
|
86 struct sha512_state sha512; |
|
|
87 #endif |
|
|
88 #ifdef SHA256 |
|
|
89 struct sha256_state sha256; |
|
|
90 #endif |
|
|
91 #ifdef SHA1 |
|
|
92 struct sha1_state sha1; |
|
|
93 #endif |
|
|
94 #ifdef MD5 |
|
|
95 struct md5_state md5; |
|
|
96 #endif |
|
|
97 #ifdef MD4 |
|
|
98 struct md4_state md4; |
|
|
99 #endif |
|
|
100 #ifdef MD2 |
|
|
101 struct md2_state md2; |
|
|
102 #endif |
|
|
103 #ifdef TIGER |
|
|
104 struct tiger_state tiger; |
|
|
105 #endif |
|
|
106 #ifdef RIPEMD128 |
|
|
107 struct rmd128_state rmd128; |
|
|
108 #endif |
|
|
109 #ifdef RIPEMD160 |
|
|
110 struct rmd160_state rmd160; |
|
|
111 #endif |
|
|
112 } hash_state; |
|
|
113 |
|
|
114 extern struct _hash_descriptor { |
|
|
115 char *name; |
|
|
116 unsigned char ID; |
|
|
117 unsigned long hashsize; /* digest output size in bytes */ |
|
|
118 unsigned long blocksize; /* the block size the hash uses */ |
|
15
|
119 unsigned char DER[64]; /* DER encoded identifier */ |
|
|
120 unsigned long DERlen; /* length of DER encoding */ |
|
3
|
121 void (*init)(hash_state *); |
|
|
122 int (*process)(hash_state *, const unsigned char *, unsigned long); |
|
|
123 int (*done)(hash_state *, unsigned char *); |
|
|
124 int (*test)(void); |
|
|
125 } hash_descriptor[]; |
|
|
126 |
|
|
127 |
|
|
128 #ifdef WHIRLPOOL |
|
|
129 extern void whirlpool_init(hash_state * md); |
|
|
130 extern int whirlpool_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
131 extern int whirlpool_done(hash_state * md, unsigned char *hash); |
|
|
132 extern int whirlpool_test(void); |
|
|
133 extern const struct _hash_descriptor whirlpool_desc; |
|
|
134 #endif |
|
|
135 |
|
|
136 #ifdef SHA512 |
|
|
137 extern void sha512_init(hash_state * md); |
|
|
138 extern int sha512_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
139 extern int sha512_done(hash_state * md, unsigned char *hash); |
|
|
140 extern int sha512_test(void); |
|
|
141 extern const struct _hash_descriptor sha512_desc; |
|
|
142 #endif |
|
|
143 |
|
|
144 #ifdef SHA384 |
|
|
145 #ifndef SHA512 |
|
|
146 #error SHA512 is required for SHA384 |
|
|
147 #endif |
|
|
148 extern void sha384_init(hash_state * md); |
|
|
149 #define sha384_process sha512_process |
|
|
150 extern int sha384_done(hash_state * md, unsigned char *hash); |
|
|
151 extern int sha384_test(void); |
|
|
152 extern const struct _hash_descriptor sha384_desc; |
|
|
153 #endif |
|
|
154 |
|
|
155 #ifdef SHA256 |
|
|
156 extern void sha256_init(hash_state * md); |
|
|
157 extern int sha256_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
158 extern int sha256_done(hash_state * md, unsigned char *hash); |
|
|
159 extern int sha256_test(void); |
|
|
160 extern const struct _hash_descriptor sha256_desc; |
|
|
161 |
|
|
162 #ifdef SHA224 |
|
|
163 #ifndef SHA256 |
|
|
164 #error SHA256 is required for SHA224 |
|
|
165 #endif |
|
|
166 extern void sha224_init(hash_state * md); |
|
|
167 #define sha224_process sha256_process |
|
|
168 extern int sha224_done(hash_state * md, unsigned char *hash); |
|
|
169 extern int sha224_test(void); |
|
|
170 extern const struct _hash_descriptor sha224_desc; |
|
|
171 #endif |
|
|
172 #endif |
|
|
173 |
|
|
174 #ifdef SHA1 |
|
|
175 extern void sha1_init(hash_state * md); |
|
|
176 extern int sha1_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
177 extern int sha1_done(hash_state * md, unsigned char *hash); |
|
|
178 extern int sha1_test(void); |
|
|
179 extern const struct _hash_descriptor sha1_desc; |
|
|
180 #endif |
|
|
181 |
|
|
182 #ifdef MD5 |
|
|
183 extern void md5_init(hash_state * md); |
|
|
184 extern int md5_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
185 extern int md5_done(hash_state * md, unsigned char *hash); |
|
|
186 extern int md5_test(void); |
|
|
187 extern const struct _hash_descriptor md5_desc; |
|
|
188 #endif |
|
|
189 |
|
|
190 #ifdef MD4 |
|
|
191 extern void md4_init(hash_state * md); |
|
|
192 extern int md4_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
193 extern int md4_done(hash_state * md, unsigned char *hash); |
|
|
194 extern int md4_test(void); |
|
|
195 extern const struct _hash_descriptor md4_desc; |
|
|
196 #endif |
|
|
197 |
|
|
198 #ifdef MD2 |
|
|
199 extern void md2_init(hash_state * md); |
|
|
200 extern int md2_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
201 extern int md2_done(hash_state * md, unsigned char *hash); |
|
|
202 extern int md2_test(void); |
|
|
203 extern const struct _hash_descriptor md2_desc; |
|
|
204 #endif |
|
|
205 |
|
|
206 #ifdef TIGER |
|
|
207 extern void tiger_init(hash_state * md); |
|
|
208 extern int tiger_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
209 extern int tiger_done(hash_state * md, unsigned char *hash); |
|
|
210 extern int tiger_test(void); |
|
|
211 extern const struct _hash_descriptor tiger_desc; |
|
|
212 #endif |
|
|
213 |
|
|
214 #ifdef RIPEMD128 |
|
|
215 extern void rmd128_init(hash_state * md); |
|
|
216 extern int rmd128_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
217 extern int rmd128_done(hash_state * md, unsigned char *hash); |
|
|
218 extern int rmd128_test(void); |
|
|
219 extern const struct _hash_descriptor rmd128_desc; |
|
|
220 #endif |
|
|
221 |
|
|
222 #ifdef RIPEMD160 |
|
|
223 extern void rmd160_init(hash_state * md); |
|
|
224 extern int rmd160_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
225 extern int rmd160_done(hash_state * md, unsigned char *hash); |
|
|
226 extern int rmd160_test(void); |
|
|
227 extern const struct _hash_descriptor rmd160_desc; |
|
|
228 #endif |
|
|
229 |
|
|
230 |
|
|
231 extern int find_hash(const char *name); |
|
|
232 extern int find_hash_id(unsigned char ID); |
|
|
233 extern int find_hash_any(const char *name, int digestlen); |
|
|
234 extern int register_hash(const struct _hash_descriptor *hash); |
|
|
235 extern int unregister_hash(const struct _hash_descriptor *hash); |
|
|
236 extern int hash_is_valid(int idx); |
|
|
237 |
|
|
238 extern int hash_memory(int hash, const unsigned char *data, unsigned long len, unsigned char *dst, unsigned long *outlen); |
|
|
239 extern int hash_filehandle(int hash, FILE *in, unsigned char *dst, unsigned long *outlen); |
|
|
240 extern int hash_file(int hash, const char *fname, unsigned char *dst, unsigned long *outlen); |
|
|
241 |
|
|
242 /* a simple macro for making hash "process" functions */ |
|
|
243 #define HASH_PROCESS(func_name, compress_name, state_var, block_size) \ |
|
|
244 int func_name (hash_state * md, const unsigned char *buf, unsigned long len) \ |
|
|
245 { \ |
|
|
246 unsigned long n; \ |
|
|
247 _ARGCHK(md != NULL); \ |
|
|
248 _ARGCHK(buf != NULL); \ |
|
|
249 if (md-> state_var .curlen > sizeof(md-> state_var .buf)) { \ |
|
|
250 return CRYPT_INVALID_ARG; \ |
|
|
251 } \ |
|
|
252 while (len > 0) { \ |
|
|
253 if (md-> state_var .curlen == 0 && len >= block_size) { \ |
|
|
254 compress_name (md, (unsigned char *)buf); \ |
|
|
255 md-> state_var .length += block_size * 8; \ |
|
|
256 buf += block_size; \ |
|
|
257 len -= block_size; \ |
|
|
258 } else { \ |
|
|
259 n = MIN(len, (block_size - md-> state_var .curlen)); \ |
|
|
260 memcpy(md-> state_var .buf + md-> state_var.curlen, buf, (size_t)n); \ |
|
|
261 md-> state_var .curlen += n; \ |
|
|
262 buf += n; \ |
|
|
263 len -= n; \ |
|
|
264 if (md-> state_var .curlen == block_size) { \ |
|
|
265 compress_name (md, md-> state_var .buf); \ |
|
|
266 md-> state_var .length += 8*block_size; \ |
|
|
267 md-> state_var .curlen = 0; \ |
|
|
268 } \ |
|
|
269 } \ |
|
|
270 } \ |
|
|
271 return CRYPT_OK; \ |
|
|
272 } |
|
|
273 |
|
|
274 #ifdef HMAC |
|
|
275 typedef struct Hmac_state { |
|
|
276 hash_state md; |
|
|
277 int hash; |
|
|
278 hash_state hashstate; |
|
|
279 unsigned char key[MAXBLOCKSIZE]; |
|
|
280 } hmac_state; |
|
|
281 |
|
|
282 extern int hmac_init(hmac_state *hmac, int hash, const unsigned char *key, unsigned long keylen); |
|
|
283 extern int hmac_process(hmac_state *hmac, const unsigned char *buf, unsigned long len); |
|
|
284 extern int hmac_done(hmac_state *hmac, unsigned char *hashOut, unsigned long *outlen); |
|
|
285 extern int hmac_test(void); |
|
|
286 extern int hmac_memory(int hash, const unsigned char *key, unsigned long keylen, |
|
|
287 const unsigned char *data, unsigned long len, |
|
|
288 unsigned char *dst, unsigned long *dstlen); |
|
|
289 extern int hmac_file(int hash, const char *fname, const unsigned char *key, |
|
|
290 unsigned long keylen, |
|
|
291 unsigned char *dst, unsigned long *dstlen); |
|
|
292 #endif |
|
|
293 |
|
|
294 #ifdef OMAC |
|
|
295 |
|
|
296 typedef struct { |
|
|
297 int cipher_idx, |
|
|
298 buflen, |
|
|
299 blklen; |
|
|
300 unsigned char block[MAXBLOCKSIZE], |
|
|
301 prev[MAXBLOCKSIZE], |
|
|
302 Lu[2][MAXBLOCKSIZE]; |
|
|
303 symmetric_key key; |
|
|
304 } omac_state; |
|
|
305 |
|
|
306 extern int omac_init(omac_state *omac, int cipher, const unsigned char *key, unsigned long keylen); |
|
|
307 extern int omac_process(omac_state *state, const unsigned char *buf, unsigned long len); |
|
|
308 extern int omac_done(omac_state *state, unsigned char *out, unsigned long *outlen); |
|
|
309 extern int omac_memory(int cipher, const unsigned char *key, unsigned long keylen, |
|
|
310 const unsigned char *msg, unsigned long msglen, |
|
|
311 unsigned char *out, unsigned long *outlen); |
|
|
312 extern int omac_file(int cipher, const unsigned char *key, unsigned long keylen, |
|
|
313 const char *filename, unsigned char *out, unsigned long *outlen); |
|
|
314 extern int omac_test(void); |
|
|
315 #endif /* OMAC */ |
|
|
316 |
|
|
317 #ifdef PMAC |
|
|
318 |
|
|
319 typedef struct { |
|
|
320 unsigned char Ls[32][MAXBLOCKSIZE], /* L shifted by i bits to the left */ |
|
|
321 Li[MAXBLOCKSIZE], /* value of Li [current value, we calc from previous recall] */ |
|
|
322 Lr[MAXBLOCKSIZE], /* L * x^-1 */ |
|
|
323 block[MAXBLOCKSIZE], /* currently accumulated block */ |
|
|
324 checksum[MAXBLOCKSIZE]; /* current checksum */ |
|
|
325 |
|
|
326 symmetric_key key; /* scheduled key for cipher */ |
|
|
327 unsigned long block_index; /* index # for current block */ |
|
|
328 int cipher_idx, /* cipher idx */ |
|
|
329 block_len, /* length of block */ |
|
|
330 buflen; /* number of bytes in the buffer */ |
|
|
331 } pmac_state; |
|
|
332 |
|
|
333 extern int pmac_init(pmac_state *pmac, int cipher, const unsigned char *key, unsigned long keylen); |
|
|
334 extern int pmac_process(pmac_state *state, const unsigned char *buf, unsigned long len); |
|
|
335 extern int pmac_done(pmac_state *state, unsigned char *out, unsigned long *outlen); |
|
|
336 |
|
|
337 extern int pmac_memory(int cipher, const unsigned char *key, unsigned long keylen, |
|
|
338 const unsigned char *msg, unsigned long msglen, |
|
|
339 unsigned char *out, unsigned long *outlen); |
|
|
340 |
|
|
341 extern int pmac_file(int cipher, const unsigned char *key, unsigned long keylen, |
|
|
342 const char *filename, unsigned char *out, unsigned long *outlen); |
|
|
343 |
|
|
344 extern int pmac_test(void); |
|
|
345 |
|
|
346 /* internal functions */ |
|
|
347 extern int pmac_ntz(unsigned long x); |
|
|
348 extern void pmac_shift_xor(pmac_state *pmac); |
|
|
349 |
|
|
350 #endif /* PMAC */ |
|
|
351 |
|
|
352 #ifdef EAX_MODE |
|
|
353 |
|
|
354 #if !(defined(OMAC) && defined(CTR)) |
|
|
355 #error EAX_MODE requires OMAC and CTR |
|
|
356 #endif |
|
|
357 |
|
|
358 typedef struct { |
|
|
359 unsigned char N[MAXBLOCKSIZE]; |
|
|
360 symmetric_CTR ctr; |
|
|
361 omac_state headeromac, ctomac; |
|
|
362 } eax_state; |
|
|
363 |
|
|
364 extern int eax_init(eax_state *eax, int cipher, const unsigned char *key, unsigned long keylen, |
|
|
365 const unsigned char *nonce, unsigned long noncelen, |
|
|
366 const unsigned char *header, unsigned long headerlen); |
|
|
367 |
|
|
368 extern int eax_encrypt(eax_state *eax, const unsigned char *pt, unsigned char *ct, unsigned long length); |
|
|
369 extern int eax_decrypt(eax_state *eax, const unsigned char *ct, unsigned char *pt, unsigned long length); |
|
|
370 extern int eax_addheader(eax_state *eax, const unsigned char *header, unsigned long length); |
|
|
371 extern int eax_done(eax_state *eax, unsigned char *tag, unsigned long *taglen); |
|
|
372 |
|
|
373 extern int eax_encrypt_authenticate_memory(int cipher, |
|
|
374 const unsigned char *key, unsigned long keylen, |
|
|
375 const unsigned char *nonce, unsigned long noncelen, |
|
|
376 const unsigned char *header, unsigned long headerlen, |
|
|
377 const unsigned char *pt, unsigned long ptlen, |
|
|
378 unsigned char *ct, |
|
|
379 unsigned char *tag, unsigned long *taglen); |
|
|
380 |
|
|
381 extern int eax_decrypt_verify_memory(int cipher, |
|
|
382 const unsigned char *key, unsigned long keylen, |
|
|
383 const unsigned char *nonce, unsigned long noncelen, |
|
|
384 const unsigned char *header, unsigned long headerlen, |
|
|
385 const unsigned char *ct, unsigned long ctlen, |
|
|
386 unsigned char *pt, |
|
|
387 unsigned char *tag, unsigned long taglen, |
|
|
388 int *res); |
|
|
389 |
|
|
390 extern int eax_test(void); |
|
|
391 #endif /* EAX MODE */ |
|
|
392 |
|
|
393 #ifdef OCB_MODE |
|
|
394 typedef struct { |
|
|
395 unsigned char L[MAXBLOCKSIZE], /* L value */ |
|
|
396 Ls[32][MAXBLOCKSIZE], /* L shifted by i bits to the left */ |
|
|
397 Li[MAXBLOCKSIZE], /* value of Li [current value, we calc from previous recall] */ |
|
|
398 Lr[MAXBLOCKSIZE], /* L * x^-1 */ |
|
|
399 R[MAXBLOCKSIZE], /* R value */ |
|
|
400 checksum[MAXBLOCKSIZE]; /* current checksum */ |
|
|
401 |
|
|
402 symmetric_key key; /* scheduled key for cipher */ |
|
|
403 unsigned long block_index; /* index # for current block */ |
|
|
404 int cipher, /* cipher idx */ |
|
|
405 block_len; /* length of block */ |
|
|
406 } ocb_state; |
|
|
407 |
|
|
408 extern int ocb_init(ocb_state *ocb, int cipher, |
|
|
409 const unsigned char *key, unsigned long keylen, const unsigned char *nonce); |
|
|
410 |
|
|
411 extern int ocb_encrypt(ocb_state *ocb, const unsigned char *pt, unsigned char *ct); |
|
|
412 extern int ocb_decrypt(ocb_state *ocb, const unsigned char *ct, unsigned char *pt); |
|
|
413 |
|
|
414 extern int ocb_done_encrypt(ocb_state *ocb, |
|
|
415 const unsigned char *pt, unsigned long ptlen, |
|
|
416 unsigned char *ct, |
|
|
417 unsigned char *tag, unsigned long *taglen); |
|
|
418 |
|
|
419 extern int ocb_done_decrypt(ocb_state *ocb, |
|
|
420 const unsigned char *ct, unsigned long ctlen, |
|
|
421 unsigned char *pt, |
|
|
422 const unsigned char *tag, unsigned long taglen, int *res); |
|
|
423 |
|
|
424 extern int ocb_encrypt_authenticate_memory(int cipher, |
|
|
425 const unsigned char *key, unsigned long keylen, |
|
|
426 const unsigned char *nonce, |
|
|
427 const unsigned char *pt, unsigned long ptlen, |
|
|
428 unsigned char *ct, |
|
|
429 unsigned char *tag, unsigned long *taglen); |
|
|
430 |
|
|
431 extern int ocb_decrypt_verify_memory(int cipher, |
|
|
432 const unsigned char *key, unsigned long keylen, |
|
|
433 const unsigned char *nonce, |
|
|
434 const unsigned char *ct, unsigned long ctlen, |
|
|
435 unsigned char *pt, |
|
|
436 const unsigned char *tag, unsigned long taglen, |
|
|
437 int *res); |
|
|
438 |
|
|
439 extern int ocb_test(void); |
|
|
440 |
|
|
441 /* internal functions */ |
|
|
442 extern void ocb_shift_xor(ocb_state *ocb, unsigned char *Z); |
|
|
443 extern int ocb_ntz(unsigned long x); |
|
|
444 extern int __ocb_done(ocb_state *ocb, const unsigned char *pt, unsigned long ptlen, |
|
|
445 unsigned char *ct, unsigned char *tag, unsigned long *taglen, int mode); |
|
|
446 |
|
|
447 #endif /* OCB_MODE */ |
|
|
448 |
|
|
449 |
