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 RIPEMD256 74 struct rmd256_state { 75 ulong64 length; 76 unsigned char buf[64]; 77 ulong32 curlen, state[8]; 78 }; 79 #endif 80 81 #ifdef RIPEMD320 82 struct rmd320_state { 83 ulong64 length; 84 unsigned char buf[64]; 85 ulong32 curlen, state[10]; 86 }; 87 #endif 88 89 #ifdef WHIRLPOOL 90 struct whirlpool_state { 91 ulong64 length, state[8]; 92 unsigned char buf[64]; 93 ulong32 curlen; 94 }; 95 #endif 96 97 #ifdef CHC_HASH 98 struct chc_state { 99 ulong64 length; 100 unsigned char state[MAXBLOCKSIZE], buf[MAXBLOCKSIZE]; 101 ulong32 curlen; 102 }; 103 #endif 104 105 typedef 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 */ 150 extern 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 195 int chc_register(int cipher); 196 int chc_init(hash_state * md); 197 int chc_process(hash_state * md, const unsigned char *in, unsigned long inlen); 198 int chc_done(hash_state * md, unsigned char *hash); 199 int chc_test(void); 200 extern const struct ltc_hash_descriptor chc_desc; 201 #endif 202 203 #ifdef WHIRLPOOL 204 int whirlpool_init(hash_state * md); 205 int whirlpool_process(hash_state * md, const unsigned char *in, unsigned long inlen); 206 int whirlpool_done(hash_state * md, unsigned char *hash); 207 int whirlpool_test(void); 208 extern const struct ltc_hash_descriptor whirlpool_desc; 209 #endif 210 211 #ifdef SHA512 212 int sha512_init(hash_state * md); 213 int sha512_process(hash_state * md, const unsigned char *in, unsigned long inlen); 214 int sha512_done(hash_state * md, unsigned char *hash); 215 int sha512_test(void); 216 extern 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 223 int sha384_init(hash_state * md); 224 #define sha384_process sha512_process 225 int sha384_done(hash_state * md, unsigned char *hash); 226 int sha384_test(void); 227 extern const struct ltc_hash_descriptor sha384_desc; 228 #endif 229 230 #ifdef SHA256 231 int sha256_init(hash_state * md); 232 int sha256_process(hash_state * md, const unsigned char *in, unsigned long inlen); 233 int sha256_done(hash_state * md, unsigned char *hash); 234 int sha256_test(void); 235 extern const struct ltc_hash_descriptor sha256_desc; 236 237 #ifdef SHA224 238 #ifndef SHA256 239 #error SHA256 is required for SHA224 240 #endif 241 int sha224_init(hash_state * md); 242 #define sha224_process sha256_process 243 int sha224_done(hash_state * md, unsigned char *hash); 244 int sha224_test(void); 245 extern const struct ltc_hash_descriptor sha224_desc; 246 #endif 247 #endif 248 249 #ifdef SHA1 250 int sha1_init(hash_state * md); 251 int sha1_process(hash_state * md, const unsigned char *in, unsigned long inlen); 252 int sha1_done(hash_state * md, unsigned char *hash); 253 int sha1_test(void); 254 extern const struct ltc_hash_descriptor sha1_desc; 255 #endif 256 257 #ifdef MD5 258 int md5_init(hash_state * md); 259 int md5_process(hash_state * md, const unsigned char *in, unsigned long inlen); 260 int md5_done(hash_state * md, unsigned char *hash); 261 int md5_test(void); 262 extern const struct ltc_hash_descriptor md5_desc; 263 #endif 264 265 #ifdef MD4 266 int md4_init(hash_state * md); 267 int md4_process(hash_state * md, const unsigned char *in, unsigned long inlen); 268 int md4_done(hash_state * md, unsigned char *hash); 269 int md4_test(void); 270 extern const struct ltc_hash_descriptor md4_desc; 271 #endif 272 273 #ifdef MD2 274 int md2_init(hash_state * md); 275 int md2_process(hash_state * md, const unsigned char *in, unsigned long inlen); 276 int md2_done(hash_state * md, unsigned char *hash); 277 int md2_test(void); 278 extern const struct ltc_hash_descriptor md2_desc; 279 #endif 280 281 #ifdef TIGER 282 int tiger_init(hash_state * md); 283 int tiger_process(hash_state * md, const unsigned char *in, unsigned long inlen); 284 int tiger_done(hash_state * md, unsigned char *hash); 285 int tiger_test(void); 286 extern const struct ltc_hash_descriptor tiger_desc; 287 #endif 288 289 #ifdef RIPEMD128 290 int rmd128_init(hash_state * md); 291 int rmd128_process(hash_state * md, const unsigned char *in, unsigned long inlen); 292 int rmd128_done(hash_state * md, unsigned char *hash); 293 int rmd128_test(void); 294 extern const struct ltc_hash_descriptor rmd128_desc; 295 #endif 296 297 #ifdef RIPEMD160 298 int rmd160_init(hash_state * md); 299 int rmd160_process(hash_state * md, const unsigned char *in, unsigned long inlen); 300 int rmd160_done(hash_state * md, unsigned char *hash); 301 int rmd160_test(void); 302 extern const struct ltc_hash_descriptor rmd160_desc; 303 #endif 304 305 #ifdef RIPEMD256 306 int rmd256_init(hash_state * md); 307 int rmd256_process(hash_state * md, const unsigned char *in, unsigned long inlen); 308 int rmd256_done(hash_state * md, unsigned char *hash); 309 int rmd256_test(void); 310 extern const struct ltc_hash_descriptor rmd256_desc; 311 #endif 312 313 #ifdef RIPEMD320 314 int rmd320_init(hash_state * md); 315 int rmd320_process(hash_state * md, const unsigned char *in, unsigned long inlen); 316 int rmd320_done(hash_state * md, unsigned char *hash); 317 int rmd320_test(void); 318 extern const struct ltc_hash_descriptor rmd320_desc; 319 #endif 320 321 322 int find_hash(const char *name); 323 int find_hash_id(unsigned char ID); 324 int find_hash_oid(const unsigned long *ID, unsigned long IDlen); 325 int find_hash_any(const char *name, int digestlen); 326 int register_hash(const struct ltc_hash_descriptor *hash); 327 int unregister_hash(const struct ltc_hash_descriptor *hash); 328 int hash_is_valid(int idx); 329 330 LTC_MUTEX_PROTO(ltc_hash_mutex) 331 332 int hash_memory(int hash, 333 const unsigned char *in, unsigned long inlen, 334 unsigned char *out, unsigned long *outlen); 335 int hash_memory_multi(int hash, unsigned char *out, unsigned long *outlen, 336 const unsigned char *in, unsigned long inlen, ...); 337 int hash_filehandle(int hash, FILE *in, unsigned char *out, unsigned long *outlen); 338 int 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) \ 342 int 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