create tremded branch

14 files changed, 1566 insertions, 0 deletions

diff --git a/src/granger/src/nettle/CMakeLists.txt b/src/granger/src/nettle/CMakeLists.txt
new file mode 100644
index 0000000..c2ec77c
--- /dev/null
+++ b/src/granger/src/nettle/CMakeLists.txt
@@ -0,0 +1,23 @@
+if(NOT WIN32)
+    add_definitions(-Wall -Wextra)
+endif(NOT WIN32)
+
+if(WIN32)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+endif(WIN32)
+
+add_library(granger_nettle
+    macros.h
+    md5-compress.c
+    md5.c
+    md5.h
+    nettle-stdint.h
+    nettle-types.h
+    nettle-write.h
+    sha2.h
+    sha256-compress.c
+    sha256.c
+    version.h
+    write-be32.c
+    write-le32.c
+    )
diff --git a/src/granger/src/nettle/macros.h b/src/granger/src/nettle/macros.h
new file mode 100644
index 0000000..af84841
--- /dev/null
+++ b/src/granger/src/nettle/macros.h
@@ -0,0 +1,245 @@
+/* macros.h
+
+   Copyright (C) 2001, 2010 Niels Möller
+
+   This file is part of GNU Nettle.
+
+   GNU Nettle is free software: you can redistribute it and/or
+   modify it under the terms of either:
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or both in parallel, as here.
+
+   GNU Nettle 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
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see http://www.gnu.org/licenses/.
+*/
+
+#ifndef NETTLE_MACROS_H_INCLUDED
+#define NETTLE_MACROS_H_INCLUDED
+
+/* Reads a 64-bit integer, in network, big-endian, byte order */
+#define READ_UINT64(p)				\
+(  (((uint64_t) (p)[0]) << 56)			\
+ | (((uint64_t) (p)[1]) << 48)			\
+ | (((uint64_t) (p)[2]) << 40)			\
+ | (((uint64_t) (p)[3]) << 32)			\
+ | (((uint64_t) (p)[4]) << 24)			\
+ | (((uint64_t) (p)[5]) << 16)			\
+ | (((uint64_t) (p)[6]) << 8)			\
+ |  ((uint64_t) (p)[7]))
+
+#define WRITE_UINT64(p, i)			\
+do {						\
+  (p)[0] = ((i) >> 56) & 0xff;			\
+  (p)[1] = ((i) >> 48) & 0xff;			\
+  (p)[2] = ((i) >> 40) & 0xff;			\
+  (p)[3] = ((i) >> 32) & 0xff;			\
+  (p)[4] = ((i) >> 24) & 0xff;			\
+  (p)[5] = ((i) >> 16) & 0xff;			\
+  (p)[6] = ((i) >> 8) & 0xff;			\
+  (p)[7] = (i) & 0xff;				\
+} while(0)
+
+/* Reads a 32-bit integer, in network, big-endian, byte order */
+#define READ_UINT32(p)				\
+(  (((uint32_t) (p)[0]) << 24)			\
+ | (((uint32_t) (p)[1]) << 16)			\
+ | (((uint32_t) (p)[2]) << 8)			\
+ |  ((uint32_t) (p)[3]))
+
+#define WRITE_UINT32(p, i)			\
+do {						\
+  (p)[0] = ((i) >> 24) & 0xff;			\
+  (p)[1] = ((i) >> 16) & 0xff;			\
+  (p)[2] = ((i) >> 8) & 0xff;			\
+  (p)[3] = (i) & 0xff;				\
+} while(0)
+
+/* Analogous macros, for 24 and 16 bit numbers */
+#define READ_UINT24(p)				\
+(  (((uint32_t) (p)[0]) << 16)			\
+ | (((uint32_t) (p)[1]) << 8)			\
+ |  ((uint32_t) (p)[2]))
+
+#define WRITE_UINT24(p, i)			\
+do {						\
+  (p)[0] = ((i) >> 16) & 0xff;			\
+  (p)[1] = ((i) >> 8) & 0xff;			\
+  (p)[2] = (i) & 0xff;				\
+} while(0)
+
+#define READ_UINT16(p)				\
+(  (((uint32_t) (p)[0]) << 8)			\
+ |  ((uint32_t) (p)[1]))
+
+#define WRITE_UINT16(p, i)			\
+do {						\
+  (p)[0] = ((i) >> 8) & 0xff;			\
+  (p)[1] = (i) & 0xff;				\
+} while(0)
+
+/* And the other, little-endian, byteorder */
+#define LE_READ_UINT64(p)			\
+(  (((uint64_t) (p)[7]) << 56)			\
+ | (((uint64_t) (p)[6]) << 48)			\
+ | (((uint64_t) (p)[5]) << 40)			\
+ | (((uint64_t) (p)[4]) << 32)			\
+ | (((uint64_t) (p)[3]) << 24)			\
+ | (((uint64_t) (p)[2]) << 16)			\
+ | (((uint64_t) (p)[1]) << 8)			\
+ |  ((uint64_t) (p)[0]))
+
+#define LE_WRITE_UINT64(p, i)			\
+do {						\
+  (p)[7] = ((i) >> 56) & 0xff;			\
+  (p)[6] = ((i) >> 48) & 0xff;			\
+  (p)[5] = ((i) >> 40) & 0xff;			\
+  (p)[4] = ((i) >> 32) & 0xff;			\
+  (p)[3] = ((i) >> 24) & 0xff;			\
+  (p)[2] = ((i) >> 16) & 0xff;			\
+  (p)[1] = ((i) >> 8) & 0xff;			\
+  (p)[0] = (i) & 0xff;				\
+} while (0)
+
+#define LE_READ_UINT32(p)			\
+(  (((uint32_t) (p)[3]) << 24)			\
+ | (((uint32_t) (p)[2]) << 16)			\
+ | (((uint32_t) (p)[1]) << 8)			\
+ |  ((uint32_t) (p)[0]))
+
+#define LE_WRITE_UINT32(p, i)			\
+do {						\
+  (p)[3] = ((i) >> 24) & 0xff;			\
+  (p)[2] = ((i) >> 16) & 0xff;			\
+  (p)[1] = ((i) >> 8) & 0xff;			\
+  (p)[0] = (i) & 0xff;				\
+} while(0)
+
+/* Analogous macros, for 16 bit numbers */
+#define LE_READ_UINT16(p)			\
+  (  (((uint32_t) (p)[1]) << 8)			\
+     |  ((uint32_t) (p)[0]))
+
+#define LE_WRITE_UINT16(p, i)			\
+  do {						\
+    (p)[1] = ((i) >> 8) & 0xff;			\
+    (p)[0] = (i) & 0xff;			\
+  } while(0)
+
+/* Macro to make it easier to loop over several blocks. */
+#define FOR_BLOCKS(length, dst, src, blocksize)	\
+  assert( !((length) % (blocksize)));           \
+  for (; (length); ((length) -= (blocksize),	\
+		  (dst) += (blocksize),		\
+		  (src) += (blocksize)) )
+
+/* The masking of the right shift is needed to allow n == 0 (using
+   just 32 - n and 64 - n results in undefined behaviour). Most uses
+   of these macros use a constant and non-zero rotation count. */
+#define ROTL32(n,x) (((x)<<(n)) | ((x)>>((-(n)&31))))
+
+#define ROTL64(n,x) (((x)<<(n)) | ((x)>>((-(n))&63)))
+
+/* Requires that size > 0 */
+#define INCREMENT(size, ctr)			\
+  do {						\
+    unsigned increment_i = (size) - 1;		\
+    if (++(ctr)[increment_i] == 0)		\
+      while (increment_i > 0			\
+	     && ++(ctr)[--increment_i] == 0 )	\
+	;					\
+  } while (0)
+
+
+/* Helper macro for Merkle-Damgård hash functions. Assumes the context
+   structs includes the following fields:
+
+     uint8_t block[...];		// Buffer holding one block
+     unsigned int index;		// Index into block
+*/
+
+/* Currently used by sha512 (and sha384) only. */
+#define MD_INCR(ctx) ((ctx)->count_high += !++(ctx)->count_low)
+
+/* Takes the compression function f as argument. NOTE: also clobbers
+   length and data. */
+#define MD_UPDATE(ctx, length, data, f, incr)				\
+  do {									\
+    if ((ctx)->index)							\
+      {									\
+	/* Try to fill partial block */					\
+	unsigned __md_left = sizeof((ctx)->block) - (ctx)->index;	\
+	if ((length) < __md_left)					\
+	  {								\
+	    memcpy((ctx)->block + (ctx)->index, (data), (length));	\
+	    (ctx)->index += (length);					\
+	    goto __md_done; /* Finished */				\
+	  }								\
+	else								\
+	  {								\
+	    memcpy((ctx)->block + (ctx)->index, (data), __md_left);	\
+									\
+	    f((ctx), (ctx)->block);					\
+	    (incr);							\
+									\
+	    (data) += __md_left;					\
+	    (length) -= __md_left;					\
+	  }								\
+      }									\
+    while ((length) >= sizeof((ctx)->block))				\
+      {									\
+	f((ctx), (data));						\
+	(incr);								\
+									\
+	(data) += sizeof((ctx)->block);					\
+	(length) -= sizeof((ctx)->block);				\
+      }									\
+    memcpy ((ctx)->block, (data), (length));				\
+    (ctx)->index = (length);						\
+  __md_done:								\
+    ;									\
+  } while (0)
+
+/* Pads the block to a block boundary with the bit pattern 1 0*,
+   leaving size octets for the length field at the end. If needed,
+   compresses the block and starts a new one. */
+#define MD_PAD(ctx, size, f)						\
+  do {									\
+    unsigned __md_i;							\
+    __md_i = (ctx)->index;						\
+									\
+    /* Set the first char of padding to 0x80. This is safe since there	\
+       is always at least one byte free */				\
+									\
+    assert(__md_i < sizeof((ctx)->block));				\
+    (ctx)->block[__md_i++] = 0x80;					\
+									\
+    if (__md_i > (sizeof((ctx)->block) - (size)))			\
+      { /* No room for length in this block. Process it and		\
+	   pad with another one */					\
+	memset((ctx)->block + __md_i, 0, sizeof((ctx)->block) - __md_i); \
+									\
+	f((ctx), (ctx)->block);						\
+	__md_i = 0;							\
+      }									\
+    memset((ctx)->block + __md_i, 0,					\
+	   sizeof((ctx)->block) - (size) - __md_i);			\
+									\
+  } while (0)
+
+#endif /* NETTLE_MACROS_H_INCLUDED */
diff --git a/src/granger/src/nettle/md5-compress.c b/src/granger/src/nettle/md5-compress.c
new file mode 100644
index 0000000..b8dad3f
--- /dev/null
+++ b/src/granger/src/nettle/md5-compress.c
@@ -0,0 +1,174 @@
+/* md5-compress.c
+
+   The compression function for the md5 hash function.
+
+   Copyright (C) 2001, 2005 Niels Möller
+
+   This file is part of GNU Nettle.
+
+   GNU Nettle is free software: you can redistribute it and/or
+   modify it under the terms of either:
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or both in parallel, as here.
+
+   GNU Nettle 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
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see http://www.gnu.org/licenses/.
+*/
+
+/* Based on public domain code hacked by Colin Plumb, Andrew Kuchling, and
+ * Niels Möller. */
+
+
+#if HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#ifndef MD5_DEBUG
+# define MD5_DEBUG 0
+#endif
+
+#if MD5_DEBUG
+# include <stdio.h>
+# define DEBUG(i) \
+  fprintf(stderr, "%2d: %8x %8x %8x %8x\n", i, a, b, c, d)
+#else
+# define DEBUG(i)
+#endif
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "md5.h"
+
+#include "macros.h"
+
+/* A block, treated as a sequence of 32-bit words. */
+#define MD5_DATA_LENGTH 16
+
+/* MD5 functions */
+
+#define F1(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
+#define F2(x, y, z) F1((z), (x), (y))
+#define F3(x, y, z) ((x) ^ (y) ^ (z))
+#define F4(x, y, z) ((y) ^ ((x) | ~(z)))
+
+#define ROUND(f, w, x, y, z, data, s) \
+( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
+
+/* Perform the MD5 transformation on one full block of 16 32-bit
+ * words.
+ *
+ * Compresses 20 (_MD5_DIGEST_LENGTH + MD5_DATA_LENGTH) words into 4
+ * (_MD5_DIGEST_LENGTH) words. */
+
+void
+_nettle_md5_compress(uint32_t *digest, const uint8_t *input)
+{
+  uint32_t data[MD5_DATA_LENGTH];
+  uint32_t a, b, c, d;
+  unsigned i;
+
+  for (i = 0; i < MD5_DATA_LENGTH; i++, input += 4)
+    data[i] = LE_READ_UINT32(input);
+
+  a = digest[0];
+  b = digest[1];
+  c = digest[2];
+  d = digest[3];
+
+  DEBUG(-1);
+  ROUND(F1, a, b, c, d, data[ 0] + 0xd76aa478, 7); DEBUG(0);
+  ROUND(F1, d, a, b, c, data[ 1] + 0xe8c7b756, 12); DEBUG(1);
+  ROUND(F1, c, d, a, b, data[ 2] + 0x242070db, 17);
+  ROUND(F1, b, c, d, a, data[ 3] + 0xc1bdceee, 22);
+  ROUND(F1, a, b, c, d, data[ 4] + 0xf57c0faf, 7);
+  ROUND(F1, d, a, b, c, data[ 5] + 0x4787c62a, 12);
+  ROUND(F1, c, d, a, b, data[ 6] + 0xa8304613, 17);
+  ROUND(F1, b, c, d, a, data[ 7] + 0xfd469501, 22);
+  ROUND(F1, a, b, c, d, data[ 8] + 0x698098d8, 7);
+  ROUND(F1, d, a, b, c, data[ 9] + 0x8b44f7af, 12);
+  ROUND(F1, c, d, a, b, data[10] + 0xffff5bb1, 17);
+  ROUND(F1, b, c, d, a, data[11] + 0x895cd7be, 22);
+  ROUND(F1, a, b, c, d, data[12] + 0x6b901122, 7);
+  ROUND(F1, d, a, b, c, data[13] + 0xfd987193, 12);
+  ROUND(F1, c, d, a, b, data[14] + 0xa679438e, 17);
+  ROUND(F1, b, c, d, a, data[15] + 0x49b40821, 22); DEBUG(15);
+
+  ROUND(F2, a, b, c, d, data[ 1] + 0xf61e2562, 5); DEBUG(16);
+  ROUND(F2, d, a, b, c, data[ 6] + 0xc040b340, 9); DEBUG(17);
+  ROUND(F2, c, d, a, b, data[11] + 0x265e5a51, 14);
+  ROUND(F2, b, c, d, a, data[ 0] + 0xe9b6c7aa, 20);
+  ROUND(F2, a, b, c, d, data[ 5] + 0xd62f105d, 5);
+  ROUND(F2, d, a, b, c, data[10] + 0x02441453, 9);
+  ROUND(F2, c, d, a, b, data[15] + 0xd8a1e681, 14);
+  ROUND(F2, b, c, d, a, data[ 4] + 0xe7d3fbc8, 20);
+  ROUND(F2, a, b, c, d, data[ 9] + 0x21e1cde6, 5);
+  ROUND(F2, d, a, b, c, data[14] + 0xc33707d6, 9);
+  ROUND(F2, c, d, a, b, data[ 3] + 0xf4d50d87, 14);
+  ROUND(F2, b, c, d, a, data[ 8] + 0x455a14ed, 20);
+  ROUND(F2, a, b, c, d, data[13] + 0xa9e3e905, 5);
+  ROUND(F2, d, a, b, c, data[ 2] + 0xfcefa3f8, 9);
+  ROUND(F2, c, d, a, b, data[ 7] + 0x676f02d9, 14);
+  ROUND(F2, b, c, d, a, data[12] + 0x8d2a4c8a, 20); DEBUG(31);
+
+  ROUND(F3, a, b, c, d, data[ 5] + 0xfffa3942, 4); DEBUG(32);
+  ROUND(F3, d, a, b, c, data[ 8] + 0x8771f681, 11); DEBUG(33);
+  ROUND(F3, c, d, a, b, data[11] + 0x6d9d6122, 16);
+  ROUND(F3, b, c, d, a, data[14] + 0xfde5380c, 23);
+  ROUND(F3, a, b, c, d, data[ 1] + 0xa4beea44, 4);
+  ROUND(F3, d, a, b, c, data[ 4] + 0x4bdecfa9, 11);
+  ROUND(F3, c, d, a, b, data[ 7] + 0xf6bb4b60, 16);
+  ROUND(F3, b, c, d, a, data[10] + 0xbebfbc70, 23);
+  ROUND(F3, a, b, c, d, data[13] + 0x289b7ec6, 4);
+  ROUND(F3, d, a, b, c, data[ 0] + 0xeaa127fa, 11);
+  ROUND(F3, c, d, a, b, data[ 3] + 0xd4ef3085, 16);
+  ROUND(F3, b, c, d, a, data[ 6] + 0x04881d05, 23);
+  ROUND(F3, a, b, c, d, data[ 9] + 0xd9d4d039, 4);
+  ROUND(F3, d, a, b, c, data[12] + 0xe6db99e5, 11);
+  ROUND(F3, c, d, a, b, data[15] + 0x1fa27cf8, 16);
+  ROUND(F3, b, c, d, a, data[ 2] + 0xc4ac5665, 23); DEBUG(47);
+
+  ROUND(F4, a, b, c, d, data[ 0] + 0xf4292244, 6); DEBUG(48);
+  ROUND(F4, d, a, b, c, data[ 7] + 0x432aff97, 10); DEBUG(49);
+  ROUND(F4, c, d, a, b, data[14] + 0xab9423a7, 15);
+  ROUND(F4, b, c, d, a, data[ 5] + 0xfc93a039, 21);
+  ROUND(F4, a, b, c, d, data[12] + 0x655b59c3, 6);
+  ROUND(F4, d, a, b, c, data[ 3] + 0x8f0ccc92, 10);
+  ROUND(F4, c, d, a, b, data[10] + 0xffeff47d, 15);
+  ROUND(F4, b, c, d, a, data[ 1] + 0x85845dd1, 21);
+  ROUND(F4, a, b, c, d, data[ 8] + 0x6fa87e4f, 6);
+  ROUND(F4, d, a, b, c, data[15] + 0xfe2ce6e0, 10);
+  ROUND(F4, c, d, a, b, data[ 6] + 0xa3014314, 15);
+  ROUND(F4, b, c, d, a, data[13] + 0x4e0811a1, 21);
+  ROUND(F4, a, b, c, d, data[ 4] + 0xf7537e82, 6);
+  ROUND(F4, d, a, b, c, data[11] + 0xbd3af235, 10);
+  ROUND(F4, c, d, a, b, data[ 2] + 0x2ad7d2bb, 15);
+  ROUND(F4, b, c, d, a, data[ 9] + 0xeb86d391, 21); DEBUG(63);
+
+  digest[0] += a;
+  digest[1] += b;
+  digest[2] += c;
+  digest[3] += d;
+#if MD5_DEBUG
+  fprintf(stderr, "99: %8x %8x %8x %8x\n",
+	  digest[0], digest[1], digest[2], digest[3]);
+#endif
+  
+}
diff --git a/src/granger/src/nettle/md5.c b/src/granger/src/nettle/md5.c
new file mode 100644
index 0000000..97a5245
--- /dev/null
+++ b/src/granger/src/nettle/md5.c
@@ -0,0 +1,93 @@
+/* md5.c
+
+   The MD5 hash function, described in RFC 1321.
+
+   Copyright (C) 2001 Niels Möller
+
+   This file is part of GNU Nettle.
+
+   GNU Nettle is free software: you can redistribute it and/or
+   modify it under the terms of either:
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or both in parallel, as here.
+
+   GNU Nettle 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
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see http://www.gnu.org/licenses/.
+*/
+
+/* Based on public domain code hacked by Colin Plumb, Andrew Kuchling, and
+ * Niels Möller. */
+
+#if HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <assert.h>
+#include <string.h>
+
+#include "md5.h"
+
+#include "macros.h"
+#include "nettle-write.h"
+
+void
+md5_init(struct md5_ctx *ctx)
+{
+  const uint32_t iv[_MD5_DIGEST_LENGTH] =
+    {
+      0x67452301,
+      0xefcdab89,
+      0x98badcfe,
+      0x10325476,
+    };
+  memcpy(ctx->state, iv, sizeof(ctx->state));
+  ctx->count = 0;
+  ctx->index = 0;
+}
+
+#define COMPRESS(ctx, data) (_nettle_md5_compress((ctx)->state, (data)))
+
+void
+md5_update(struct md5_ctx *ctx,
+	   size_t length,
+	   const uint8_t *data)
+{
+  MD_UPDATE(ctx, length, data, COMPRESS, ctx->count++);
+}
+
+void
+md5_digest(struct md5_ctx *ctx,
+	   size_t length,
+	   uint8_t *digest)
+{
+  uint64_t bit_count;
+  
+  assert(length <= MD5_DIGEST_SIZE);
+
+  MD_PAD(ctx, 8, COMPRESS);
+
+  /* There are 512 = 2^9 bits in one block */
+  bit_count = (ctx->count << 9) | (ctx->index << 3);
+
+  LE_WRITE_UINT64(ctx->block + (MD5_BLOCK_SIZE - 8), bit_count);
+  _nettle_md5_compress(ctx->state, ctx->block);
+
+  _nettle_write_le32(length, digest, ctx->state);
+  md5_init(ctx);
+}
diff --git a/src/granger/src/nettle/md5.h b/src/granger/src/nettle/md5.h
new file mode 100644
index 0000000..79304bc
--- /dev/null
+++ b/src/granger/src/nettle/md5.h
@@ -0,0 +1,86 @@
+/* md5.h
+
+   The MD5 hash function, described in RFC 1321.
+
+   Copyright (C) 2001 Niels Möller
+
+   This file is part of GNU Nettle.
+
+   GNU Nettle is free software: you can redistribute it and/or
+   modify it under the terms of either:
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or both in parallel, as here.
+
+   GNU Nettle 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
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see http://www.gnu.org/licenses/.
+*/
+ 
+#ifndef NETTLE_MD5_H_INCLUDED
+#define NETTLE_MD5_H_INCLUDED
+
+#include "nettle-types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Name mangling */
+#define md5_init nettle_md5_init
+#define md5_update nettle_md5_update
+#define md5_digest nettle_md5_digest
+
+#define MD5_DIGEST_SIZE 16
+#define MD5_BLOCK_SIZE 64
+/* For backwards compatibility */
+#define MD5_DATA_SIZE MD5_BLOCK_SIZE
+
+/* Digest is kept internally as 4 32-bit words. */
+#define _MD5_DIGEST_LENGTH 4
+
+struct md5_ctx
+{
+  uint32_t state[_MD5_DIGEST_LENGTH];
+  uint64_t count;               /* Block count */
+  uint8_t block[MD5_BLOCK_SIZE]; /* Block buffer */
+  unsigned index;               /* Into buffer */
+};
+
+void
+md5_init(struct md5_ctx *ctx);
+
+void
+md5_update(struct md5_ctx *ctx,
+	   size_t length,
+	   const uint8_t *data);
+
+void
+md5_digest(struct md5_ctx *ctx,
+	   size_t length,
+	   uint8_t *digest);
+
+/* Internal compression function. STATE points to 4 uint32_t words,
+   and DATA points to 64 bytes of input data, possibly unaligned. */
+void
+_nettle_md5_compress(uint32_t *state, const uint8_t *data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NETTLE_MD5_H_INCLUDED */
diff --git a/src/granger/src/nettle/nettle-stdint.h b/src/granger/src/nettle/nettle-stdint.h
new file mode 100644
index 0000000..3298fa6
--- /dev/null
+++ b/src/granger/src/nettle/nettle-stdint.h
@@ -0,0 +1,6 @@
+#ifndef __NETTLE_STDINT_H

+#define __NETTLE_STDINT_H

+

+#include <stdint.h>

+

+#endif /* __NETTLE_STDINT_H */

diff --git a/src/granger/src/nettle/nettle-types.h b/src/granger/src/nettle/nettle-types.h
new file mode 100644
index 0000000..8f77ea9
--- /dev/null
+++ b/src/granger/src/nettle/nettle-types.h
@@ -0,0 +1,110 @@
+/* nettle-types.h
+
+   Copyright (C) 2005, 2014 Niels Möller
+
+   This file is part of GNU Nettle.
+
+   GNU Nettle is free software: you can redistribute it and/or
+   modify it under the terms of either:
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or both in parallel, as here.
+
+   GNU Nettle 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
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see http://www.gnu.org/licenses/.
+*/
+
+#ifndef NETTLE_TYPES_H
+#define NETTLE_TYPES_H
+
+/* For size_t */
+#include <stddef.h>
+
+/* Pretend these types always exists. Nettle doesn't use them. */
+#define _STDINT_HAVE_INT_FAST32_T 1
+#include "nettle-stdint.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* An aligned 16-byte block. */
+union nettle_block16
+{
+  uint8_t b[16];
+  unsigned long w[16 / sizeof(unsigned long)];
+};
+
+/* Randomness. Used by key generation and dsa signature creation. */
+typedef void nettle_random_func(void *ctx,
+				size_t length, uint8_t *dst);
+
+/* Progress report function, mainly for key generation. */
+typedef void nettle_progress_func(void *ctx, int c);
+
+/* Realloc function, used by struct nettle_buffer. */
+typedef void *nettle_realloc_func(void *ctx, void *p, size_t length);
+
+/* Ciphers */
+typedef void nettle_set_key_func(void *ctx, const uint8_t *key);
+
+/* For block ciphers, const context. */
+typedef void nettle_cipher_func(const void *ctx,
+				size_t length, uint8_t *dst,
+				const uint8_t *src);
+
+
+/* Uses a void * for cipher contexts. Used for crypt operations where
+   the internal state changes during the encryption. */
+typedef void nettle_crypt_func(void *ctx,
+			       size_t length, uint8_t *dst,
+			       const uint8_t *src);
+
+/* Hash algorithms */
+typedef void nettle_hash_init_func(void *ctx);
+typedef void nettle_hash_update_func(void *ctx,
+				     size_t length,
+				     const uint8_t *src);
+typedef void nettle_hash_digest_func(void *ctx,
+				     size_t length, uint8_t *dst);
+
+/* ASCII armor codecs. NOTE: Experimental and subject to change. */
+
+typedef size_t nettle_armor_length_func(size_t length);
+typedef void nettle_armor_init_func(void *ctx);
+
+typedef size_t nettle_armor_encode_update_func(void *ctx,
+					       uint8_t *dst,
+					       size_t src_length,
+					       const uint8_t *src);
+
+typedef size_t nettle_armor_encode_final_func(void *ctx, uint8_t *dst);
+
+typedef int nettle_armor_decode_update_func(void *ctx,
+					    size_t *dst_length,
+					    uint8_t *dst,
+					    size_t src_length,
+					    const uint8_t *src);
+
+typedef int nettle_armor_decode_final_func(void *ctx);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NETTLE_TYPES_H */
diff --git a/src/granger/src/nettle/nettle-write.h b/src/granger/src/nettle/nettle-write.h
new file mode 100644
index 0000000..54152bd
--- /dev/null
+++ b/src/granger/src/nettle/nettle-write.h
@@ -0,0 +1,58 @@
+/* nettle-write.h
+
+   Internal functions to write out word-sized data to byte arrays.
+
+   Copyright (C) 2010 Niels Möller
+
+   This file is part of GNU Nettle.
+
+   GNU Nettle is free software: you can redistribute it and/or
+   modify it under the terms of either:
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or both in parallel, as here.
+
+   GNU Nettle 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
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see http://www.gnu.org/licenses/.
+*/
+
+#ifndef NETTLE_WRITE_H_INCLUDED
+#define NETTLE_WRITE_H_INCLUDED
+
+/* For size_t */
+#include <stddef.h>
+
+#include "nettle-stdint.h"
+
+/* Write the word array at SRC to the byte array at DST, using little
+   endian (le) or big endian (be) byte order, and truncating the
+   result to LENGTH bytes. */
+
+/* FIXME: Use a macro shortcut to memcpy for native endianness. */
+void
+_nettle_write_be32(size_t length, uint8_t *dst,
+		   uint32_t *src);
+void
+_nettle_write_le32(size_t length, uint8_t *dst,
+		   uint32_t *src);
+
+void
+_nettle_write_le64(size_t length, uint8_t *dst,
+		   uint64_t *src);
+
+#endif /* NETTLE_WRITE_H_INCLUDED */
diff --git a/src/granger/src/nettle/sha2.h b/src/granger/src/nettle/sha2.h
new file mode 100644
index 0000000..d0426d7
--- /dev/null
+++ b/src/granger/src/nettle/sha2.h
@@ -0,0 +1,206 @@
+/* sha2.h
+
+   The sha2 family of hash functions.
+
+   Copyright (C) 2001, 2012 Niels Möller
+
+   This file is part of GNU Nettle.
+
+   GNU Nettle is free software: you can redistribute it and/or
+   modify it under the terms of either:
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or both in parallel, as here.
+
+   GNU Nettle 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
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see http://www.gnu.org/licenses/.
+*/
+ 
+#ifndef NETTLE_SHA2_H_INCLUDED
+#define NETTLE_SHA2_H_INCLUDED
+
+#include "nettle-types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Name mangling */
+#define sha224_init nettle_sha224_init
+#define sha224_digest nettle_sha224_digest
+#define sha256_init nettle_sha256_init
+#define sha256_update nettle_sha256_update
+#define sha256_digest nettle_sha256_digest
+#define sha384_init nettle_sha384_init
+#define sha384_digest nettle_sha384_digest
+#define sha512_init nettle_sha512_init
+#define sha512_update nettle_sha512_update
+#define sha512_digest nettle_sha512_digest
+#define sha512_224_init   nettle_sha512_224_init
+#define sha512_224_digest nettle_sha512_224_digest
+#define sha512_256_init   nettle_sha512_256_init
+#define sha512_256_digest nettle_sha512_256_digest
+
+/* For backwards compatibility */
+#define SHA224_DATA_SIZE SHA256_BLOCK_SIZE
+#define SHA256_DATA_SIZE SHA256_BLOCK_SIZE
+#define SHA512_DATA_SIZE SHA512_BLOCK_SIZE
+#define SHA384_DATA_SIZE SHA512_BLOCK_SIZE
+
+/* SHA256 */
+
+#define SHA256_DIGEST_SIZE 32
+#define SHA256_BLOCK_SIZE 64
+
+/* Digest is kept internally as 8 32-bit words. */
+#define _SHA256_DIGEST_LENGTH 8
+
+struct sha256_ctx
+{
+  uint32_t state[_SHA256_DIGEST_LENGTH];    /* State variables */
+  uint64_t count;                           /* 64-bit block count */
+  uint8_t block[SHA256_BLOCK_SIZE];          /* SHA256 data buffer */
+  unsigned int index;                       /* index into buffer */
+};
+
+void
+sha256_init(struct sha256_ctx *ctx);
+
+void
+sha256_update(struct sha256_ctx *ctx,
+	      size_t length,
+	      const uint8_t *data);
+
+void
+sha256_digest(struct sha256_ctx *ctx,
+	      size_t length,
+	      uint8_t *digest);
+
+/* Internal compression function. STATE points to 8 uint32_t words,
+   DATA points to 64 bytes of input data, possibly unaligned, and K
+   points to the table of constants. */
+void
+_nettle_sha256_compress(uint32_t *state, const uint8_t *data, const uint32_t *k);
+
+
+/* SHA224, a truncated SHA256 with different initial state. */
+
+#define SHA224_DIGEST_SIZE 28
+#define SHA224_BLOCK_SIZE SHA256_BLOCK_SIZE
+#define sha224_ctx sha256_ctx
+
+void
+sha224_init(struct sha256_ctx *ctx);
+
+#define sha224_update nettle_sha256_update
+
+void
+sha224_digest(struct sha256_ctx *ctx,
+	      size_t length,
+	      uint8_t *digest);
+
+
+/* SHA512 */
+
+#define SHA512_DIGEST_SIZE 64
+#define SHA512_BLOCK_SIZE 128
+
+/* Digest is kept internally as 8 64-bit words. */
+#define _SHA512_DIGEST_LENGTH 8
+
+struct sha512_ctx
+{
+  uint64_t state[_SHA512_DIGEST_LENGTH];    /* State variables */
+  uint64_t count_low, count_high;           /* 128-bit block count */
+  uint8_t block[SHA512_BLOCK_SIZE];          /* SHA512 data buffer */
+  unsigned int index;                       /* index into buffer */
+};
+
+void
+sha512_init(struct sha512_ctx *ctx);
+
+void
+sha512_update(struct sha512_ctx *ctx,
+	      size_t length,
+	      const uint8_t *data);
+
+void
+sha512_digest(struct sha512_ctx *ctx,
+	      size_t length,
+	      uint8_t *digest);
+
+/* Internal compression function. STATE points to 8 uint64_t words,
+   DATA points to 128 bytes of input data, possibly unaligned, and K
+   points to the table of constants. */
+void
+_nettle_sha512_compress(uint64_t *state, const uint8_t *data, const uint64_t *k);
+
+
+/* SHA384, a truncated SHA512 with different initial state. */
+
+#define SHA384_DIGEST_SIZE 48
+#define SHA384_BLOCK_SIZE SHA512_BLOCK_SIZE
+#define sha384_ctx sha512_ctx
+
+void
+sha384_init(struct sha512_ctx *ctx);
+
+#define sha384_update nettle_sha512_update
+
+void
+sha384_digest(struct sha512_ctx *ctx,
+	      size_t length,
+	      uint8_t *digest);
+
+
+/* SHA512_224 and SHA512_256, two truncated versions of SHA512 
+   with different initial states. */
+
+#define SHA512_224_DIGEST_SIZE 28
+#define SHA512_224_BLOCK_SIZE SHA512_BLOCK_SIZE
+#define sha512_224_ctx sha512_ctx
+
+void
+sha512_224_init(struct sha512_224_ctx *ctx);
+
+#define sha512_224_update nettle_sha512_update
+
+void
+sha512_224_digest(struct sha512_224_ctx *ctx,
+                  size_t length,
+                  uint8_t *digest);
+
+#define SHA512_256_DIGEST_SIZE 32
+#define SHA512_256_BLOCK_SIZE SHA512_BLOCK_SIZE
+#define sha512_256_ctx sha512_ctx
+
+void
+sha512_256_init(struct sha512_256_ctx *ctx);
+
+#define sha512_256_update nettle_sha512_update
+
+void
+sha512_256_digest(struct sha512_256_ctx *ctx,
+                  size_t length,
+                  uint8_t *digest);
+  
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NETTLE_SHA2_H_INCLUDED */
diff --git a/src/granger/src/nettle/sha256-compress.c b/src/granger/src/nettle/sha256-compress.c
new file mode 100644
index 0000000..8b82d70
--- /dev/null
+++ b/src/granger/src/nettle/sha256-compress.c
@@ -0,0 +1,199 @@
+/* sha256-compress.c
+
+   The compression function of the sha256 hash function.
+
+   Copyright (C) 2001, 2010 Niels Möller
+
+   This file is part of GNU Nettle.
+
+   GNU Nettle is free software: you can redistribute it and/or
+   modify it under the terms of either:
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or both in parallel, as here.
+
+   GNU Nettle 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
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see http://www.gnu.org/licenses/.
+*/
+
+#if HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#ifndef SHA256_DEBUG
+# define SHA256_DEBUG 0
+#endif
+
+#if SHA256_DEBUG
+# include <stdio.h>
+# define DEBUG(i) \
+  fprintf(stderr, "%2d: %8x %8x %8x %8x %8x %8x %8x %8x\n", \
+	  i, A, B, C, D ,E, F, G, H)
+#else
+# define DEBUG(i)
+#endif
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "sha2.h"
+
+#include "macros.h"
+
+/* A block, treated as a sequence of 32-bit words. */
+#define SHA256_DATA_LENGTH 16
+
+/* The SHA256 functions. The Choice function is the same as the SHA1
+   function f1, and the majority function is the same as the SHA1 f3
+   function. They can be optimized to save one boolean operation each
+   - thanks to Rich Schroeppel, rcs@cs.arizona.edu for discovering
+   this */
+
+/* #define Choice(x,y,z) ( ( (x) & (y) ) | ( ~(x) & (z) ) ) */
+#define Choice(x,y,z)   ( (z) ^ ( (x) & ( (y) ^ (z) ) ) ) 
+/* #define Majority(x,y,z) ( ((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)) ) */
+#define Majority(x,y,z) ( ((x) & (y)) ^ ((z) & ((x) ^ (y))) )
+
+#define S0(x) (ROTL32(30,(x)) ^ ROTL32(19,(x)) ^ ROTL32(10,(x))) 
+#define S1(x) (ROTL32(26,(x)) ^ ROTL32(21,(x)) ^ ROTL32(7,(x)))
+
+#define s0(x) (ROTL32(25,(x)) ^ ROTL32(14,(x)) ^ ((x) >> 3))
+#define s1(x) (ROTL32(15,(x)) ^ ROTL32(13,(x)) ^ ((x) >> 10))
+
+/* The initial expanding function.  The hash function is defined over an
+   64-word expanded input array W, where the first 16 are copies of the input
+   data, and the remaining 64 are defined by
+
+        W[ t ] = s1(W[t-2]) + W[t-7] + s0(W[i-15]) + W[i-16]
+
+   This implementation generates these values on the fly in a circular
+   buffer - thanks to Colin Plumb, colin@nyx10.cs.du.edu for this
+   optimization.
+*/
+
+#define EXPAND(W,i) \
+( W[(i) & 15 ] += (s1(W[((i)-2) & 15]) + W[((i)-7) & 15] + s0(W[((i)-15) & 15])) )
+
+/* The prototype SHA sub-round.  The fundamental sub-round is:
+
+        T1 = h + S1(e) + Choice(e,f,g) + K[t] + W[t]
+	T2 = S0(a) + Majority(a,b,c)
+	a' = T1+T2
+	b' = a
+	c' = b
+	d' = c
+	e' = d + T1
+	f' = e
+	g' = f
+	h' = g
+
+   but this is implemented by unrolling the loop 8 times and renaming
+   the variables
+   ( h, a, b, c, d, e, f, g ) = ( a, b, c, d, e, f, g, h ) each
+   iteration. */
+
+/* It's crucial that DATA is only used once, as that argument will
+ * have side effects. */
+#define ROUND(a,b,c,d,e,f,g,h,k,data) do {	\
+    h += S1(e) + Choice(e,f,g) + k + data;	\
+    d += h;					\
+    h += S0(a) + Majority(a,b,c);		\
+  } while (0)
+
+/* For fat builds */
+#if HAVE_NATIVE_sha256_compress
+void
+_nettle_sha256_compress_c(uint32_t *state, const uint8_t *input, const uint32_t *k);
+#define _nettle_sha256_compress _nettle_sha256_compress_c
+#endif
+
+void
+_nettle_sha256_compress(uint32_t *state, const uint8_t *input, const uint32_t *k)
+{
+  uint32_t data[SHA256_DATA_LENGTH];
+  uint32_t A, B, C, D, E, F, G, H;     /* Local vars */
+  unsigned i;
+  uint32_t *d;
+
+  for (i = 0; i < SHA256_DATA_LENGTH; i++, input+= 4)
+    {
+      data[i] = READ_UINT32(input);
+    }
+
+  /* Set up first buffer and local data buffer */
+  A = state[0];
+  B = state[1];
+  C = state[2];
+  D = state[3];
+  E = state[4];
+  F = state[5];
+  G = state[6];
+  H = state[7];
+  
+  /* Heavy mangling */
+  /* First 16 subrounds that act on the original data */
+
+  DEBUG(-1);
+  for (i = 0, d = data; i<16; i+=8, k += 8, d+= 8)
+    {
+      ROUND(A, B, C, D, E, F, G, H, k[0], d[0]); DEBUG(i);
+      ROUND(H, A, B, C, D, E, F, G, k[1], d[1]); DEBUG(i+1);
+      ROUND(G, H, A, B, C, D, E, F, k[2], d[2]);
+      ROUND(F, G, H, A, B, C, D, E, k[3], d[3]);
+      ROUND(E, F, G, H, A, B, C, D, k[4], d[4]);
+      ROUND(D, E, F, G, H, A, B, C, k[5], d[5]);
+      ROUND(C, D, E, F, G, H, A, B, k[6], d[6]); DEBUG(i+6);
+      ROUND(B, C, D, E, F, G, H, A, k[7], d[7]); DEBUG(i+7);
+    }
+  
+  for (; i<64; i += 16, k+= 16)
+    {
+      ROUND(A, B, C, D, E, F, G, H, k[ 0], EXPAND(data,  0)); DEBUG(i);
+      ROUND(H, A, B, C, D, E, F, G, k[ 1], EXPAND(data,  1)); DEBUG(i+1);
+      ROUND(G, H, A, B, C, D, E, F, k[ 2], EXPAND(data,  2)); DEBUG(i+2);
+      ROUND(F, G, H, A, B, C, D, E, k[ 3], EXPAND(data,  3)); DEBUG(i+3);
+      ROUND(E, F, G, H, A, B, C, D, k[ 4], EXPAND(data,  4)); DEBUG(i+4);
+      ROUND(D, E, F, G, H, A, B, C, k[ 5], EXPAND(data,  5)); DEBUG(i+5);
+      ROUND(C, D, E, F, G, H, A, B, k[ 6], EXPAND(data,  6)); DEBUG(i+6);
+      ROUND(B, C, D, E, F, G, H, A, k[ 7], EXPAND(data,  7)); DEBUG(i+7);
+      ROUND(A, B, C, D, E, F, G, H, k[ 8], EXPAND(data,  8)); DEBUG(i+8);
+      ROUND(H, A, B, C, D, E, F, G, k[ 9], EXPAND(data,  9)); DEBUG(i+9);
+      ROUND(G, H, A, B, C, D, E, F, k[10], EXPAND(data, 10)); DEBUG(i+10);
+      ROUND(F, G, H, A, B, C, D, E, k[11], EXPAND(data, 11)); DEBUG(i+11);
+      ROUND(E, F, G, H, A, B, C, D, k[12], EXPAND(data, 12)); DEBUG(i+12);
+      ROUND(D, E, F, G, H, A, B, C, k[13], EXPAND(data, 13)); DEBUG(i+13);
+      ROUND(C, D, E, F, G, H, A, B, k[14], EXPAND(data, 14)); DEBUG(i+14);
+      ROUND(B, C, D, E, F, G, H, A, k[15], EXPAND(data, 15)); DEBUG(i+15);
+    }
+
+  /* Update state */
+  state[0] += A;
+  state[1] += B;
+  state[2] += C;
+  state[3] += D;
+  state[4] += E;
+  state[5] += F;
+  state[6] += G;
+  state[7] += H;
+#if SHA256_DEBUG
+  fprintf(stderr, "99: %8x %8x %8x %8x %8x %8x %8x %8x\n",
+	  state[0], state[1], state[2], state[3],
+	  state[4], state[5], state[6], state[7]);
+#endif
+}
diff --git a/src/granger/src/nettle/sha256.c b/src/granger/src/nettle/sha256.c
new file mode 100644
index 0000000..0cb3559
--- /dev/null
+++ b/src/granger/src/nettle/sha256.c
@@ -0,0 +1,162 @@
+/* sha256.c
+
+   The sha256 hash function.
+   See http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
+
+   Copyright (C) 2001 Niels Möller
+
+   This file is part of GNU Nettle.
+
+   GNU Nettle is free software: you can redistribute it and/or
+   modify it under the terms of either:
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or both in parallel, as here.
+
+   GNU Nettle 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
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see http://www.gnu.org/licenses/.
+*/
+
+/* Modelled after the sha1.c code by Peter Gutmann. */
+
+#if HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "sha2.h"
+
+#include "macros.h"
+#include "nettle-write.h"
+
+/* Generated by the shadata program. */
+static const uint32_t
+K[64] =
+{
+  0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL, 
+  0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL, 
+  0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL, 
+  0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 0xc19bf174UL, 
+  0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL, 
+  0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL, 
+  0x983e5152UL, 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL, 
+  0xc6e00bf3UL, 0xd5a79147UL, 0x06ca6351UL, 0x14292967UL, 
+  0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL, 0x53380d13UL, 
+  0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL, 
+  0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL, 
+  0xd192e819UL, 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, 
+  0x19a4c116UL, 0x1e376c08UL, 0x2748774cUL, 0x34b0bcb5UL, 
+  0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL, 0x682e6ff3UL, 
+  0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL, 
+  0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL, 
+};
+
+#define COMPRESS(ctx, data) (_nettle_sha256_compress((ctx)->state, (data), K))
+
+/* Initialize the SHA values */
+
+void
+sha256_init(struct sha256_ctx *ctx)
+{
+  /* Initial values, also generated by the shadata program. */
+  static const uint32_t H0[_SHA256_DIGEST_LENGTH] =
+  {
+    0x6a09e667UL, 0xbb67ae85UL, 0x3c6ef372UL, 0xa54ff53aUL, 
+    0x510e527fUL, 0x9b05688cUL, 0x1f83d9abUL, 0x5be0cd19UL, 
+  };
+
+  memcpy(ctx->state, H0, sizeof(H0));
+
+  /* Initialize bit count */
+  ctx->count = 0;
+  
+  /* Initialize buffer */
+  ctx->index = 0;
+}
+
+void
+sha256_update(struct sha256_ctx *ctx,
+	      size_t length, const uint8_t *data)
+{
+  MD_UPDATE (ctx, length, data, COMPRESS, ctx->count++);
+}
+
+static void
+sha256_write_digest(struct sha256_ctx *ctx,
+		    size_t length,
+		    uint8_t *digest)
+{
+  uint64_t bit_count;
+
+  assert(length <= SHA256_DIGEST_SIZE);
+
+  MD_PAD(ctx, 8, COMPRESS);
+
+  /* There are 512 = 2^9 bits in one block */  
+  bit_count = (ctx->count << 9) | (ctx->index << 3);
+
+  /* This is slightly inefficient, as the numbers are converted to
+     big-endian format, and will be converted back by the compression
+     function. It's probably not worth the effort to fix this. */
+  WRITE_UINT64(ctx->block + (SHA256_BLOCK_SIZE - 8), bit_count);
+  COMPRESS(ctx, ctx->block);
+
+  _nettle_write_be32(length, digest, ctx->state);
+}
+
+void
+sha256_digest(struct sha256_ctx *ctx,
+	      size_t length,
+	      uint8_t *digest)
+{
+  sha256_write_digest(ctx, length, digest);
+  sha256_init(ctx);
+}
+
+/* sha224 variant. */
+
+void
+sha224_init(struct sha256_ctx *ctx)
+{
+  /* Initial values. Low 32 bits of the initial values for sha384. */
+  static const uint32_t H0[_SHA256_DIGEST_LENGTH] =
+  {
+    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,
+    0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,
+  };
+
+  memcpy(ctx->state, H0, sizeof(H0));
+
+  /* Initialize bit count */
+  ctx->count = 0;
+  
+  /* Initialize buffer */
+  ctx->index = 0;
+}
+
+void
+sha224_digest(struct sha256_ctx *ctx,
+	      size_t length,
+	      uint8_t *digest)
+{
+  sha256_write_digest(ctx, length, digest);
+  sha224_init(ctx);
+}
diff --git a/src/granger/src/nettle/version.h b/src/granger/src/nettle/version.h
new file mode 100644
index 0000000..3a1d20c
--- /dev/null
+++ b/src/granger/src/nettle/version.h
@@ -0,0 +1,58 @@
+/* version.h
+
+   Information about library version.
+
+   Copyright (C) 2015 Red Hat, Inc.
+   Copyright (C) 2015 Niels Möller
+
+   This file is part of GNU Nettle.
+
+   GNU Nettle is free software: you can redistribute it and/or
+   modify it under the terms of either:
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or both in parallel, as here.
+
+   GNU Nettle 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
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see http://www.gnu.org/licenses/.
+*/
+
+#ifndef NETTLE_VERSION_H_INCLUDED
+#define NETTLE_VERSION_H_INCLUDED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Individual version numbers in decimal */
+#define NETTLE_VERSION_MAJOR 3
+#define NETTLE_VERSION_MINOR 3
+
+#define NETTLE_USE_MINI_GMP 1
+
+/* We need a preprocessor constant for GMP_NUMB_BITS, simply using
+   sizeof(mp_limb_t) * CHAR_BIT is not good enough. */
+#if NETTLE_USE_MINI_GMP
+# define GMP_NUMB_BITS (sizeof(unsigned long) * 8)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NETTLE_VERSION_H_INCLUDED */
diff --git a/src/granger/src/nettle/write-be32.c b/src/granger/src/nettle/write-be32.c
new file mode 100644
index 0000000..7d68905
--- /dev/null
+++ b/src/granger/src/nettle/write-be32.c
@@ -0,0 +1,77 @@
+/* write-be32.c
+
+   Copyright (C) 2001 Niels Möller
+
+   This file is part of GNU Nettle.
+
+   GNU Nettle is free software: you can redistribute it and/or
+   modify it under the terms of either:
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or both in parallel, as here.
+
+   GNU Nettle 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
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see http://www.gnu.org/licenses/.
+*/
+
+#if HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdlib.h>
+
+#include "nettle-write.h"
+
+#include "macros.h"
+
+void
+_nettle_write_be32(size_t length, uint8_t *dst,
+		   uint32_t *src)
+{
+  size_t i;
+  size_t words;
+  unsigned leftover;
+  
+  words = length / 4;
+  leftover = length % 4;
+
+  for (i = 0; i < words; i++, dst += 4)
+    WRITE_UINT32(dst, src[i]);
+
+  if (leftover)
+    {
+      uint32_t word;
+      unsigned j = leftover;
+      
+      word = src[i];
+      
+      switch (leftover)
+	{
+	default:
+	  abort();
+	case 3:
+	  dst[--j] = (word >> 8) & 0xff;
+	  /* Fall through */
+	case 2:
+	  dst[--j] = (word >> 16) & 0xff;
+	  /* Fall through */
+	case 1:
+	  dst[--j] = (word >> 24) & 0xff;
+	}
+    }
+}
diff --git a/src/granger/src/nettle/write-le32.c b/src/granger/src/nettle/write-le32.c
new file mode 100644
index 0000000..d44eb24
--- /dev/null
+++ b/src/granger/src/nettle/write-le32.c
@@ -0,0 +1,69 @@
+/* write-le32.c
+
+   Copyright (C) 2001, 2011 Niels Möller
+
+   This file is part of GNU Nettle.
+
+   GNU Nettle is free software: you can redistribute it and/or
+   modify it under the terms of either:
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or both in parallel, as here.
+
+   GNU Nettle 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
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see http://www.gnu.org/licenses/.
+*/
+
+#if HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdlib.h>
+
+#include "nettle-write.h"
+
+#include "macros.h"
+
+void
+_nettle_write_le32(size_t length, uint8_t *dst,
+		   uint32_t *src)
+{
+  size_t i;
+  size_t words;
+  unsigned leftover;
+  
+  words = length / 4;
+  leftover = length % 4;
+
+  for (i = 0; i < words; i++, dst += 4)
+    LE_WRITE_UINT32(dst, src[i]);
+
+  if (leftover)
+    {
+      uint32_t word;
+      
+      word = src[i];
+
+      do
+	{
+	  *dst++ = word & 0xff;
+	  word >>= 8;
+	}
+      while (--leftover);
+    }
+}