Rearrange the file tree.

[u/mdw/catacomb] / symm / whirlpool.c

/* -*-c-*-
 *
 * Whirlpool hash function
 *
 * (c) 2005 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of Catacomb.
 *
 * Catacomb is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * Catacomb is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with Catacomb; if not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

/*----- Header files ------------------------------------------------------*/

#include <mLib/bits.h>

#include "ghash.h"
#include "ghash-def.h"
#include "hash.h"
#include "whirlpool.h"
#include "whirlpool-tab.h"

#if defined(HAVE_UINT64)
#  define USE64
#endif

/*----- Static variables --------------------------------------------------*/

static const kludge64 C[10] = WHIRLPOOL_C;

#ifdef USE64
static const kludge64 T[8][256] = WHIRLPOOL_T;
#else
static const uint32 U[4][256] = WHIRLPOOL_U, V[4][256] = WHIRLPOOL_V;
#endif

/*----- Main code ---------------------------------------------------------*/

#define DUMP(k, v) do {							\
  int i;								\
  printf("\n");								\
  for (i = 0; i < 8; i++)						\
    printf("  %08x %08x	 :  %08x %08x\n",				\
	   HI64(k[i]), LO64(k[i]),					\
	   HI64(v[i]), LO64(v[i]));					\
} while (0)

#define OFFSET(i, n) (((i) + 16 - (n)) % 8)

#ifdef USE64

#define BYTE(x, j)							\
  U8((j) < 4 ?								\
    (LO64(x) >> ((j) * 8)) :						\
    (HI64(x) >> ((j) * 8 - 32)))

#define TT(v, i, j) T[j][BYTE(v[OFFSET(i, j)], j)]

#define XROW(vv, v, i) do {						\
  XOR64(vv[i], vv[i], TT(v, i, 1));					\
  XOR64(vv[i], vv[i], TT(v, i, 2));					\
  XOR64(vv[i], vv[i], TT(v, i, 3));					\
  XOR64(vv[i], vv[i], TT(v, i, 4));					\
  XOR64(vv[i], vv[i], TT(v, i, 5));					\
  XOR64(vv[i], vv[i], TT(v, i, 6));					\
  XOR64(vv[i], vv[i], TT(v, i, 7));					\
} while (0)

#define ROWZ(vv, v, i) do {						\
  vv[i] = TT(v, i, 0);							\
  XROW(vv, v, i);							\
} while (0)

#define ROWK(vv, v, i, k) do {						\
  vv[i] = k;								\
  XOR64(vv[i], vv[i], TT(v, i, 0));					\
  XROW(vv, v, i);							\
} while (0)

#else

#define BYTE(x, j) U8((x) >> (((j) & 3) * 8))

#define UUL(v, i, j) U[j & 3][BYTE(v[OFFSET(i, j)].lo, j)]
#define VVL(v, i, j) V[j & 3][BYTE(v[OFFSET(i, j)].lo, j)]
#define UUH(v, i, j) U[j & 3][BYTE(v[OFFSET(i, j)].hi, j)]
#define VVH(v, i, j) V[j & 3][BYTE(v[OFFSET(i, j)].hi, j)]

#define XROW(vv, v, i) do {						\
  vv[i].lo ^= UUL(v, i, 1); vv[i].hi ^= VVL(v, i, 1);			\
  vv[i].lo ^= UUL(v, i, 2); vv[i].hi ^= VVL(v, i, 2);			\
  vv[i].lo ^= UUL(v, i, 3); vv[i].hi ^= VVL(v, i, 3);			\
  vv[i].lo ^= VVH(v, i, 4); vv[i].hi ^= UUH(v, i, 4);			\
  vv[i].lo ^= VVH(v, i, 5); vv[i].hi ^= UUH(v, i, 5);			\
  vv[i].lo ^= VVH(v, i, 6); vv[i].hi ^= UUH(v, i, 6);			\
  vv[i].lo ^= VVH(v, i, 7); vv[i].hi ^= UUH(v, i, 7);			\
} while (0)

#define ROWZ(vv, v, i) do {						\
  vv[i].lo = UUL(v, i, 0);  vv[i].hi = VVL(v, i, 0);			\
  XROW(vv, v, i);							\
} while (0)

#define ROWK(vv, v, i, k) do {						\
  vv[i] = k;								\
  vv[i].lo ^= UUL(v, i, 0); vv[i].hi ^= VVL(v, i, 0);			\
  XROW(vv, v, i);							\
} while (0)

#endif

#define RHO(vv, v, kk, k) do {						\
  ROWK(kk, k, 0, *c++);	  ROWK(vv, v, 0, kk[0]);			\
  ROWZ(kk, k, 1);	  ROWK(vv, v, 1, kk[1]);			\
  ROWZ(kk, k, 2);	  ROWK(vv, v, 2, kk[2]);			\
  ROWZ(kk, k, 3);	  ROWK(vv, v, 3, kk[3]);			\
  ROWZ(kk, k, 4);	  ROWK(vv, v, 4, kk[4]);			\
  ROWZ(kk, k, 5);	  ROWK(vv, v, 5, kk[5]);			\
  ROWZ(kk, k, 6);	  ROWK(vv, v, 6, kk[6]);			\
  ROWZ(kk, k, 7);	  ROWK(vv, v, 7, kk[7]);			\
} while (0)

