* Initial checkin.

Rev: src/nettle/.bootstrap:1.1
Rev: src/nettle/.c-style:1.1
Rev: src/nettle/AUTHORS:1.1
Rev: src/nettle/ChangeLog:1.1
Rev: src/nettle/Makefile.am:1.1
Rev: src/nettle/NEWS:1.1
Rev: src/nettle/README:1.1
Rev: src/nettle/aes.c:1.1
Rev: src/nettle/aes.h:1.1
Rev: src/nettle/arcfour.c:1.1
Rev: src/nettle/arcfour.h:1.1
Rev: src/nettle/configure.in:1.1
Rev: src/nettle/macros.h:1.1
Rev: src/nettle/md5.c:1.1
Rev: src/nettle/md5.h:1.1
Rev: src/nettle/memxor.c:1.1
Rev: src/nettle/memxor.h:1.1
Rev: src/nettle/testsuite/.c-style:1.1
Rev: src/nettle/testsuite/Makefile.am:1.1
Rev: src/nettle/testsuite/aes-test.m4:1.1
Rev: src/nettle/testsuite/arcfour-test.m4:1.1
Rev: src/nettle/testsuite/macros.m4:1.1
Rev: src/nettle/testsuite/md5-test.m4:1.1
Rev: src/nettle/testsuite/run-tests:1.1
Rev: src/nettle/testsuite/testutils.c:1.1
Rev: src/nettle/testsuite/testutils.h:1.1

src/nettle/.bootstrap

+aclocal && autoconf && autoheader && automake -a

src/nettle/.c-style

+"gnu"

src/nettle/ChangeLog

+2001-04-13  Niels Mller  <nisse@cuckoo.hack.org>
+
+	* Initial checkin.
+

src/nettle/Makefile.am

+SUBDIRS = . testsuite
+
+lib_LIBRARIES = libnettle.a
+include_HEADERS = arcfour.h
+
+libnettleincludedir = $(includedir)/nettle
+libnettle_a_SOURCES = aes.c aes.h arcfour.c arcfour.h md5.c md5.h
+
+libnettle_a_LIBADD = @LIBOBJS@
+
+EXTRA_DIST = macros.h

src/nettle/aes.h

+/* aes.h
+ *
+ * The aes/rijndael block cipher.
+ */
+
+/* nettle, low-level cryptographics library
+ *
+ * Copyright (C) 2001 Niels Möller
+ *  
+ * The nettle library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at your
+ * option) any later version.
+ * 
+ * The GNU MP Library 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 Lesser General Public
+ * License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with the GNU MP Library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ */
+ 
+#ifndef NETTLE_AES_H_INCLUDED
+#define NETTLE_AES_H_INCLUDED
+
+#include <stdint.h>
+
+#define AES_BLOCK_SIZE 16
+
+/* Variable key size between 128 and 256 bits. But the only valid
+ * values are 16 (128 bits), 24 (192 bits) and 32 (256 bits). */
+#define AES_MIN_KEY_SIZE 16
+#define AES_MAX_KEY_SIZE 32
+
+#define AES_KEY_SIZE 32
+
+struct aes_ctx
+{
+  uint32_t keys[60];  /* maximum size of key schedule */
+  uint32_t ikeys[60]; /* inverse key schedule */
+  unsigned  nrounds;  /* number of rounds to use for our key size */
+};
+
+void
+aes_set_key(struct aes_ctx *ctx,
+	    unsigned length, const uint8_t *key);
+
+void
+aes_encrypt(struct aes_ctx *ctx,
+	    unsigned length, uint8_t *dst,
+	    const uint8_t *src);
+void
+aes_decrypt(struct aes_ctx *ctx,
+	    unsigned length, uint8_t *dst,
+	    const uint8_t *src);
+
+#endif /* NETTLE_AES_H_INCLUDED */

src/nettle/arcfour.c

