diff options
| author | Mounir IDRASSI <mounir.idrassi@idrix.fr> | 2013-06-22 16:16:13 +0200 |
|---|---|---|
| committer | Mounir IDRASSI <mounir.idrassi@idrix.fr> | 2014-11-08 23:18:07 +0100 |
| commit | c606f0866c3a2a5db3ef9bc41738ef33eb9612a9 (patch) | |
| tree | 5847c644cdfff3c1dd55b88b565448087ae89f11 /src/Crypto/Whirlpool.h | |
| download | VeraCrypt-c606f0866c3a2a5db3ef9bc41738ef33eb9612a9.tar.gz VeraCrypt-c606f0866c3a2a5db3ef9bc41738ef33eb9612a9.zip | |
Add original TrueCrypt 7.1a sources
Diffstat (limited to 'src/Crypto/Whirlpool.h')
| -rw-r--r-- | src/Crypto/Whirlpool.h | 151 |
1 files changed, 151 insertions, 0 deletions
diff --git a/src/Crypto/Whirlpool.h b/src/Crypto/Whirlpool.h new file mode 100644 index 00000000..be04c055 --- /dev/null +++ b/src/Crypto/Whirlpool.h @@ -0,0 +1,151 @@ +#ifndef WHIRLPOOL_H
+#define WHIRLPOOL_H 1
+
+#include "Common/Tcdefs.h"
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif
+
+#ifndef PORTABLE_C__
+#define PORTABLE_C__
+
+#include <limits.h>
+
+/* 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 __int32 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##ui64)
+#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;
+
+#endif /* PORTABLE_C__ */
+
+// -------------
+
+typedef NESSIEstruct WHIRLPOOL_CTX;
+
+void WHIRLPOOL_add(const unsigned char * const source, unsigned __int32 sourceBits, struct NESSIEstruct * const structpointer);
+void WHIRLPOOL_finalize(struct NESSIEstruct * const structpointer, unsigned char * const result);
+void WHIRLPOOL_init(struct NESSIEstruct * const structpointer);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* WHIRLPOOL_H */
|