/* $Id: whirlpool.h,v 1.7 2007/09/23 01:54:30 jessekornblum Exp $ */ #include "main.h" /* #ifdef HASH_ALGORITHM #error Hash algorithm already defined! #else #define HASH_ALGORITHM "Whirlpool" #endif */ /* Bytes in hash */ //#define HASH_LENGTH 64 /* Characters needed to display hash. This is *usually* twice the HASH_LENGTH defined above. This number is used to find and compare hashes as part of the matching process. */ //#define HASH_STRING_LENGTH 128 /* These supply the hashing code, hash.c, with the names of the functions used in the algorithm to do the real computation. HASH_Init takes a HASH_CONTEXT only HASH_Update takes a hash context, the buffer, and its size in bytes HASH_Final takes a char to put the sum in and then a context */ //#define HASH_CONTEXT NESSIEstruct //#define HASH_Init(A) NESSIEinit(A) // We multiply by C by eight because this function needs // number of BITS as a paramter! //#define HASH_Update(A,B,C) NESSIEadd(B, C*8, A) //#define HASH_Final(A,B) NESSIEfinalize(B,A) /* Define which types of files of known hashes that support this type of hash. The values, if given, are the location of the hash value in terms of number of commas that preceed the hash. For example, if the file format is: hash,stuff,junk the define should be SUPPORT_FORMAT 0 if the file format is stuff,junk,hash the define should be SUPPORT_FORMAT 2 Remember that numbers are not necessary for all file types! */ //#define SUPPORT_PLAIN /* Although there is no whirlpool program on BSD at this time, there's no reason why these hashes can't be stored in BSD format. */ //#define SUPPORT_BSD //#define SUPPORT_MD5DEEP_SIZE //#undef SUPPORT_HASHKEEPER //#undef SUPPORT_ILOOK //#undef SUPPORT_NSRL_15 //#undef SUPPORT_NSRL_20 /* ---------------------------------------------------------------------- Original headers from Whirlpool ---------------------------------------------------------------------- */ #ifndef PORTABLE_C__ #define PORTABLE_C__ #include /* Definition of minimum-width integer types * * u8 -> unsigned integer type, at least 8 bits, equivalent to unsigned char * u16 -> unsigned integer type, at least 16 bits * u32 -> unsigned integer type, at least 32 bits * * s8, s16, s32 -> signed counterparts of u8, u16, u32 * * Always use macro's T8(), T16() or T32() to obtain exact-width results, * i.e., to specify the size of the result of each expression. */ typedef signed char s8; typedef unsigned char u8; #if UINT_MAX >= 4294967295UL typedef signed short s16; typedef signed int s32; typedef unsigned short u16; typedef unsigned int u32; #define ONE32 0xffffffffU #else typedef signed int s16; typedef signed long s32; typedef unsigned int u16; typedef unsigned long u32; #define ONE32 0xffffffffUL #endif #define ONE8 0xffU #define ONE16 0xffffU #define T8(x) ((x) & ONE8) #define T16(x) ((x) & ONE16) #define T32(x) ((x) & ONE32) #ifdef _MSC_VER typedef unsigned __int64 u64; typedef signed __int64 s64; #define LL(v) (v##i64) #define ONE64 LL(0xffffffffffffffff) #else /* !_MSC_VER */ typedef unsigned long long u64; typedef signed long long s64; #define LL(v) (v##ULL) #define ONE64 LL(0xffffffffffffffff) #endif /* ?_MSC_VER */ #define T64(x) ((x) & ONE64) #define ROTR64(v, n) (((v) >> (n)) | T64((v) << (64 - (n)))) /* * Note: the test is used to detect native 64-bit architectures; * if the unsigned long is strictly greater than 32-bit, it is * assumed to be at least 64-bit. This will not work correctly * on (old) 36-bit architectures (PDP-11 for instance). * * On non-64-bit architectures, "long long" is used. */ /* * U8TO32_BIG(c) returns the 32-bit value stored in big-endian convention * in the unsigned char array pointed to by c. */ #define U8TO32_BIG(c) (((u32)T8(*(c)) << 24) | ((u32)T8(*((c) + 1)) << 16) | ((u32)T8(*((c) + 2)) << 8) | ((u32)T8(*((c) + 3)))) /* * U8TO32_LITTLE(c) returns the 32-bit value stored in little-endian convention * in the unsigned char array pointed to by c. */ #define U8TO32_LITTLE(c) (((u32)T8(*(c))) | ((u32)T8(*((c) + 1)) << 8) | (u32)T8(*((c) + 2)) << 16) | ((u32)T8(*((c) + 3)) << 24)) /* * U8TO32_BIG(c, v) stores the 32-bit-value v in big-endian convention * into the unsigned char array pointed to by c. */ #define U32TO8_BIG(c, v) do { u32 x = (v); u8 *d = (c); d[0] = T8(x >> 24); d[1] = T8(x >> 16); d[2] = T8(x >> 8); d[3] = T8(x); } while (0) /* * U8TO32_LITTLE(c, v) stores the 32-bit-value v in little-endian convention * into the unsigned char array pointed to by c. */ #define U32TO8_LITTLE(c, v) do { u32 x = (v); u8 *d = (c); d[0] = T8(x); d[1] = T8(x >> 8); d[2] = T8(x >> 16); d[3] = T8(x >> 24); } while (0) /* * ROTL32(v, n) returns the value of the 32-bit unsigned value v after * a rotation of n bits to the left. It might be replaced by the appropriate * architecture-specific macro. * * It evaluates v and n twice. * * The compiler might emit a warning if n is the constant 0. The result * is undefined if n is greater than 31. */ #define ROTL32(v, n) (T32((v) << (n)) | ((v) >> (32 - (n)))) /* * Whirlpool-specific definitions. */ #define DIGESTBYTES 64 #define DIGESTBITS (8*DIGESTBYTES) /* 512 */ #define WBLOCKBYTES 64 #define WBLOCKBITS (8*WBLOCKBYTES) /* 512 */ #define LENGTHBYTES 32 #define LENGTHBITS (8*LENGTHBYTES) /* 256 */ typedef struct NESSIEstruct { u8 bitLength[LENGTHBYTES]; /* global number of hashed bits (256-bit counter) */ u8 buffer[WBLOCKBYTES]; /* buffer of data to hash */ int bufferBits; /* current number of bits on the buffer */ int bufferPos; /* current (possibly incomplete) byte slot on the buffer */ u64 hash[DIGESTBYTES/8]; /* the hashing state */ } NESSIEstruct; void NESSIEinit(struct NESSIEstruct * const structpointer); /* WARNING: The "len" here is the number of BITS, not the number of BYTES. You must multiply the number of bytes by eight before calling this function! */ void NESSIEadd(const unsigned char * const source, unsigned long sourceBits, struct NESSIEstruct * const structpointer); void NESSIEfinalize(struct NESSIEstruct * const structpointer, unsigned char * const result); #define context_whirlpool_t NESSIEstruct int hash_init_whirlpool(state *s); int hash_update_whirlpool(state *s, unsigned char *buf, uint64_t len); int hash_final_whirlpool(state *s, unsigned char *digest); #endif /* PORTABLE_C__ */