+/* arcfour.c
+ *
+ * The arcfour/rc4 stream cipher.
+ */
+
+/* nettle, low-level cryptographics library
+ *
+ * Copyright (C) 2001 Niels Mller
+ *  
+ * The nettle library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at your
+ * option) any later version.
+ * 
+ * The GNU MP Library 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 Lesser General Public
+ * License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with the GNU MP Library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ */
+
+#include "arcfour.h"
+
+#include <assert.h>
+
+#define SWAP(a,b) do { int _t = a; a = b; b = _t; } while(0)
+
+void
+arcfour_set_key(struct arcfour_ctx *ctx,
+		unsigned length, const uint8_t *key)
+{
+  unsigned i, j, k;
+  
+  assert(length >= ARCFOUR_MIN_KEY_SIZE);
+  assert(length <= ARCFOUR_MAX_KEY_SIZE);
+
+  /* Initialize context */
+  for (i = 0; i<256; i++)
+    ctx->S[i] = i;
+
+  for (i = j = k = 0; i<256; i++)
+    {
+      j += ctx->S[i] + key[k]; j &= 0xff;
+      SWAP(ctx->S[i], ctx->S[j]);
+      /* Repeat key as needed */
+      k = (k + 1) % length;
+    }
+  ctx->i = ctx->j = 0;
+}
+
+
+void
+arcfour_crypt(struct arcfour_ctx *ctx,
+	      unsigned length, uint8_t *dst,
+	      const uint8_t *src)
+{
+  register uint8_t i, j;
+
+  i = ctx->i; j = ctx->j;
+  while(length--)
+    {
+      i++; i &= 0xff;
+      j += ctx->S[i]; j &= 0xff;
+      SWAP(ctx->S[i], ctx->S[j]);
+      *dst++ = *src++ ^ ctx->S[ (ctx->S[i] + ctx->S[j]) & 0xff ];
+    }
+  ctx->i = i; ctx->j = j;
+}
+
+void
+arcfour_stream(struct arcfour_ctx *ctx,
+	       unsigned length, uint8_t *dst)
+{
+  register uint8_t i, j;
+
+  i = ctx->i; j = ctx->j;
+  while(length--)
+    {
+      i++; i &= 0xff;
+      j += ctx->S[i]; j &= 0xff;
+      SWAP(ctx->S[i], ctx->S[j]);
+      *dst++ = ctx->S[ (ctx->S[i] + ctx->S[j]) & 0xff ];
+    }
+  ctx->i = i; ctx->j = j;
+}
+

src/nettle/arcfour.h

+/* arcfour.h
+ *
+ * The arcfour/rc4 stream cipher.
+ */
+
+/* nettle, low-level cryptographics library
+ *
+ * Copyright (C) 2001 Niels Mller
+ *  
+ * The nettle library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at your
+ * option) any later version.
+ * 
+ * The GNU MP Library 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 Lesser General Public
+ * License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with the GNU MP Library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ */
+ 
+#ifndef NETTLE_ARCFOUR_H_INCLUDED
+#define NETTLE_ARCFOUR_H_INCLUDED
+
+#include <stdint.h>
+
+/* Minimum and maximum keysizes, and a reasonable default. In
+ * octets.*/
+#define ARCFOUR_MIN_KEY_SIZE 1
+#define ARCFOUR_MAX_KEY_SIZE 256
+#define ARCFOUR_KEY_SIZE 16
+
+struct arcfour_ctx
+{
+  uint8_t S[256];
+  uint8_t i;
+  uint8_t j;
+};
+
+void
+arcfour_set_key(struct arcfour_ctx *ctx,
+		unsigned length, const uint8_t *key);
+
+void
+arcfour_crypt(struct arcfour_ctx *ctx,
+	      unsigned length, uint8_t *dst,
+	      const uint8_t *src);
+
+void
+arcfour_stream(struct arcfour_ctx *ctx,
+	       unsigned length, uint8_t *dst);
+
+#endif /* NETTLE_ARCFOUR_H_INCLUDED */
+

src/nettle/configure.in