void whirlpool_compress(whirlpool_ctx *ctx, const void *sbuf)
{
  kludge64 m[8], k[8], kk[8], v[8], vv[8];
  const kludge64 *c = C;
  const octet *s = sbuf;
  int i;

  for (i = 0; i < 8; i++) {
    LOAD64_L_(m[i], &s[i * 8]);
    XOR64(v[i], m[i], ctx->s[i]);
  }

  RHO(vv, v, kk, ctx->s);
  RHO(v, vv, k, kk);
  RHO(vv, v, kk, k);
  RHO(v, vv, k, kk);
  RHO(vv, v, kk, k);
  RHO(v, vv, k, kk);
  RHO(vv, v, kk, k);
  RHO(v, vv, k, kk);
  RHO(vv, v, kk, k);
  RHO(v, vv, k, kk);

  for (i = 0; i < 8; i++) {
    XOR64(ctx->s[i], ctx->s[i], m[i]);
    XOR64(ctx->s[i], ctx->s[i], v[i]);
  }
}

/* --- @whirlpool_init@, @whirlpool256_init@ --- *
 *
 * Arguments:	@whirlpool_ctx *ctx@ = pointer to context block to initialize
 *
 * Returns:	---
 *
 * Use:		Initializes a context block ready for hashing.
 */

void whirlpool_init(whirlpool_ctx *ctx)
{
  int i;

  for (i = 0; i < 8; i++)
    SET64(ctx->s[i], 0, 0);
  ctx->off = 0;
  ctx->nh = ctx->nl = 0;
}

/* --- @whirlpool_set@, @whirlpool256_set@ --- *
 *
 * Arguments:	@whirlpool_ctx *ctx@ = pointer to context block
 *		@const void *buf@ = pointer to state buffer
 *		@unsigned long count@ = current count of bytes processed
 *
 * Returns:	---
 *
 * Use:		Initializes a context block from a given state.  This is
 *		useful in cases where the initial hash state is meant to be
 *		secret, e.g., for NMAC and HMAC support.
 */

void whirlpool_set(whirlpool_ctx *ctx, const void *buf, unsigned long count)
{
  const octet *p = buf;
  int i;

  for (i = 0; i < 8; i++) {
    LOAD64_L_(ctx->s[i], p);
    p += 8;
  }
  ctx->off = 0;
  ctx->nl = U32(count);
  ctx->nh = U32(((count & ~MASK32) >> 16) >> 16);
}

/* --- @whirlpool_hash@, @whirlpool256_hash@ --- *
 *
 * Arguments:	@whirlpool_ctx *ctx@ = pointer to context block
 *		@const void *buf@ = buffer of data to hash
 *		@size_t sz@ = size of buffer to hash
 *
 * Returns:	---
 *
 * Use:		Hashes a buffer of data.  The buffer may be of any size and
 *		alignment.
 */

void whirlpool_hash(whirlpool_ctx *ctx, const void *buf, size_t sz)
{
  HASH_BUFFER(WHIRLPOOL, whirlpool, ctx, buf, sz);
}

/* --- @whirlpool_done@, @whirlpool256_done@ --- *
 *
 * Arguments:	@whirlpool_ctx *ctx@ = pointer to context block
 *		@void *hash@ = pointer to output buffer
 *
 * Returns:	---
 *
 * Use:		Returns the hash of the data read so far.
 */

static void final(whirlpool_ctx *ctx)
{
  HASH_PAD(WHIRLPOOL, whirlpool, ctx, 0x80, 0, 32);
  memset(ctx->buf + WHIRLPOOL_BUFSZ - 32, 0, 24);
  STORE32(ctx->buf + WHIRLPOOL_BUFSZ -	8, (ctx->nl >> 29) | (ctx->nh << 3));
  STORE32(ctx->buf + WHIRLPOOL_BUFSZ -	4, ctx->nl << 3);
  whirlpool_compress(ctx, ctx->buf);
}

void whirlpool_done(whirlpool_ctx *ctx, void *hash)
{
  octet *p = hash;
  int i;

  final(ctx);
  for (i = 0; i < 8; i++) {
    STORE64_L_(p, ctx->s[i]);
    p += 8;
  }
}

void whirlpool256_done(whirlpool256_ctx *ctx, void *hash)
{
  octet *p = hash;
  int i;

  final(ctx);
  for (i = 0; i < 4; i++) {
    STORE64_L_(p, ctx->s[i]);
    p += 8;
  }
}

/* --- @whirlpool_state@, @whirlpool256_state@ --- *
 *
 * Arguments:	@whirlpool_ctx *ctx@ = pointer to context
 *		@void *state@ = pointer to buffer for current state
 *
 * Returns:	Number of bytes written to the hash function so far.
 *
 * Use:		Returns the current state of the hash function such that
 *		it can be passed to @whirlpool_set@.
 */

unsigned long whirlpool_state(whirlpool_ctx *ctx, void *state)
{
  octet *p = state;
  int i;

  for (i = 0; i < 8; i++) {
    STORE64_L_(p, ctx->s[i]);
    p += 8;
  }
  return (ctx->nl | ((ctx->nh << 16) << 16));
}

/* --- Generic interface --- */

GHASH_DEF(WHIRLPOOL, whirlpool)

/* --- Test code --- */

HASH_TEST(WHIRLPOOL, whirlpool)

/*----- That's all, folks -------------------------------------------------*/