1/* ---- HASH FUNCTIONS ---- */
2#ifdef SHA512
3struct sha512_state {
4    ulong64  length, state[8];
5    unsigned long curlen;
6    unsigned char buf[128];
7};
8#endif
9
10#ifdef SHA256
11struct sha256_state {
12    ulong64 length;
13    ulong32 state[8], curlen;
14    unsigned char buf[64];
15};
16#endif
17
18#ifdef SHA1
19struct sha1_state {
20    ulong64 length;
21    ulong32 state[5], curlen;
22    unsigned char buf[64];
23};
24#endif
25
26#ifdef MD5
27struct md5_state {
28    ulong64 length;
29    ulong32 state[4], curlen;
30    unsigned char buf[64];
31};
32#endif
33
34#ifdef MD4
35struct md4_state {
36    ulong64 length;
37    ulong32 state[4], curlen;
38    unsigned char buf[64];
39};
40#endif
41
42#ifdef TIGER
43struct tiger_state {
44    ulong64 state[3], length;
45    unsigned long curlen;
46    unsigned char buf[64];
47};
48#endif
49
50#ifdef MD2
51struct md2_state {
52    unsigned char chksum[16], X[48], buf[16];
53    unsigned long curlen;
54};
55#endif
56
57#ifdef RIPEMD128
58struct rmd128_state {
59    ulong64 length;
60    unsigned char buf[64];
61    ulong32 curlen, state[4];
62};
63#endif
64
65#ifdef RIPEMD160
66struct rmd160_state {
67    ulong64 length;
68    unsigned char buf[64];
69    ulong32 curlen, state[5];
70};
71#endif
72
73#ifdef RIPEMD256
74struct rmd256_state {
75    ulong64 length;
76    unsigned char buf[64];
77    ulong32 curlen, state[8];
78};
79#endif
80
81#ifdef RIPEMD320
82struct rmd320_state {
83    ulong64 length;
84    unsigned char buf[64];
85    ulong32 curlen, state[10];
86};
87#endif
88
89#ifdef WHIRLPOOL
90struct whirlpool_state {
91    ulong64 length, state[8];
92    unsigned char buf[64];
93    ulong32 curlen;
94};
95#endif
96
97#ifdef CHC_HASH
98struct chc_state {
99    ulong64 length;
100    unsigned char state[MAXBLOCKSIZE], buf[MAXBLOCKSIZE];
101    ulong32 curlen;
102};
103#endif
104
105typedef union Hash_state {
106    char dummy[1];
107#ifdef CHC_HASH
108    struct chc_state chc;
109#endif
110#ifdef WHIRLPOOL
111    struct whirlpool_state whirlpool;
112#endif
113#ifdef SHA512
114    struct sha512_state sha512;
115#endif
116#ifdef SHA256
117    struct sha256_state sha256;
118#endif
119#ifdef SHA1
120    struct sha1_state   sha1;
121#endif
122#ifdef MD5
123    struct md5_state    md5;
124#endif
125#ifdef MD4
126    struct md4_state    md4;
127#endif
128#ifdef MD2
129    struct md2_state    md2;
130#endif
131#ifdef TIGER
132    struct tiger_state  tiger;
133#endif
134#ifdef RIPEMD128
135    struct rmd128_state rmd128;
136#endif
137#ifdef RIPEMD160
138    struct rmd160_state rmd160;
139#endif
140#ifdef RIPEMD256
141    struct rmd256_state rmd256;
142#endif
143#ifdef RIPEMD320
144    struct rmd320_state rmd320;
145#endif
146    void *data;
147} hash_state;
148
149/** hash descriptor */
150extern  struct ltc_hash_descriptor {
151    /** name of hash */
152    char *name;
153    /** internal ID */
154    unsigned char ID;
155    /** Size of digest in octets */
156    unsigned long hashsize;
157    /** Input block size in octets */
158    unsigned long blocksize;
159    /** ASN.1 OID */
160    unsigned long OID[16];
161    /** Length of DER encoding */
162    unsigned long OIDlen;
163
164    /** Init a hash state
165      @param hash   The hash to initialize
166      @return CRYPT_OK if successful
167    */
168    int (*init)(hash_state *hash);
169    /** Process a block of data
170      @param hash   The hash state
171      @param in     The data to hash
172      @param inlen  The length of the data (octets)
173      @return CRYPT_OK if successful
174    */
175    int (*process)(hash_state *hash, const unsigned char *in, unsigned long inlen);
176    /** Produce the digest and store it
177      @param hash   The hash state
178      @param out    [out] The destination of the digest
179      @return CRYPT_OK if successful
180    */
181    int (*done)(hash_state *hash, unsigned char *out);
182    /** Self-test
183      @return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled
184    */
185    int (*test)(void);
186
187    /* accelerated hmac callback: if you need to-do multiple packets just use the generic hmac_memory and provide a hash callback */
188    int  (*hmac_block)(const unsigned char *key, unsigned long  keylen,
189                       const unsigned char *in,  unsigned long  inlen,
190                             unsigned char *out, unsigned long *outlen);
191
192} hash_descriptor[];
193
194#ifdef CHC_HASH
195int chc_register(int cipher);
196int chc_init(hash_state * md);
197int chc_process(hash_state * md, const unsigned char *in, unsigned long inlen);
198int chc_done(hash_state * md, unsigned char *hash);
199int chc_test(void);
200extern const struct ltc_hash_descriptor chc_desc;
201#endif
202
203#ifdef WHIRLPOOL
204int whirlpool_init(hash_state * md);
205int whirlpool_process(hash_state * md, const unsigned char *in, unsigned long inlen);
206int whirlpool_done(hash_state * md, unsigned char *hash);
207int whirlpool_test(void);
208extern const struct ltc_hash_descriptor whirlpool_desc;
209#endif
210
211#ifdef SHA512
212int sha512_init(hash_state * md);
213int sha512_process(hash_state * md, const unsigned char *in, unsigned long inlen);
214int sha512_done(hash_state * md, unsigned char *hash);
215int sha512_test(void);
216extern const struct ltc_hash_descriptor sha512_desc;
217#endif
218
219#ifdef SHA384
220#ifndef SHA512
221   #error SHA512 is required for SHA384
222#endif
223int sha384_init(hash_state * md);
224#define sha384_process sha512_process
225int sha384_done(hash_state * md, unsigned char *hash);
226int sha384_test(void);
227extern const struct ltc_hash_descriptor sha384_desc;
228#endif
229
230#ifdef SHA256
231int sha256_init(hash_state * md);
232int sha256_process(hash_state * md, const unsigned char *in, unsigned long inlen);
233int sha256_done(hash_state * md, unsigned char *hash);
234int sha256_test(void);
235extern const struct ltc_hash_descriptor sha256_desc;
236
237#ifdef SHA224
238#ifndef SHA256
239   #error SHA256 is required for SHA224
240#endif
241int sha224_init(hash_state * md);
242#define sha224_process sha256_process
243int sha224_done(hash_state * md, unsigned char *hash);
244int sha224_test(void);
245extern const struct ltc_hash_descriptor sha224_desc;
246#endif
247#endif
248
249#ifdef SHA1
250int sha1_init(hash_state * md);
251int sha1_process(hash_state * md, const unsigned char *in, unsigned long inlen);
252int sha1_done(hash_state * md, unsigned char *hash);
253int sha1_test(void);
254extern const struct ltc_hash_descriptor sha1_desc;
255#endif
256
257#ifdef MD5
258int md5_init(hash_state * md);
259int md5_process(hash_state * md, const unsigned char *in, unsigned long inlen);
260int md5_done(hash_state * md, unsigned char *hash);
261int md5_test(void);
262extern const struct ltc_hash_descriptor md5_desc;
263#endif
264
265#ifdef MD4
266int md4_init(hash_state * md);
267int md4_process(hash_state * md, const unsigned char *in, unsigned long inlen);
268int md4_done(hash_state * md, unsigned char *hash);
269int md4_test(void);
270extern const struct ltc_hash_descriptor md4_desc;
271#endif
272
273#ifdef MD2
274int md2_init(hash_state * md);
275int md2_process(hash_state * md, const unsigned char *in, unsigned long inlen);
276int md2_done(hash_state * md, unsigned char *hash);
277int md2_test(void);
278extern const struct ltc_hash_descriptor md2_desc;
279#endif
280
281#ifdef TIGER
282int tiger_init(hash_state * md);
283int tiger_process(hash_state * md, const unsigned char *in, unsigned long inlen);
284int tiger_done(hash_state * md, unsigned char *hash);
285int tiger_test(void);
286extern const struct ltc_hash_descriptor tiger_desc;
287#endif
288
289#ifdef RIPEMD128
290int rmd128_init(hash_state * md);
291int rmd128_process(hash_state * md, const unsigned char *in, unsigned long inlen);
292int rmd128_done(hash_state * md, unsigned char *hash);
293int rmd128_test(void);
294extern const struct ltc_hash_descriptor rmd128_desc;
295#endif
296
297#ifdef RIPEMD160
298int rmd160_init(hash_state * md);
299int rmd160_process(hash_state * md, const unsigned char *in, unsigned long inlen);
300int rmd160_done(hash_state * md, unsigned char *hash);
301int rmd160_test(void);
302extern const struct ltc_hash_descriptor rmd160_desc;
303#endif
304
305#ifdef RIPEMD256
306int rmd256_init(hash_state * md);
307int rmd256_process(hash_state * md, const unsigned char *in, unsigned long inlen);
308int rmd256_done(hash_state * md, unsigned char *hash);
309int rmd256_test(void);
310extern const struct ltc_hash_descriptor rmd256_desc;
311#endif
312
313#ifdef RIPEMD320
314int rmd320_init(hash_state * md);
315int rmd320_process(hash_state * md, const unsigned char *in, unsigned long inlen);
316int rmd320_done(hash_state * md, unsigned char *hash);
317int rmd320_test(void);
318extern const struct ltc_hash_descriptor rmd320_desc;
319#endif
320
321
322int find_hash(const char *name);
323int find_hash_id(unsigned char ID);
324int find_hash_oid(const unsigned long *ID, unsigned long IDlen);
325int find_hash_any(const char *name, int digestlen);
326int register_hash(const struct ltc_hash_descriptor *hash);
327int unregister_hash(const struct ltc_hash_descriptor *hash);
328int hash_is_valid(int idx);
329
330LTC_MUTEX_PROTO(ltc_hash_mutex)
331
332int hash_memory(int hash,
333                const unsigned char *in,  unsigned long inlen,
334                      unsigned char *out, unsigned long *outlen);
335int hash_memory_multi(int hash, unsigned char *out, unsigned long *outlen,
336                      const unsigned char *in, unsigned long inlen, ...);
337int hash_filehandle(int hash, FILE *in, unsigned char *out, unsigned long *outlen);
338int hash_file(int hash, const char *fname, unsigned char *out, unsigned long *outlen);
339
340/* a simple macro for making hash "process" functions */
341#define HASH_PROCESS(func_name, compress_name, state_var, block_size)                       \
342int func_name (hash_state * md, const unsigned char *in, unsigned long inlen)               \
343{                                                                                           \
344    unsigned long n;                                                                        \
345    int           err;                                                                      \
346    LTC_ARGCHK(md != NULL);                                                                 \
347    LTC_ARGCHK(in != NULL);                                                                 \
348    if (md-> state_var .curlen > sizeof(md-> state_var .buf)) {                             \
349       return CRYPT_INVALID_ARG;                                                            \
350    }                                                                                       \
351    while (inlen > 0) {                                                                     \
352        if (md-> state_var .curlen == 0 && inlen >= block_size) {                           \
353           if ((err = compress_name (md, (unsigned char *)in)) != CRYPT_OK) {               \
354              return err;                                                                   \
355           }                                                                                \
356           md-> state_var .length += block_size * 8;                                        \
357           in             += block_size;                                                    \
358           inlen          -= block_size;                                                    \
359        } else {                                                                            \
360           n = MIN(inlen, (block_size - md-> state_var .curlen));                           \
361           memcpy(md-> state_var .buf + md-> state_var.curlen, in, (size_t)n);              \
362           md-> state_var .curlen += n;                                                     \
363           in             += n;                                                             \
364           inlen          -= n;                                                             \
365           if (md-> state_var .curlen == block_size) {                                      \
366              if ((err = compress_name (md, md-> state_var .buf)) != CRYPT_OK) {            \
367                 return err;                                                                \
368              }                                                                             \
369              md-> state_var .length += 8*block_size;                                       \
370              md-> state_var .curlen = 0;                                                   \
371           }                                                                                \
372       }                                                                                    \
373    }                                                                                       \
374    return CRYPT_OK;                                                                        \
375}
376
377/* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_hash.h,v $ */
378/* $Revision: 1.19 $ */
379/* $Date: 2006/11/05 01:36:43 $ */
380