+dnl -*- mode: shell-script; sh-indentation: 2; -*-
+dnl $Id$
+
+dnl Process this file with autoconf to produce a configure script.
+
+AC_INIT(arcfour.c)
+
+AM_INIT_AUTOMAKE(libnettle, 0.1)
+
+AM_CONFIG_HEADER(config.h)
+
+dnl Checks for programs.
+AC_PROG_CC
+AC_PROG_MAKE_SET
+AC_PROG_RANLIB
+AM_PROG_CC_STDC
+
+if test "x$am_cv_prog_cc_stdc" = xno ; then
+  AC_ERROR([the C compiler doesn't handle ANSI-C])
+fi
+
+AC_PATH_PROG(M4, m4, m4)
+
+dnl Checks for typedefs, structures, and compiler characteristics.
+AC_C_CONST
+AC_C_INLINE
+AC_TYPE_UID_T
+AC_TYPE_SIZE_T
+AC_HEADER_TIME
+
+dnl Needed by the supplied memcmp.c
+AC_C_BIGENDIAN
+
+AC_CHECK_SIZEOF(short, 2)
+AC_CHECK_SIZEOF(int, 4)
+AC_CHECK_SIZEOF(long, 4)
+
+AC_REPLACE_FUNCS(memxor)
+
+# Set these flags *last*, or else the test programs won't compile
+if test x$GCC = xyes ; then
+    CFLAGS="$CFLAGS -ggdb3 -Wall -W \
+ -Wmissing-prototypes -Wmissing-declarations -Wstrict-prototypes \
+ -Waggregate-return \
+ -Wpointer-arith -Wbad-function-cast -Wnested-externs"
+
+# Don't enable -Wcast-align as it results in tons of warnings in the
+# DES code. And when using stdio.
+
+fi
+
+AC_OUTPUT(Makefile testsuite/Makefile)
+

src/nettle/macros.h

+/* macros.h
+ *
+ */
+
+/* nettle, low-level cryptographics library
+ *
+ * Copyright (C) 2001 Niels Mller
+ *  
+ * The nettle library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at your
+ * option) any later version.
+ * 
+ * The GNU MP Library 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 Lesser General Public
+ * License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with the GNU MP Library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ */
+
+#ifndef NETTLE_MACROS_H_INCLUDED
+#define NETTLE_MACROS_H_INCLUDED
+
+/* 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)
+
+/* And the other, little-endian, byteorder */
+#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)
+
+
+#endif /* NETTLE_MACROS_H_INCLUDED */

src/nettle/md5.c

+/* md5.c
+ *
+ * The md5 hash function.
+ */
+
+/* nettle, low-level cryptographics library
+ *
+ * Copyright (C) 2001 Niels Mller
+ *  
+ * The nettle library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at your
+ * option) any later version.
+ * 
+ * The GNU MP Library 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 Lesser General Public
+ * License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with the GNU MP Library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ */
+
+/* Based on public domain code hacked by Colin Plumb, Andrew Kuchling, and
+ * Niels Mller. */
+
+#include "md5.h"
+
+#include "macros.h"
+
+#include <assert.h>
+
+/* A block, treated as a sequence of 32-bit words. */
+#define MD5_DATA_LENGTH 16
+
+static void
+md5_transform(uint32_t *digest, const uint32_t *data);
+
+static void
+md5_block(struct md5_ctx *ctx, const uint8_t *block);
+
+void
+md5_init(struct md5_ctx *ctx)
+{
+  ctx->digest[0] = 0x67452301;
+  ctx->digest[1] = 0xefcdab89;
+  ctx->digest[2] = 0x98badcfe;
+  ctx->digest[3] = 0x10325476;
+  
+  ctx->count_l = ctx->count_h = 0;
+  ctx->index = 0;
+}
+
+void
+md5_update(struct md5_ctx *ctx,
+	   unsigned length,
+	   const uint8_t *data)
+{
+  if (ctx->index)
+    {
+      /* Try to fill partial block */
+      unsigned left = MD5_DATA_SIZE - ctx->index;
+      if (length < left)
+	{
+	  memcpy(ctx->block + ctx->index, data, length);
+	  ctx->index += length;
+	  return; /* Finished */
+	}
+      else
+	{
+	  memcpy(ctx->block + ctx->index, data, left);
+	  md5_block(ctx, ctx->block);
+	  data += left;
+	  length -= left;
+	}
+    }
+  while (length >= MD5_DATA_SIZE)
+    {
+      md5_block(ctx, data);
+      data += MD5_DATA_SIZE;
+      length -= MD5_DATA_SIZE;
+    }
+  if ((ctx->index = length))     /* This assignment is intended */
+    /* Buffer leftovers */
+    memcpy(ctx->block, data, length);
+}
+
+/* Final wrapup - pad to MD5_DATA_SIZE-byte boundary with the bit
+ * pattern 1 0* (64-bit count of bits processed, LSB-first) */
+
+void
+md5_final(struct md5_ctx *ctx)
+{
+  uint32_t data[MD5_DATA_LENGTH];
+  unsigned i;
+  unsigned words;
+  
+  i = ctx->index;
+
+  /* Set the first char of padding to 0x80. This is safe since there
+   * is always at least one byte free */
+  assert(i < MD5_DATA_SIZE);
+  ctx->block[i++] = 0x80;
+
+  /* Fill rest of word */
+  for( ; i & 3; i++)
+    ctx->block[i] = 0;
+
+  /* i is now a multiple of the word size 4 */
+  words = i >> 2;
+  for (i = 0; i < words; i++)
+    data[i] = LE_READ_UINT32(ctx->block + 4*i);
+  
+  if (words > (MD5_DATA_LENGTH-2))
+    { /* No room for length in this block. Process it and
+       * pad with another one */
+      for (i = words ; i < MD5_DATA_LENGTH; i++)
+	data[i] = 0;
+      md5_transform(ctx->digest, data);
+      for (i = 0; i < (MD5_DATA_LENGTH-2); i++)
+	data[i] = 0;
+    }
+  else
+    for (i = words ; i < MD5_DATA_LENGTH - 2; i++)
+      data[i] = 0;
+  
+  /* There are 512 = 2^9 bits in one block 
+   * Little-endian order => Least significant word first */
+
+  data[MD5_DATA_LENGTH-1] = (ctx->count_h << 9) | (ctx->count_l >> 23);
+  data[MD5_DATA_LENGTH-2] = (ctx->count_l << 9) | (ctx->index << 3);
+  md5_transform(ctx->digest, data);
+}
+
+void
+md5_digest(const struct md5_ctx *ctx,
+	   unsigned length,
+	   uint8_t *digest)
+{
+  unsigned i;
+  unsigned words;
+  unsigned leftover;
+  
+  assert(length <= MD5_DIGEST_SIZE);
+
+  words = length / 4;
+  leftover = length % 4;
+  
+  /* Little endian order */
+  for (i = 0; i < words; i++, digest += 4)
+    LE_WRITE_UINT32(digest, ctx->digest[i]);
+
+  if (leftover)
+    {
+      uint32_t word;
+      unsigned j;
+
+      assert(i < _MD5_DIGEST_LENGTH);
+      
+      /* Still least significant byte first. */
+      for (word = ctx->digest[i], j = 0; j < leftover;
+	   j++, word >>= 8)
+	digest[j] = word & 0xff;
+    }
+}
+
+/* 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. */
+
+static void
+md5_transform(uint32_t *digest, const uint32_t *data)
+{
+  uint32_t a, b, c, d;
+  a = digest[0];
+  b = digest[1];
+  c = digest[2];
+  d = digest[3];
+
+  ROUND(F1, a, b, c, d, data[ 0] + 0xd76aa478, 7);
+  ROUND(F1, d, a, b, c, data[ 1] + 0xe8c7b756, 12);
+  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);
+
+  ROUND(F2, a, b, c, d, data[ 1] + 0xf61e2562, 5);
+  ROUND(F2, d, a, b, c, data[ 6] + 0xc040b340, 9);
+  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);
+
+  ROUND(F3, a, b, c, d, data[ 5] + 0xfffa3942, 4);
+  ROUND(F3, d, a, b, c, data[ 8] + 0x8771f681, 11);
+  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);
+
+  ROUND(F4, a, b, c, d, data[ 0] + 0xf4292244, 6);
+  ROUND(F4, d, a, b, c, data[ 7] + 0x432aff97, 10);
+  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);
+
+  digest[0] += a;
+  digest[1] += b;
+  digest[2] += c;
+  digest[3] += d;
+}
+
+static void
+md5_block(struct md5_ctx *ctx, const uint8_t *block)
+{
+  uint32_t data[MD5_DATA_LENGTH];
+  unsigned i;
+  
+  /* Update block count */
+  if (!++ctx->count_l)
+    ++ctx->count_h;
+
+  /* Endian independent conversion */
+  for (i = 0; i<16; i++, block += 4)
+    data[i] = LE_READ_UINT32(block);
+
+  md5_transform(ctx->digest, data);
+}

src/nettle/md5.h

+/* md5.h
+ *
+ * The md5 hash function.