/*

 * MD4 (RFC-1320) message digest.

 * Modified from MD5 code by Andrey Panin <pazke@donpac.ru>

 *

 * Written by Solar Designer <solar@openwall.com> in 2001, and placed in

 * the public domain.  There's absolutely no warranty.

 *

 * This differs from Colin Plumb's older public domain implementation in

 * that no 32-bit integer data type is required, there's no compile-time

 * endianness configuration.

 * The primary goals are portability and ease of use.

 *

 * This implementation is meant to be fast, but not as fast as possible.

 * Some known optimizations are not included to reduce source code size

 * and avoid compile-time configuration.

 */

#include "crypt-port.h"

#include "alg-md4.h"

#include "byteorder.h"

#if INCLUDE_nthash

/*

 * The basic MD4 functions.

 */

#define F(x, y, z)  ((z) ^ ((x) & ((y) ^ (z))))

#define G(x, y, z)  (((x) & (y)) | ((x) & (z)) | ((y) & (z)))

#define H(x, y, z)  ((x) ^ (y) ^ (z))

/*

 * The MD4 transformation for all four rounds.

 */

#define STEP(f, a, b, c, d, x, s) \

  (a) += f((b), (c), (d)) + (x);   \

  (a) = ((a) << (s)) | ((a) >> (32 - (s)))

/*

 * SET reads 4 input bytes in little-endian byte order and stores them

 * in a properly aligned word in host byte order.

 *

 * The check for little-endian architectures which tolerate unaligned

 * memory accesses is just an optimization.  Nothing will break if it

 * doesn't work.

 */

#define SET(n) \

  (ctx->block[(n)] = le32_to_cpu (&ptr[(n) * 4]))

#define GET(n) \

  (ctx->block[(n)])

/*

 * This processes one or more 64-byte data blocks, but does NOT update

 * the bit counters.  There're no alignment requirements.

 */

static const unsigned char *

body (struct md4_ctx *ctx, const unsigned char *data, size_t size)

{

  const unsigned char *ptr;

  uint32_t a, b, c, d;

  uint32_t saved_a, saved_b, saved_c, saved_d;

  ptr = data;

  a = ctx->a;

  b = ctx->b;

  c = ctx->c;

  d = ctx->d;

  do

    {

      saved_a = a;

      saved_b = b;

      saved_c = c;

      saved_d = d;

      /* Round 1 */

      STEP(F, a, b, c, d, SET( 0),  3);

      STEP(F, d, a, b, c, SET( 1),  7);

      STEP(F, c, d, a, b, SET( 2), 11);

      STEP(F, b, c, d, a, SET( 3), 19);

      STEP(F, a, b, c, d, SET( 4),  3);

      STEP(F, d, a, b, c, SET( 5),  7);

      STEP(F, c, d, a, b, SET( 6), 11);

      STEP(F, b, c, d, a, SET( 7), 19);

      STEP(F, a, b, c, d, SET( 8),  3);

      STEP(F, d, a, b, c, SET( 9),  7);

      STEP(F, c, d, a, b, SET(10), 11);

      STEP(F, b, c, d, a, SET(11), 19);

      STEP(F, a, b, c, d, SET(12),  3);

      STEP(F, d, a, b, c, SET(13),  7);

      STEP(F, c, d, a, b, SET(14), 11);

      STEP(F, b, c, d, a, SET(15), 19);

      /* Round 2 */

      STEP(G, a, b, c, d, GET( 0) + 0x5A827999,  3);

      STEP(G, d, a, b, c, GET( 4) + 0x5A827999,  5);

      STEP(G, c, d, a, b, GET( 8) + 0x5A827999,  9);

      STEP(G, b, c, d, a, GET(12) + 0x5A827999, 13);

      STEP(G, a, b, c, d, GET( 1) + 0x5A827999,  3);

      STEP(G, d, a, b, c, GET( 5) + 0x5A827999,  5);

      STEP(G, c, d, a, b, GET( 9) + 0x5A827999,  9);

      STEP(G, b, c, d, a, GET(13) + 0x5A827999, 13);

      STEP(G, a, b, c, d, GET( 2) + 0x5A827999,  3);

      STEP(G, d, a, b, c, GET( 6) + 0x5A827999,  5);

      STEP(G, c, d, a, b, GET(10) + 0x5A827999,  9);

      STEP(G, b, c, d, a, GET(14) + 0x5A827999, 13);

      STEP(G, a, b, c, d, GET( 3) + 0x5A827999,  3);

      STEP(G, d, a, b, c, GET( 7) + 0x5A827999,  5);

      STEP(G, c, d, a, b, GET(11) + 0x5A827999,  9);

      STEP(G, b, c, d, a, GET(15) + 0x5A827999, 13);

      /* Round 3 */

      STEP(H, a, b, c, d, GET( 0) + 0x6ED9EBA1,  3);

      STEP(H, d, a, b, c, GET( 8) + 0x6ED9EBA1,  9);

      STEP(H, c, d, a, b, GET( 4) + 0x6ED9EBA1, 11);

      STEP(H, b, c, d, a, GET(12) + 0x6ED9EBA1, 15);

      STEP(H, a, b, c, d, GET( 2) + 0x6ED9EBA1,  3);

      STEP(H, d, a, b, c, GET(10) + 0x6ED9EBA1,  9);

      STEP(H, c, d, a, b, GET( 6) + 0x6ED9EBA1, 11);

      STEP(H, b, c, d, a, GET(14) + 0x6ED9EBA1, 15);

      STEP(H, a, b, c, d, GET( 1) + 0x6ED9EBA1,  3);

      STEP(H, d, a, b, c, GET( 9) + 0x6ED9EBA1,  9);

      STEP(H, c, d, a, b, GET( 5) + 0x6ED9EBA1, 11);

      STEP(H, b, c, d, a, GET(13) + 0x6ED9EBA1, 15);

      STEP(H, a, b, c, d, GET( 3) + 0x6ED9EBA1,  3);

      STEP(H, d, a, b, c, GET(11) + 0x6ED9EBA1,  9);

      STEP(H, c, d, a, b, GET( 7) + 0x6ED9EBA1, 11);

      STEP(H, b, c, d, a, GET(15) + 0x6ED9EBA1, 15);

      a += saved_a;

      b += saved_b;

      c += saved_c;

      d += saved_d;

      ptr += 64;

    }

  while (size -= 64);

  ctx->a = a;

  ctx->b = b;

  ctx->c = c;

  ctx->d = d;

  return ptr;

}

