whirlpool-portability.h
上传用户:market2
上传日期:2018-11-18
资源大小:18786k
文件大小:4k
源码类别:

外挂编程

开发平台:

Windows_Unix

  1. /**
  2.  * The Whirlpool hashing function.
  3.  *
  4.  * Do not #include this header in your application, this is an internal header.
  5.  * You're probably looking for whirlpool-algorithm.h
  6.  *
  7.  * The Whirlpool algorithm was developed by
  8.  * Paulo S. L. M. Barreto and Vincent Rijmen.
  9.  *
  10.  * See
  11.  *      P.S.L.M. Barreto, V. Rijmen,
  12.  *      ``The Whirlpool hashing function,''
  13.  *      NESSIE submission, 2000 (tweaked version, 2001),
  14.  *      <https://www.cosic.esat.kuleuven.ac.be/nessie/workshop/submissions/whirlpool.zip>
  15.  *
  16.  * @version 3.0 (2003.03.12)
  17.  *
  18.  * Modified for use in this software package.
  19.  */
  20. #ifndef _WHIRLPOOL_PORTABILITY_H_
  21. #define _WHIRLPOOL_PORTABILITY_H_
  22. /* Definition of minimum-width integer types
  23.  * 
  24.  * u8   -> unsigned integer type, at least 8 bits, equivalent to unsigned char
  25.  * u16  -> unsigned integer type, at least 16 bits
  26.  * u32  -> unsigned integer type, at least 32 bits
  27.  *
  28.  * s8, s16, s32  -> signed counterparts of u8, u16, u32
  29.  *
  30.  * Always use macro's T8(), T16() or T32() to obtain exact-width results,
  31.  * i.e., to specify the size of the result of each expression.
  32.  */
  33. typedef signed char s8;
  34. typedef unsigned char u8;
  35. #if UINT_MAX >= 4294967295UL
  36. typedef signed short s16;
  37. typedef signed int s32;
  38. typedef unsigned short u16;
  39. typedef unsigned int u32;
  40. #define ONE32   0xffffffffU
  41. #else
  42. typedef signed int s16;
  43. typedef signed long s32;
  44. typedef unsigned int u16;
  45. typedef unsigned long u32;
  46. #define ONE32   0xffffffffUL
  47. #endif
  48. #define ONE8    0xffU
  49. #define ONE16   0xffffU
  50. #define T8(x)   ((x) & ONE8)
  51. #define T16(x)  ((x) & ONE16)
  52. #define T32(x)  ((x) & ONE32)
  53. #ifdef _MSC_VER
  54. typedef unsigned __int64 u64;
  55. typedef signed __int64 s64;
  56. #define LL(v)   (v##i64)
  57. #define ONE64   LL(0xffffffffffffffff)
  58. #else  /* !_MSC_VER */
  59. typedef unsigned long long u64;
  60. typedef signed long long s64;
  61. #define LL(v)   (v##ULL)
  62. #define ONE64   LL(0xffffffffffffffff)
  63. #endif /* ?_MSC_VER */
  64. #define T64(x)  ((x) & ONE64)
  65. #define ROTR64(v, n)   (((v) >> (n)) | T64((v) << (64 - (n))))
  66. /*
  67.  * Note: the test is used to detect native 64-bit architectures;
  68.  * if the unsigned long is strictly greater than 32-bit, it is
  69.  * assumed to be at least 64-bit. This will not work correctly
  70.  * on (old) 36-bit architectures (PDP-11 for instance).
  71.  *
  72.  * On non-64-bit architectures, "long long" is used.
  73.  */
  74. /*
  75.  * U8TO32_BIG(c) returns the 32-bit value stored in big-endian convention
  76.  * in the unsigned char array pointed to by c.
  77.  */
  78. #define U8TO32_BIG(c)  (((u32)T8(*(c)) << 24) | ((u32)T8(*((c) + 1)) << 16) | ((u32)T8(*((c) + 2)) << 8) | ((u32)T8(*((c) + 3))))
  79. /*
  80.  * U8TO32_LITTLE(c) returns the 32-bit value stored in little-endian convention
  81.  * in the unsigned char array pointed to by c.
  82.  */
  83. #define U8TO32_LITTLE(c)  (((u32)T8(*(c))) | ((u32)T8(*((c) + 1)) << 8) | (u32)T8(*((c) + 2)) << 16) | ((u32)T8(*((c) + 3)) << 24))
  84. /*
  85.  * U8TO32_BIG(c, v) stores the 32-bit-value v in big-endian convention
  86.  * into the unsigned char array pointed to by c.
  87.  */
  88. #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)
  89. /*
  90.  * U8TO32_LITTLE(c, v) stores the 32-bit-value v in little-endian convention
  91.  * into the unsigned char array pointed to by c.
  92.  */
  93. #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)
  94. /*
  95.  * ROTL32(v, n) returns the value of the 32-bit unsigned value v after
  96.  * a rotation of n bits to the left. It might be replaced by the appropriate
  97.  * architecture-specific macro.
  98.  *
  99.  * It evaluates v and n twice.
  100.  *
  101.  * The compiler might emit a warning if n is the constant 0. The result
  102.  * is undefined if n is greater than 31.
  103.  */
  104. #define ROTL32(v, n)   (T32((v) << (n)) | ((v) >> (32 - (n))))
  105. /*
  106.  * Whirlpool-specific definitions.
  107.  */
  108. #define DIGESTBYTES WP_DIGEST_SIZE
  109. #define DIGESTBITS  (8*DIGESTBYTES) /* 512 */
  110. #define WBLOCKBYTES 64
  111. #define WBLOCKBITS  (8*WBLOCKBYTES) /* 512 */
  112. #define LENGTHBYTES 32
  113. #define LENGTHBITS  (8*LENGTHBYTES) /* 256 */
  114. struct WP_Struct {
  115. u8  bitLength[LENGTHBYTES]; /* global number of hashed bits (256-bit counter) */
  116. u8  buffer[WBLOCKBYTES]; /* buffer of data to hash */
  117. int bufferBits;         /* current number of bits on the buffer */
  118. int bufferPos;         /* current (possibly incomplete) byte slot on the buffer */
  119. u64 hash[DIGESTBYTES/8];    /* the hashing state */
  120. };
  121. #endif