/src/runtime/ext/hash/hash_whirlpool.cpp
C++ | 450 lines | 325 code | 18 blank | 107 comment | 20 complexity | 30724b8f754526590a0b056f98ba06d1 MD5 | raw file
- /*
- +----------------------------------------------------------------------+
- | HipHop for PHP |
- +----------------------------------------------------------------------+
- | Copyright (c) 2010 Facebook, Inc. (http://www.facebook.com) |
- | Copyright (c) 1997-2010 The PHP Group |
- +----------------------------------------------------------------------+
- | This source file is subject to version 3.01 of the PHP license, |
- | that is bundled with this package in the file LICENSE, and is |
- | available through the world-wide-web at the following url: |
- | http://www.php.net/license/3_01.txt |
- | If you did not receive a copy of the PHP license and are unable to |
- | obtain it through the world-wide-web, please send a note to |
- | license@php.net so we can mail you a copy immediately. |
- +----------------------------------------------------------------------+
- */
- #include <runtime/ext/hash/hash_whirlpool.h>
- #include <runtime/ext/hash/php_hash_whirlpool_tables.h>
- namespace HPHP {
- ///////////////////////////////////////////////////////////////////////////////
- typedef struct {
- uint64 state[8];
- unsigned char bitlength[32];
- struct {
- int pos;
- int bits;
- unsigned char data[64];
- } buffer;
- } PHP_WHIRLPOOL_CTX;
- hash_whirlpool::hash_whirlpool() :
- HashEngine(64, 64, sizeof(PHP_WHIRLPOOL_CTX)) {
- };
- #define DIGESTBYTES 64
- #define DIGESTBITS (8*DIGESTBYTES) /* 512 */
- #define WBLOCKBYTES 64
- #define WBLOCKBITS (8*WBLOCKBYTES) /* 512 */
- #define LENGTHBYTES 32
- #define LENGTHBITS (8*LENGTHBYTES) /* 256 */
- static void WhirlpoolTransform(PHP_WHIRLPOOL_CTX *context) {
- int i, r;
- unsigned long K[8]; /* the round key */
- unsigned long block[8]; /* mu(buffer) */
- unsigned long state[8]; /* the cipher state */
- unsigned long L[8];
- unsigned char *buffer = context->buffer.data;
- /*
- * map the buffer to a block:
- */
- for (i = 0; i < 8; i++, buffer += 8) {
- block[i] =
- (((unsigned long)buffer[0] ) << 56) ^
- (((unsigned long)buffer[1] & 0xffL) << 48) ^
- (((unsigned long)buffer[2] & 0xffL) << 40) ^
- (((unsigned long)buffer[3] & 0xffL) << 32) ^
- (((unsigned long)buffer[4] & 0xffL) << 24) ^
- (((unsigned long)buffer[5] & 0xffL) << 16) ^
- (((unsigned long)buffer[6] & 0xffL) << 8) ^
- (((unsigned long)buffer[7] & 0xffL) );
- }
- /*
- * compute and apply K^0 to the cipher state:
- */
- state[0] = block[0] ^ (K[0] = context->state[0]);
- state[1] = block[1] ^ (K[1] = context->state[1]);
- state[2] = block[2] ^ (K[2] = context->state[2]);
- state[3] = block[3] ^ (K[3] = context->state[3]);
- state[4] = block[4] ^ (K[4] = context->state[4]);
- state[5] = block[5] ^ (K[5] = context->state[5]);
- state[6] = block[6] ^ (K[6] = context->state[6]);
- state[7] = block[7] ^ (K[7] = context->state[7]);
- /*
- * iterate over all rounds:
- */
- for (r = 1; r <= R; r++) {
- /*
- * compute K^r from K^{r-1}:
- */
- L[0] =
- C0[(int)(K[0] >> 56) ] ^
- C1[(int)(K[7] >> 48) & 0xff] ^
- C2[(int)(K[6] >> 40) & 0xff] ^
- C3[(int)(K[5] >> 32) & 0xff] ^
- C4[(int)(K[4] >> 24) & 0xff] ^
- C5[(int)(K[3] >> 16) & 0xff] ^
- C6[(int)(K[2] >> 8) & 0xff] ^
- C7[(int)(K[1] ) & 0xff] ^
- rc[r];
- L[1] =
- C0[(int)(K[1] >> 56) ] ^
- C1[(int)(K[0] >> 48) & 0xff] ^
- C2[(int)(K[7] >> 40) & 0xff] ^
- C3[(int)(K[6] >> 32) & 0xff] ^
- C4[(int)(K[5] >> 24) & 0xff] ^
- C5[(int)(K[4] >> 16) & 0xff] ^
- C6[(int)(K[3] >> 8) & 0xff] ^
- C7[(int)(K[2] ) & 0xff];
- L[2] =
- C0[(int)(K[2] >> 56) ] ^
- C1[(int)(K[1] >> 48) & 0xff] ^
- C2[(int)(K[0] >> 40) & 0xff] ^
- C3[(int)(K[7] >> 32) & 0xff] ^
- C4[(int)(K[6] >> 24) & 0xff] ^
- C5[(int)(K[5] >> 16) & 0xff] ^
- C6[(int)(K[4] >> 8) & 0xff] ^
- C7[(int)(K[3] ) & 0xff];
- L[3] =
- C0[(int)(K[3] >> 56) ] ^
- C1[(int)(K[2] >> 48) & 0xff] ^
- C2[(int)(K[1] >> 40) & 0xff] ^
- C3[(int)(K[0] >> 32) & 0xff] ^
- C4[(int)(K[7] >> 24) & 0xff] ^
- C5[(int)(K[6] >> 16) & 0xff] ^
- C6[(int)(K[5] >> 8) & 0xff] ^
- C7[(int)(K[4] ) & 0xff];
- L[4] =
- C0[(int)(K[4] >> 56) ] ^
- C1[(int)(K[3] >> 48) & 0xff] ^
- C2[(int)(K[2] >> 40) & 0xff] ^
- C3[(int)(K[1] >> 32) & 0xff] ^
- C4[(int)(K[0] >> 24) & 0xff] ^
- C5[(int)(K[7] >> 16) & 0xff] ^
- C6[(int)(K[6] >> 8) & 0xff] ^
- C7[(int)(K[5] ) & 0xff];
- L[5] =
- C0[(int)(K[5] >> 56) ] ^
- C1[(int)(K[4] >> 48) & 0xff] ^
- C2[(int)(K[3] >> 40) & 0xff] ^
- C3[(int)(K[2] >> 32) & 0xff] ^
- C4[(int)(K[1] >> 24) & 0xff] ^
- C5[(int)(K[0] >> 16) & 0xff] ^
- C6[(int)(K[7] >> 8) & 0xff] ^
- C7[(int)(K[6] ) & 0xff];
- L[6] =
- C0[(int)(K[6] >> 56) ] ^
- C1[(int)(K[5] >> 48) & 0xff] ^
- C2[(int)(K[4] >> 40) & 0xff] ^
- C3[(int)(K[3] >> 32) & 0xff] ^
- C4[(int)(K[2] >> 24) & 0xff] ^
- C5[(int)(K[1] >> 16) & 0xff] ^
- C6[(int)(K[0] >> 8) & 0xff] ^
- C7[(int)(K[7] ) & 0xff];
- L[7] =
- C0[(int)(K[7] >> 56) ] ^
- C1[(int)(K[6] >> 48) & 0xff] ^
- C2[(int)(K[5] >> 40) & 0xff] ^
- C3[(int)(K[4] >> 32) & 0xff] ^
- C4[(int)(K[3] >> 24) & 0xff] ^
- C5[(int)(K[2] >> 16) & 0xff] ^
- C6[(int)(K[1] >> 8) & 0xff] ^
- C7[(int)(K[0] ) & 0xff];
- K[0] = L[0];
- K[1] = L[1];
- K[2] = L[2];
- K[3] = L[3];
- K[4] = L[4];
- K[5] = L[5];
- K[6] = L[6];
- K[7] = L[7];
- /*
- * apply the r-th round transformation:
- */
- L[0] =
- C0[(int)(state[0] >> 56) ] ^
- C1[(int)(state[7] >> 48) & 0xff] ^
- C2[(int)(state[6] >> 40) & 0xff] ^
- C3[(int)(state[5] >> 32) & 0xff] ^
- C4[(int)(state[4] >> 24) & 0xff] ^
- C5[(int)(state[3] >> 16) & 0xff] ^
- C6[(int)(state[2] >> 8) & 0xff] ^
- C7[(int)(state[1] ) & 0xff] ^
- K[0];
- L[1] =
- C0[(int)(state[1] >> 56) ] ^
- C1[(int)(state[0] >> 48) & 0xff] ^
- C2[(int)(state[7] >> 40) & 0xff] ^
- C3[(int)(state[6] >> 32) & 0xff] ^
- C4[(int)(state[5] >> 24) & 0xff] ^
- C5[(int)(state[4] >> 16) & 0xff] ^
- C6[(int)(state[3] >> 8) & 0xff] ^
- C7[(int)(state[2] ) & 0xff] ^
- K[1];
- L[2] =
- C0[(int)(state[2] >> 56) ] ^
- C1[(int)(state[1] >> 48) & 0xff] ^
- C2[(int)(state[0] >> 40) & 0xff] ^
- C3[(int)(state[7] >> 32) & 0xff] ^
- C4[(int)(state[6] >> 24) & 0xff] ^
- C5[(int)(state[5] >> 16) & 0xff] ^
- C6[(int)(state[4] >> 8) & 0xff] ^
- C7[(int)(state[3] ) & 0xff] ^
- K[2];
- L[3] =
- C0[(int)(state[3] >> 56) ] ^
- C1[(int)(state[2] >> 48) & 0xff] ^
- C2[(int)(state[1] >> 40) & 0xff] ^
- C3[(int)(state[0] >> 32) & 0xff] ^
- C4[(int)(state[7] >> 24) & 0xff] ^
- C5[(int)(state[6] >> 16) & 0xff] ^
- C6[(int)(state[5] >> 8) & 0xff] ^
- C7[(int)(state[4] ) & 0xff] ^
- K[3];
- L[4] =
- C0[(int)(state[4] >> 56) ] ^
- C1[(int)(state[3] >> 48) & 0xff] ^
- C2[(int)(state[2] >> 40) & 0xff] ^
- C3[(int)(state[1] >> 32) & 0xff] ^
- C4[(int)(state[0] >> 24) & 0xff] ^
- C5[(int)(state[7] >> 16) & 0xff] ^
- C6[(int)(state[6] >> 8) & 0xff] ^
- C7[(int)(state[5] ) & 0xff] ^
- K[4];
- L[5] =
- C0[(int)(state[5] >> 56) ] ^
- C1[(int)(state[4] >> 48) & 0xff] ^
- C2[(int)(state[3] >> 40) & 0xff] ^
- C3[(int)(state[2] >> 32) & 0xff] ^
- C4[(int)(state[1] >> 24) & 0xff] ^
- C5[(int)(state[0] >> 16) & 0xff] ^
- C6[(int)(state[7] >> 8) & 0xff] ^
- C7[(int)(state[6] ) & 0xff] ^
- K[5];
- L[6] =
- C0[(int)(state[6] >> 56) ] ^
- C1[(int)(state[5] >> 48) & 0xff] ^
- C2[(int)(state[4] >> 40) & 0xff] ^
- C3[(int)(state[3] >> 32) & 0xff] ^
- C4[(int)(state[2] >> 24) & 0xff] ^
- C5[(int)(state[1] >> 16) & 0xff] ^
- C6[(int)(state[0] >> 8) & 0xff] ^
- C7[(int)(state[7] ) & 0xff] ^
- K[6];
- L[7] =
- C0[(int)(state[7] >> 56) ] ^
- C1[(int)(state[6] >> 48) & 0xff] ^
- C2[(int)(state[5] >> 40) & 0xff] ^
- C3[(int)(state[4] >> 32) & 0xff] ^
- C4[(int)(state[3] >> 24) & 0xff] ^
- C5[(int)(state[2] >> 16) & 0xff] ^
- C6[(int)(state[1] >> 8) & 0xff] ^
- C7[(int)(state[0] ) & 0xff] ^
- K[7];
- state[0] = L[0];
- state[1] = L[1];
- state[2] = L[2];
- state[3] = L[3];
- state[4] = L[4];
- state[5] = L[5];
- state[6] = L[6];
- state[7] = L[7];
- }
- /*
- * apply the Miyaguchi-Preneel compression function:
- */
- context->state[0] ^= state[0] ^ block[0];
- context->state[1] ^= state[1] ^ block[1];
- context->state[2] ^= state[2] ^ block[2];
- context->state[3] ^= state[3] ^ block[3];
- context->state[4] ^= state[4] ^ block[4];
- context->state[5] ^= state[5] ^ block[5];
- context->state[6] ^= state[6] ^ block[6];
- context->state[7] ^= state[7] ^ block[7];
- memset(state, 0, sizeof(state));
- }
- void hash_whirlpool::hash_init(void *context_) {
- PHP_WHIRLPOOL_CTX *context = (PHP_WHIRLPOOL_CTX*)context_;
- memset(context, 0, sizeof(*context));
- }
- void hash_whirlpool::hash_update(void *context_, const unsigned char *input,
- unsigned int len) {
- PHP_WHIRLPOOL_CTX *context = (PHP_WHIRLPOOL_CTX*)context_;
- unsigned long sourceBits = len * 8;
- /* index of leftmost source unsigned char containing data (1 to 8 bits). */
- int sourcePos = 0;
- /* space on source[sourcePos]. */
- int sourceGap = (8 - ((int)sourceBits & 7)) & 7;
- /* occupied bits on buffer[bufferPos]. */
- int bufferRem = context->buffer.bits & 7;
- const unsigned char *source = input;
- unsigned char *buffer = context->buffer.data;
- unsigned char *bitLength = context->bitlength;
- int bufferBits = context->buffer.bits;
- int bufferPos = context->buffer.pos;
- unsigned int b, carry;
- int i;
- /*
- * tally the length of the added data:
- */
- unsigned long value = sourceBits;
- for (i = 31, carry = 0; i >= 0 && (carry != 0 || value != L64(0)); i--) {
- carry += bitLength[i] + ((unsigned int)value & 0xff);
- bitLength[i] = (unsigned char)carry;
- carry >>= 8;
- value >>= 8;
- }
- /*
- * process data in chunks of 8 bits (a more efficient approach would be to
- * take whole-word chunks):
- */
- while (sourceBits > 8) {
- /* N.B. at least source[sourcePos] and source[sourcePos+1] contain data. */
- /*
- * take a byte from the source:
- */
- b = ((source[sourcePos] << sourceGap) & 0xff) |
- ((source[sourcePos + 1] & 0xff) >> (8 - sourceGap));
- /*
- * process this byte:
- */
- buffer[bufferPos++] |= (unsigned char)(b >> bufferRem);
- bufferBits += 8 - bufferRem; /* bufferBits = 8*bufferPos; */
- if (bufferBits == DIGESTBITS) {
- /*
- * process data block:
- */
- WhirlpoolTransform(context);
- /*
- * reset buffer:
- */
- bufferBits = bufferPos = 0;
- }
- buffer[bufferPos] = (unsigned char) (b << (8 - bufferRem));
- bufferBits += bufferRem;
- /*
- * proceed to remaining data:
- */
- sourceBits -= 8;
- sourcePos++;
- }
- /* now 0 <= sourceBits <= 8;
- * furthermore, all data (if any is left) is in source[sourcePos].
- */
- if (sourceBits > 0) {
- /* bits are left-justified on b. */
- b = (source[sourcePos] << sourceGap) & 0xff;
- /*
- * process the remaining bits:
- */
- buffer[bufferPos] |= b >> bufferRem;
- } else {
- b = 0;
- }
- if (bufferRem + sourceBits < 8) {
- /*
- * all remaining data fits on buffer[bufferPos],
- * and there still remains some space.
- */
- bufferBits += (int) sourceBits;
- } else {
- /*
- * buffer[bufferPos] is full:
- */
- bufferPos++;
- bufferBits += 8 - bufferRem; /* bufferBits = 8*bufferPos; */
- sourceBits -= 8 - bufferRem;
- /* now 0 <= sourceBits < 8;
- * furthermore, all data (if any is left) is in source[sourcePos].
- */
- if (bufferBits == DIGESTBITS) {
- /*
- * process data block:
- */
- WhirlpoolTransform(context);
- /*
- * reset buffer:
- */
- bufferBits = bufferPos = 0;
- }
- buffer[bufferPos] = (unsigned char) (b << (8 - bufferRem));
- bufferBits += (int)sourceBits;
- }
- context->buffer.bits = bufferBits;
- context->buffer.pos = bufferPos;
- }
- void hash_whirlpool::hash_final(unsigned char *digest, void *context_) {
- PHP_WHIRLPOOL_CTX *context = (PHP_WHIRLPOOL_CTX*)context_;
- int i;
- unsigned char *buffer = context->buffer.data;
- unsigned char *bitLength = context->bitlength;
- int bufferBits = context->buffer.bits;
- int bufferPos = context->buffer.pos;
- /*
- * append a '1'-bit:
- */
- buffer[bufferPos] |= 0x80U >> (bufferBits & 7);
- /* all remaining bits on the current unsigned char are set to zero. */
- bufferPos++;
- /*
- * pad with zero bits to complete (N*WBLOCKBITS - LENGTHBITS) bits:
- */
- if (bufferPos > WBLOCKBYTES - LENGTHBYTES) {
- if (bufferPos < WBLOCKBYTES) {
- memset(&buffer[bufferPos], 0, WBLOCKBYTES - bufferPos);
- }
- /*
- * process data block:
- */
- WhirlpoolTransform(context);
- /*
- * reset buffer:
- */
- bufferPos = 0;
- }
- if (bufferPos < WBLOCKBYTES - LENGTHBYTES) {
- memset(&buffer[bufferPos], 0, (WBLOCKBYTES - LENGTHBYTES) - bufferPos);
- }
- bufferPos = WBLOCKBYTES - LENGTHBYTES;
- /*
- * append bit length of hashed data:
- */
- memcpy(&buffer[WBLOCKBYTES - LENGTHBYTES], bitLength, LENGTHBYTES);
- /*
- * process data block:
- */
- WhirlpoolTransform(context);
- /*
- * return the completed message digest:
- */
- for (i = 0; i < DIGESTBYTES/8; i++) {
- digest[0] = (unsigned char)(context->state[i] >> 56);
- digest[1] = (unsigned char)(context->state[i] >> 48);
- digest[2] = (unsigned char)(context->state[i] >> 40);
- digest[3] = (unsigned char)(context->state[i] >> 32);
- digest[4] = (unsigned char)(context->state[i] >> 24);
- digest[5] = (unsigned char)(context->state[i] >> 16);
- digest[6] = (unsigned char)(context->state[i] >> 8);
- digest[7] = (unsigned char)(context->state[i] );
- digest += 8;
- }
- memset(context, 0, sizeof(*context));
- }
- ///////////////////////////////////////////////////////////////////////////////
- }