Mercurial > dropbear

comparison mycrypt_hash.h @ 3:7faae8f46238 libtomcrypt-orig

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Branch renaming
author Matt Johnston <matt@ucc.asn.au>
date Mon, 31 May 2004 18:25:41 +0000
parents
children 6362d3854bb4
comparison
equal deleted inserted replaced
-1:000000000000 3:7faae8f46238
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