|
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 */ |
|
|
119 void (*init)(hash_state *); |
|
|
120 int (*process)(hash_state *, const unsigned char *, unsigned long); |
|
|
121 int (*done)(hash_state *, unsigned char *); |
|
|
122 int (*test)(void); |
|
|
123 } hash_descriptor[]; |
|
|
124 |
|
|
125 |
|
|
126 #ifdef WHIRLPOOL |
|
|
127 extern void whirlpool_init(hash_state * md); |
|
|
128 extern int whirlpool_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
129 extern int whirlpool_done(hash_state * md, unsigned char *hash); |
|
|
130 extern int whirlpool_test(void); |
|
|
131 extern const struct _hash_descriptor whirlpool_desc; |
|
|
132 #endif |
|
|
133 |
|
|
134 #ifdef SHA512 |
|
|
135 extern void sha512_init(hash_state * md); |
|
|
136 extern int sha512_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
137 extern int sha512_done(hash_state * md, unsigned char *hash); |
|
|
138 extern int sha512_test(void); |
|
|
139 extern const struct _hash_descriptor sha512_desc; |
|
|
140 #endif |
|
|
141 |
|
|
142 #ifdef SHA384 |
|
|
143 #ifndef SHA512 |
|
|
144 #error SHA512 is required for SHA384 |
|
|
145 #endif |
|
|
146 extern void sha384_init(hash_state * md); |
|
|
147 #define sha384_process sha512_process |
|
|
148 extern int sha384_done(hash_state * md, unsigned char *hash); |
|
|
149 extern int sha384_test(void); |
|
|
150 extern const struct _hash_descriptor sha384_desc; |
|
|
151 #endif |
|
|
152 |
|
|
153 #ifdef SHA256 |
|
|
154 extern void sha256_init(hash_state * md); |
|
|
155 extern int sha256_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
156 extern int sha256_done(hash_state * md, unsigned char *hash); |
|
|
157 extern int sha256_test(void); |
|
|
158 extern const struct _hash_descriptor sha256_desc; |
|
|
159 |
|
|
160 #ifdef SHA224 |
|
|
161 #ifndef SHA256 |
|
|
162 #error SHA256 is required for SHA224 |
|
|
163 #endif |
|
|
164 extern void sha224_init(hash_state * md); |
|
|
165 #define sha224_process sha256_process |
|
|
166 extern int sha224_done(hash_state * md, unsigned char *hash); |
|
|
167 extern int sha224_test(void); |
|
|
168 extern const struct _hash_descriptor sha224_desc; |
|
|
169 #endif |
|
|
170 #endif |
|
|
171 |
|
|
172 #ifdef SHA1 |
|
|
173 extern void sha1_init(hash_state * md); |
|
|
174 extern int sha1_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
175 extern int sha1_done(hash_state * md, unsigned char *hash); |
|
|
176 extern int sha1_test(void); |
|
|
177 extern const struct _hash_descriptor sha1_desc; |
|
|
178 #endif |
|
|
179 |
|
|
180 #ifdef MD5 |
|
|
181 extern void md5_init(hash_state * md); |
|
|
182 extern int md5_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
183 extern int md5_done(hash_state * md, unsigned char *hash); |
|
|
184 extern int md5_test(void); |
|
|
185 extern const struct _hash_descriptor md5_desc; |
|
|
186 #endif |
|
|
187 |
|
|
188 #ifdef MD4 |
|
|
189 extern void md4_init(hash_state * md); |
|
|
190 extern int md4_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
191 extern int md4_done(hash_state * md, unsigned char *hash); |
|
|
192 extern int md4_test(void); |
|
|
193 extern const struct _hash_descriptor md4_desc; |
|
|
194 #endif |
|
|
195 |
|
|
196 #ifdef MD2 |
|
|
197 extern void md2_init(hash_state * md); |
|
|
198 extern int md2_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
199 extern int md2_done(hash_state * md, unsigned char *hash); |
|
|
200 extern int md2_test(void); |
|
|
201 extern const struct _hash_descriptor md2_desc; |
|
|
202 #endif |
|
|
203 |
|
|
204 #ifdef TIGER |
|
|
205 extern void tiger_init(hash_state * md); |
|
|
206 extern int tiger_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
207 extern int tiger_done(hash_state * md, unsigned char *hash); |
|
|
208 extern int tiger_test(void); |
|
|
209 extern const struct _hash_descriptor tiger_desc; |
|
|
210 #endif |
|
|
211 |
|
|
212 #ifdef RIPEMD128 |
|
|
213 extern void rmd128_init(hash_state * md); |
|
|
214 extern int rmd128_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
215 extern int rmd128_done(hash_state * md, unsigned char *hash); |
|
|
216 extern int rmd128_test(void); |
|
|
217 extern const struct _hash_descriptor rmd128_desc; |
|
|
218 #endif |
|
|
219 |
|
|
220 #ifdef RIPEMD160 |
|
|
221 extern void rmd160_init(hash_state * md); |
|
|
222 extern int rmd160_process(hash_state * md, const unsigned char *buf, unsigned long len); |
|
|
223 extern int rmd160_done(hash_state * md, unsigned char *hash); |
|
|
224 extern int rmd160_test(void); |
|
|
225 extern const struct _hash_descriptor rmd160_desc; |
|
|
226 #endif |
|
|
227 |
|
|
228 |
|
|
229 extern int find_hash(const char *name); |
|
|
230 extern int find_hash_id(unsigned char ID); |
|
|
231 extern int find_hash_any(const char *name, int digestlen); |
|
|
232 extern int register_hash(const struct _hash_descriptor *hash); |
|
|
233 extern int unregister_hash(const struct _hash_descriptor *hash); |
|
|
234 extern int hash_is_valid(int idx); |
|
|
235 |
|
|
236 extern int hash_memory(int hash, const unsigned char *data, unsigned long len, unsigned char *dst, unsigned long *outlen); |
|
|
237 extern int hash_filehandle(int hash, FILE *in, unsigned char *dst, unsigned long *outlen); |
|
|
238 extern int hash_file(int hash, const char *fname, unsigned char *dst, unsigned long *outlen); |
|
|
239 |
|
|
240 /* a simple macro for making hash "process" functions */ |
|
|
241 #define HASH_PROCESS(func_name, compress_name, state_var, block_size) \ |
|
|
242 int func_name (hash_state * md, const unsigned char *buf, unsigned long len) \ |
|
|
243 { \ |
|
|
244 unsigned long n; \ |
|
|
245 _ARGCHK(md != NULL); \ |
|
|
246 _ARGCHK(buf != NULL); \ |
|
|
247 if (md-> state_var .curlen > sizeof(md-> state_var .buf)) { \ |
|
|
248 return CRYPT_INVALID_ARG; \ |
|
|
249 } \ |
|
|
250 while (len > 0) { \ |
|
|
251 if (md-> state_var .curlen == 0 && len >= block_size) { \ |
|
|
252 compress_name (md, (unsigned char *)buf); \ |
|
|
253 md-> state_var .length += block_size * 8; \ |
|
|
254 buf += block_size; \ |
|
|
255 len -= block_size; \ |
|
|
256 } else { \ |
|
|
257 n = MIN(len, (block_size - md-> state_var .curlen)); \ |
|
|
258 memcpy(md-> state_var .buf + md-> state_var.curlen, buf, (size_t)n); \ |
|
|
259 md-> state_var .curlen += n; \ |
|
|
260 buf += n; \ |
|
|
261 len -= n; \ |
|
|
262 if (md-> state_var .curlen == block_size) { \ |
|
|
263 compress_name (md, md-> state_var .buf); \ |
|
|
264 md-> state_var .length += 8*block_size; \ |
|
|
265 md-> state_var .curlen = 0; \ |
|
|
266 } \ |
|
|
267 } \ |
|
|
268 } \ |
|
|
269 return CRYPT_OK; \ |
|
|
270 } |
|
|
271 |
|
|
272 #ifdef HMAC |
|
|
273 typedef struct Hmac_state { |
|
|
274 hash_state md; |
|
|
275 int hash; |
|
|
276 hash_state hashstate; |
|
|
277 unsigned char key[MAXBLOCKSIZE]; |
|
|
278 } hmac_state; |
|
|
279 |
|
|
280 extern int hmac_init(hmac_state *hmac, int hash, const unsigned char *key, unsigned long keylen); |
|
|
281 extern int hmac_process(hmac_state *hmac, const unsigned char *buf, unsigned long len); |
|
|
282 extern int hmac_done(hmac_state *hmac, unsigned char *hashOut, unsigned long *outlen); |
|
|
283 extern int hmac_test(void); |
|
|
284 extern int hmac_memory(int hash, const unsigned char *key, unsigned long keylen, |
|
|
285 const unsigned char *data, unsigned long len, |
|
|
286 unsigned char *dst, unsigned long *dstlen); |
|
|
287 extern int hmac_file(int hash, const char *fname, const unsigned char *key, |
|
|
288 unsigned long keylen, |
|
|
289 unsigned char *dst, unsigned long *dstlen); |
|
|
290 #endif |
|
|
291 |
|
|
292 #ifdef OMAC |
|
|
293 |
|
|
294 typedef struct { |
|
|
295 int cipher_idx, |
|
|
296 buflen, |
|
|
297 blklen; |
|
|
298 unsigned char block[MAXBLOCKSIZE], |
|
|
299 prev[MAXBLOCKSIZE], |
|
|
300 Lu[2][MAXBLOCKSIZE]; |
|
|
301 symmetric_key key; |
|
|
302 } omac_state; |
|
|
303 |
|
|
304 extern int omac_init(omac_state *omac, int cipher, const unsigned char *key, unsigned long keylen); |
|
|
305 extern int omac_process(omac_state *state, const unsigned char *buf, unsigned long len); |
|
|
306 extern int omac_done(omac_state *state, unsigned char *out, unsigned long *outlen); |
|
|
307 extern int omac_memory(int cipher, const unsigned char *key, unsigned long keylen, |
|
|
308 const unsigned char *msg, unsigned long msglen, |
|
|
309 unsigned char *out, unsigned long *outlen); |
|
|
310 extern int omac_file(int cipher, const unsigned char *key, unsigned long keylen, |
|
|
311 const char *filename, unsigned char *out, unsigned long *outlen); |
|
|
312 extern int omac_test(void); |
|
|
313 #endif /* OMAC */ |
|
|
314 |
|
|
315 #ifdef PMAC |
|
|
316 |
|
|
317 typedef struct { |
|
|
318 unsigned char Ls[32][MAXBLOCKSIZE], /* L shifted by i bits to the left */ |
|
|
319 Li[MAXBLOCKSIZE], /* value of Li [current value, we calc from previous recall] */ |
|
|
320 Lr[MAXBLOCKSIZE], /* L * x^-1 */ |
|
|
321 block[MAXBLOCKSIZE], /* currently accumulated block */ |
|
|
322 checksum[MAXBLOCKSIZE]; /* current checksum */ |
|
|
323 |
|
|
324 symmetric_key key; /* scheduled key for cipher */ |
|
|
325 unsigned long block_index; /* index # for current block */ |
|
|
326 int cipher_idx, /* cipher idx */ |
|
|
327 block_len, /* length of block */ |
|
|
328 buflen; /* number of bytes in the buffer */ |
|
|
329 } pmac_state; |
|
|
330 |
|
|
331 extern int pmac_init(pmac_state *pmac, int cipher, const unsigned char *key, unsigned long keylen); |
|
|
332 extern int pmac_process(pmac_state *state, const unsigned char *buf, unsigned long len); |
|
|
333 extern int pmac_done(pmac_state *state, unsigned char *out, unsigned long *outlen); |
|
|
334 |
|
|
335 extern int pmac_memory(int cipher, const unsigned char *key, unsigned long keylen, |
|
|
336 const unsigned char *msg, unsigned long msglen, |
|
|
337 unsigned char *out, unsigned long *outlen); |
|
|
338 |
|
|
339 extern int pmac_file(int cipher, const unsigned char *key, unsigned long keylen, |
|
|
340 const char *filename, unsigned char *out, unsigned long *outlen); |
|
|
341 |
|
|
342 extern int pmac_test(void); |
|
|
343 |
|
|
344 /* internal functions */ |
|
|
345 extern int pmac_ntz(unsigned long x); |
|
|
346 extern void pmac_shift_xor(pmac_state *pmac); |
|
|
347 |
|
|
348 #endif /* PMAC */ |
|
|
349 |
|
|
350 #ifdef EAX_MODE |
|
|
351 |
|
|
352 #if !(defined(OMAC) && defined(CTR)) |
|
|
353 #error EAX_MODE requires OMAC and CTR |
|
|
354 #endif |
|
|
355 |
|
|
356 typedef struct { |
|
|
357 unsigned char N[MAXBLOCKSIZE]; |
|
|
358 symmetric_CTR ctr; |
|
|
359 omac_state headeromac, ctomac; |
|
|
360 } eax_state; |
|
|
361 |
|
|
362 extern int eax_init(eax_state *eax, int cipher, const unsigned char *key, unsigned long keylen, |
|
|
363 const unsigned char *nonce, unsigned long noncelen, |
|
|
364 const unsigned char *header, unsigned long headerlen); |
|
|
365 |
|
|
366 extern int eax_encrypt(eax_state *eax, const unsigned char *pt, unsigned char *ct, unsigned long length); |
|
|
367 extern int eax_decrypt(eax_state *eax, const unsigned char *ct, unsigned char *pt, unsigned long length); |
|
|
368 extern int eax_addheader(eax_state *eax, const unsigned char *header, unsigned long length); |
|
|
369 extern int eax_done(eax_state *eax, unsigned char *tag, unsigned long *taglen); |
|
|
370 |
|
|
371 extern int eax_encrypt_authenticate_memory(int cipher, |
|
|
372 const unsigned char *key, unsigned long keylen, |
|
|
373 const unsigned char *nonce, unsigned long noncelen, |
|
|
374 const unsigned char *header, unsigned long headerlen, |
|
|
375 const unsigned char *pt, unsigned long ptlen, |
|
|
376 unsigned char *ct, |
|
|
377 unsigned char *tag, unsigned long *taglen); |
|
|
378 |
|
|
379 extern int eax_decrypt_verify_memory(int cipher, |
|
|
380 const unsigned char *key, unsigned long keylen, |
|
|
381 const unsigned char *nonce, unsigned long noncelen, |
|
|
382 const unsigned char *header, unsigned long headerlen, |
|
|
383 const unsigned char *ct, unsigned long ctlen, |
|
|
384 unsigned char *pt, |
|
|
385 unsigned char *tag, unsigned long taglen, |
|
|
386 int *res); |
|
|
387 |
|
|
388 extern int eax_test(void); |
|
|
389 #endif /* EAX MODE */ |
|
|
390 |
|
|
391 #ifdef OCB_MODE |
|
|
392 typedef struct { |
|
|
393 unsigned char L[MAXBLOCKSIZE], /* L value */ |
|
|
394 Ls[32][MAXBLOCKSIZE], /* L shifted by i bits to the left */ |
|
|
395 Li[MAXBLOCKSIZE], /* value of Li [current value, we calc from previous recall] */ |
|
|
396 Lr[MAXBLOCKSIZE], /* L * x^-1 */ |
|
|
397 R[MAXBLOCKSIZE], /* R value */ |
|
|
398 checksum[MAXBLOCKSIZE]; /* current checksum */ |
|
|
399 |
|
|
400 symmetric_key key; /* scheduled key for cipher */ |
|
|
401 unsigned long block_index; /* index # for current block */ |
|
|
402 int cipher, /* cipher idx */ |
|
|
403 block_len; /* length of block */ |
|
|
404 } ocb_state; |
|
|
405 |
|
|
406 extern int ocb_init(ocb_state *ocb, int cipher, |
|
|
407 const unsigned char *key, unsigned long keylen, const unsigned char *nonce); |
|
|
408 |
|
|
409 extern int ocb_encrypt(ocb_state *ocb, const unsigned char *pt, unsigned char *ct); |
|
|
410 extern int ocb_decrypt(ocb_state *ocb, const unsigned char *ct, unsigned char *pt); |
|
|
411 |
|
|
412 extern int ocb_done_encrypt(ocb_state *ocb, |
|
|
413 const unsigned char *pt, unsigned long ptlen, |
|
|
414 unsigned char *ct, |
|
|
415 unsigned char *tag, unsigned long *taglen); |
|
|
416 |
|
|
417 extern int ocb_done_decrypt(ocb_state *ocb, |
|
|
418 const unsigned char *ct, unsigned long ctlen, |
|
|
419 unsigned char *pt, |
|
|
420 const unsigned char *tag, unsigned long taglen, int *res); |
|
|
421 |
|
|
422 extern int ocb_encrypt_authenticate_memory(int cipher, |
|
|
423 const unsigned char *key, unsigned long keylen, |
|
|
424 const unsigned char *nonce, |
|
|
425 const unsigned char *pt, unsigned long ptlen, |
|
|
426 unsigned char *ct, |
|
|
427 unsigned char *tag, unsigned long *taglen); |
|
|
428 |
|
|
429 extern int ocb_decrypt_verify_memory(int cipher, |
|
|
430 const unsigned char *key, unsigned long keylen, |
|
|
431 const unsigned char *nonce, |
|
|
432 const unsigned char *ct, unsigned long ctlen, |
|
|
433 unsigned char *pt, |
|
|
434 const unsigned char *tag, unsigned long taglen, |
|
|
435 int *res); |
|
|
436 |
|
|
437 extern int ocb_test(void); |
|
|
438 |
|
|
439 /* internal functions */ |
|
|
440 extern void ocb_shift_xor(ocb_state *ocb, unsigned char *Z); |
|
|
441 extern int ocb_ntz(unsigned long x); |
|
|
442 extern int __ocb_done(ocb_state *ocb, const unsigned char *pt, unsigned long ptlen, |
|
|
443 unsigned char *ct, unsigned char *tag, unsigned long *taglen, int mode); |
|
|
444 |
|
|
445 #endif /* OCB_MODE */ |
|
|
446 |
|
|
447 |