/* Put result from CTX in first 16 bytes following RESBUF.  The result

   will be in little endian byte order.  */

static void *

md4_read_ctx (struct md4_ctx *ctx, void *resbuf)

{

  unsigned char *buf = resbuf;

  cpu_to_le32 (buf +  0, ctx->a);

  cpu_to_le32 (buf +  4, ctx->b);

  cpu_to_le32 (buf +  8, ctx->c);

  cpu_to_le32 (buf + 12, ctx->d);

  XCRYPT_SECURE_MEMSET (ctx, sizeof(struct md4_ctx));

  return resbuf;

}

void

md4_init_ctx (struct md4_ctx *ctx)

{

  ctx->a = 0x67452301;

  ctx->b = 0xefcdab89;

  ctx->c = 0x98badcfe;

  ctx->d = 0x10325476;

  ctx->lo = 0;

  ctx->hi = 0;

}

void

md4_process_bytes (const void *buffer, struct md4_ctx *ctx, size_t size)

{

  uint32_t saved_lo;

  size_t used, free;

  saved_lo = ctx->lo;

  if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)

    ctx->hi++;

  ctx->hi += (uint32_t)(size >> 29);

  used = saved_lo & 0x3f;

  if (used)

    {

      free = 64 - used;

      if (size < free)

        {

          memcpy(&ctx->buffer[used], buffer, size);

          return;

        }

      memcpy(&ctx->buffer[used], buffer, free);

      buffer = (const unsigned char *) buffer + free;

      size -= free;

      body(ctx, ctx->buffer, 64);

    }

  if (size >= 64)

    {

      buffer = body(ctx, buffer, size & ~(uint32_t)0x3f);

      size &= 0x3f;

    }

  memcpy(ctx->buffer, buffer, size);

}

void *

md4_finish_ctx (struct md4_ctx *ctx, void *resbuf)

{

  size_t used, free;

  used = ctx->lo & 0x3f;

  ctx->buffer[used++] = 0x80;

  free = 64 - used;

  if (free < 8)

    {

      XCRYPT_SECURE_MEMSET (&ctx->buffer[used], free);

      body(ctx, ctx->buffer, 64);

      used = 0;

      free = 64;

    }

  XCRYPT_SECURE_MEMSET (&ctx->buffer[used], free - 8);

  ctx->lo <<= 3;

  ctx->buffer[56] = (unsigned char)((ctx->lo) & 0xff);

  ctx->buffer[57] = (unsigned char)((ctx->lo >> 8) & 0xff);

  ctx->buffer[58] = (unsigned char)((ctx->lo >> 16) & 0xff);

  ctx->buffer[59] = (unsigned char)((ctx->lo >> 24) & 0xff);

  ctx->buffer[60] = (unsigned char)((ctx->hi) & 0xff);

  ctx->buffer[61] = (unsigned char)((ctx->hi >> 8) & 0xff);

  ctx->buffer[62] = (unsigned char)((ctx->hi >> 16) & 0xff);

  ctx->buffer[63] = (unsigned char)((ctx->hi >> 24) & 0xff);

  body(ctx, ctx->buffer, 64);

  return md4_read_ctx (ctx, resbuf);

}

#endif