X-Git-Url: http://erislabs.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=lib%2Fgc-gnulib.c;h=5ce31c15002ff95945ce0208a7b03932d5f62948;hb=4a36ce8554cf078dee9d708ebbb8dcee32d237d2;hp=6eff3e3fee4363f488d28b43f34d0e314a3227ba;hpb=6a58cb3f05f9a3d05ce2b0e0845b7514540d81b5;p=gnulib.git

diff --git a/lib/gc-gnulib.c b/lib/gc-gnulib.c
index 6eff3e3fe..5ce31c150 100644
--- a/lib/gc-gnulib.c
+++ b/lib/gc-gnulib.c
@@ -1,5 +1,5 @@
-/* gc-gl-common.c --- Common gnulib internal crypto interface functions
- * Copyright (C) 2002, 2003, 2004, 2005  Simon Josefsson
+/* gc-gnulib.c --- Common gnulib internal crypto interface functions
+ * Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007  Simon Josefsson
  *
  * This file is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published
@@ -20,48 +20,51 @@
 
 /* Note: This file is only built if GC uses internal functions. */
 
-#ifdef HAVE_CONFIG_H
-# include <config.h>
-#endif
+#include <config.h>
 
 /* Get prototype. */
-#include <gc.h>
+#include "gc.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 /* For randomize. */
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <errno.h>
+#ifdef GNULIB_GC_RANDOM
+# include <unistd.h>
+# include <sys/types.h>
+# include <sys/stat.h>
+# include <fcntl.h>
+# include <errno.h>
+#endif
 
 /* Hashes. */
-#ifdef GC_USE_MD4
+#ifdef GNULIB_GC_MD2
+# include "md2.h"
+#endif
+#ifdef GNULIB_GC_MD4
 # include "md4.h"
 #endif
-#ifdef GC_USE_MD5
+#ifdef GNULIB_GC_MD5
 # include "md5.h"
 #endif
-#ifdef GC_USE_SHA1
+#ifdef GNULIB_GC_SHA1
 # include "sha1.h"
 #endif
-#ifdef GC_USE_HMAC_MD5
+#if defined(GNULIB_GC_HMAC_MD5) || defined(GNULIB_GC_HMAC_SHA1)
 # include "hmac.h"
 #endif
 
 /* Ciphers. */
-#ifdef GC_USE_ARCFOUR
+#ifdef GNULIB_GC_ARCFOUR
 # include "arcfour.h"
 #endif
-#ifdef GC_USE_ARCTWO
+#ifdef GNULIB_GC_ARCTWO
 # include "arctwo.h"
 #endif
-#ifdef GC_USE_DES
+#ifdef GNULIB_GC_DES
 # include "des.h"
 #endif
-#ifdef GC_USE_RIJNDAEL
+#ifdef GNULIB_GC_RIJNDAEL
 # include "rijndael-api-fst.h"
 #endif
 
@@ -77,6 +80,8 @@ gc_done (void)
   return;
 }
 
+#ifdef GNULIB_GC_RANDOM
+
 /* Randomness. */
 
 static Gc_rc
@@ -102,6 +107,9 @@ randomize (int level, char *data, size_t datalen)
       break;
     }
 
+  if (strcmp (device, "no") == 0)
+    return GC_RANDOM_ERROR;
+
   fd = open (device, O_RDONLY);
   if (fd < 0)
     return GC_RANDOM_ERROR;
@@ -149,6 +157,8 @@ gc_random (char *data, size_t datalen)
   return randomize (2, data, datalen);
 }
 
+#endif
+
 /* Memory allocation. */
 
 void
@@ -164,16 +174,17 @@ gc_set_allocators (gc_malloc_t func_malloc,
 typedef struct _gc_cipher_ctx {
   Gc_cipher alg;
   Gc_cipher_mode mode;
-#ifdef GC_USE_ARCTWO
+#ifdef GNULIB_GC_ARCTWO
   arctwo_context arctwoContext;
+  char arctwoIV[ARCTWO_BLOCK_SIZE];
 #endif
-#ifdef GC_USE_ARCFOUR
+#ifdef GNULIB_GC_ARCFOUR
   arcfour_context arcfourContext;
 #endif
-#ifdef GC_USE_DES
+#ifdef GNULIB_GC_DES
   des_ctx desContext;
 #endif
-#ifdef GC_USE_RIJNDAEL
+#ifdef GNULIB_GC_RIJNDAEL
   rijndaelKeyInstance aesEncKey;
   rijndaelKeyInstance aesDecKey;
   rijndaelCipherInstance aesContext;
@@ -188,17 +199,20 @@ gc_cipher_open (Gc_cipher alg, Gc_cipher_mode mode,
   Gc_rc rc = GC_OK;
 
   ctx = calloc (sizeof (*ctx), 1);
+  if (!ctx)
+    return GC_MALLOC_ERROR;
 
   ctx->alg = alg;
   ctx->mode = mode;
 
   switch (alg)
     {
-#ifdef GC_USE_ARCTWO
+#ifdef GNULIB_GC_ARCTWO
     case GC_ARCTWO40:
       switch (mode)
 	{
 	case GC_ECB:
+	case GC_CBC:
 	  break;
 
 	default:
@@ -207,7 +221,7 @@ gc_cipher_open (Gc_cipher alg, Gc_cipher_mode mode,
       break;
 #endif
 
-#ifdef GC_USE_ARCFOUR
+#ifdef GNULIB_GC_ARCFOUR
     case GC_ARCFOUR128:
     case GC_ARCFOUR40:
       switch (mode)
@@ -221,7 +235,7 @@ gc_cipher_open (Gc_cipher alg, Gc_cipher_mode mode,
       break;
 #endif
 
-#ifdef GC_USE_DES
+#ifdef GNULIB_GC_DES
     case GC_DES:
       switch (mode)
 	{
@@ -234,7 +248,7 @@ gc_cipher_open (Gc_cipher alg, Gc_cipher_mode mode,
       break;
 #endif
 
-#ifdef GC_USE_RIJNDAEL
+#ifdef GNULIB_GC_RIJNDAEL
     case GC_AES128:
     case GC_AES192:
     case GC_AES256:
@@ -269,20 +283,20 @@ gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
 
   switch (ctx->alg)
     {
-#ifdef GC_USE_ARCTWO
+#ifdef GNULIB_GC_ARCTWO
     case GC_ARCTWO40:
       arctwo_setkey (&ctx->arctwoContext, keylen, key);
       break;
 #endif
 
-#ifdef GC_USE_ARCFOUR
+#ifdef GNULIB_GC_ARCFOUR
     case GC_ARCFOUR128:
     case GC_ARCFOUR40:
       arcfour_setkey (&ctx->arcfourContext, key, keylen);
       break;
 #endif
 
-#ifdef GC_USE_DES
+#ifdef GNULIB_GC_DES
     case GC_DES:
       if (keylen != 8)
 	return GC_INVALID_CIPHER;
@@ -290,7 +304,7 @@ gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
       break;
 #endif
 
-#ifdef GC_USE_RIJNDAEL
+#ifdef GNULIB_GC_RIJNDAEL
     case GC_AES128:
     case GC_AES192:
     case GC_AES256:
@@ -333,7 +347,15 @@ gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
 
   switch (ctx->alg)
     {
-#ifdef GC_USE_RIJNDAEL
+#ifdef GNULIB_GC_ARCTWO
+    case GC_ARCTWO40:
+      if (ivlen != ARCTWO_BLOCK_SIZE)
+	return GC_INVALID_CIPHER;
+      memcpy (ctx->arctwoIV, iv, ivlen);
+      break;
+#endif
+
+#ifdef GNULIB_GC_RIJNDAEL
     case GC_AES128:
     case GC_AES192:
     case GC_AES256:
@@ -379,27 +401,48 @@ gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
 
   switch (ctx->alg)
     {
-#ifdef GC_USE_ARCTWO
+#ifdef GNULIB_GC_ARCTWO
     case GC_ARCTWO40:
-      arctwo_encrypt (&ctx->arctwoContext, data, data, len);
+      switch (ctx->mode)
+	{
+	case GC_ECB:
+	  arctwo_encrypt (&ctx->arctwoContext, data, data, len);
+	  break;
+
+	case GC_CBC:
+	  for (; len >= ARCTWO_BLOCK_SIZE; len -= ARCTWO_BLOCK_SIZE,
+		 data += ARCTWO_BLOCK_SIZE)
+	    {
+	      size_t i;
+	      for (i = 0; i < ARCTWO_BLOCK_SIZE; i++)
+		data[i] ^= ctx->arctwoIV[i];
+	      arctwo_encrypt (&ctx->arctwoContext, data, data,
+			      ARCTWO_BLOCK_SIZE);
+	      memcpy (ctx->arctwoIV, data, ARCTWO_BLOCK_SIZE);
+	    }
+	    break;
+
+	default:
+	  return GC_INVALID_CIPHER;
+	}
       break;
 #endif
 
-#ifdef GC_USE_ARCFOUR
+#ifdef GNULIB_GC_ARCFOUR
     case GC_ARCFOUR128:
     case GC_ARCFOUR40:
       arcfour_stream (&ctx->arcfourContext, data, data, len);
       break;
 #endif
 
-#ifdef GC_USE_DES
+#ifdef GNULIB_GC_DES
     case GC_DES:
       for (; len >= 8; len -= 8, data += 8)
 	des_ecb_encrypt (&ctx->desContext, data, data);
       break;
 #endif
 
-#ifdef GC_USE_RIJNDAEL
+#ifdef GNULIB_GC_RIJNDAEL
     case GC_AES128:
     case GC_AES192:
     case GC_AES256:
@@ -428,27 +471,50 @@ gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
 
   switch (ctx->alg)
     {
-#ifdef GC_USE_ARCTWO
+#ifdef GNULIB_GC_ARCTWO
     case GC_ARCTWO40:
-      arctwo_decrypt (&ctx->arctwoContext, data, data, len);
+      switch (ctx->mode)
+	{
+	case GC_ECB:
+	  arctwo_decrypt (&ctx->arctwoContext, data, data, len);
+	  break;
+
+	case GC_CBC:
+	  for (; len >= ARCTWO_BLOCK_SIZE; len -= ARCTWO_BLOCK_SIZE,
+		 data += ARCTWO_BLOCK_SIZE)
+	    {
+	      char tmpIV[ARCTWO_BLOCK_SIZE];
+	      size_t i;
+	      memcpy (tmpIV, data, ARCTWO_BLOCK_SIZE);
+	      arctwo_decrypt (&ctx->arctwoContext, data, data,
+			      ARCTWO_BLOCK_SIZE);
+	      for (i = 0; i < ARCTWO_BLOCK_SIZE; i++)
+		data[i] ^= ctx->arctwoIV[i];
+	      memcpy (ctx->arctwoIV, tmpIV, ARCTWO_BLOCK_SIZE);
+	    }
+	  break;
+
+	default:
+	  return GC_INVALID_CIPHER;
+	}
       break;
 #endif
 
-#ifdef GC_USE_ARCFOUR
+#ifdef GNULIB_GC_ARCFOUR
     case GC_ARCFOUR128:
     case GC_ARCFOUR40:
       arcfour_stream (&ctx->arcfourContext, data, data, len);
       break;
 #endif
 
-#ifdef GC_USE_DES
+#ifdef GNULIB_GC_DES
     case GC_DES:
       for (; len >= 8; len -= 8, data += 8)
 	des_ecb_decrypt (&ctx->desContext, data, data);
       break;
 #endif
 
-#ifdef GC_USE_RIJNDAEL
+#ifdef GNULIB_GC_RIJNDAEL
     case GC_AES128:
     case GC_AES192:
     case GC_AES256:
@@ -483,24 +549,246 @@ gc_cipher_close (gc_cipher_handle handle)
 
 /* Hashes. */
 
+#define MAX_DIGEST_SIZE 20
+
+typedef struct _gc_hash_ctx {
+  Gc_hash alg;
+  Gc_hash_mode mode;
+  char hash[MAX_DIGEST_SIZE];
+#ifdef GNULIB_GC_MD2
+  struct md2_ctx md2Context;
+#endif
+#ifdef GNULIB_GC_MD4
+  struct md4_ctx md4Context;
+#endif
+#ifdef GNULIB_GC_MD5
+  struct md5_ctx md5Context;
+#endif
+#ifdef GNULIB_GC_SHA1
+  struct sha1_ctx sha1Context;
+#endif
+} _gc_hash_ctx;
+
+Gc_rc
+gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
+{
+  _gc_hash_ctx *ctx;
+  Gc_rc rc = GC_OK;
+
+  ctx = calloc (sizeof (*ctx), 1);
+
+  ctx->alg = hash;
+  ctx->mode = mode;
+
+  switch (hash)
+    {
+#ifdef GNULIB_GC_MD2
+    case GC_MD2:
+      md2_init_ctx (&ctx->md2Context);
+      break;
+#endif
+
+#ifdef GNULIB_GC_MD4
+    case GC_MD4:
+      md4_init_ctx (&ctx->md4Context);
+      break;
+#endif
+
+#ifdef GNULIB_GC_MD5
+    case GC_MD5:
+      md5_init_ctx (&ctx->md5Context);
+      break;
+#endif
+
+#ifdef GNULIB_GC_SHA1
+    case GC_SHA1:
+      sha1_init_ctx (&ctx->sha1Context);
+      break;
+#endif
+
+    default:
+      rc = GC_INVALID_HASH;
+      break;
+    }
+
+  switch (mode)
+    {
+    case 0:
+      break;
+
+    default:
+      rc = GC_INVALID_HASH;
+      break;
+    }
+
+  if (rc == GC_OK)
+    *outhandle = ctx;
+  else
+    free (ctx);
+
+  return rc;
+}
+
+Gc_rc
+gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
+{
+  _gc_hash_ctx *in = handle;
+  _gc_hash_ctx *out;
+
+  *outhandle = out = calloc (sizeof (*out), 1);
+  if (!out)
+    return GC_MALLOC_ERROR;
+
+  memcpy (out, in, sizeof (*out));
+
+  return GC_OK;
+}
+
+size_t
+gc_hash_digest_length (Gc_hash hash)
+{
+  size_t len;
+
+  switch (hash)
+    {
+    case GC_MD2:
+      len = GC_MD2_DIGEST_SIZE;
+      break;
+
+    case GC_MD4:
+      len = GC_MD4_DIGEST_SIZE;
+      break;
+
+    case GC_MD5:
+      len = GC_MD5_DIGEST_SIZE;
+      break;
+
+    case GC_RMD160:
+      len = GC_RMD160_DIGEST_SIZE;
+      break;
+
+    case GC_SHA1:
+      len = GC_SHA1_DIGEST_SIZE;
+      break;
+
+    default:
+      return 0;
+    }
+
+  return len;
+}
+
+void
+gc_hash_write (gc_hash_handle handle, size_t len, const char *data)
+{
+  _gc_hash_ctx *ctx = handle;
+
+  switch (ctx->alg)
+    {
+#ifdef GNULIB_GC_MD2
+    case GC_MD2:
+      md2_process_bytes (data, len, &ctx->md2Context);
+      break;
+#endif
+
+#ifdef GNULIB_GC_MD4
+    case GC_MD4:
+      md4_process_bytes (data, len, &ctx->md4Context);
+      break;
+#endif
+
+#ifdef GNULIB_GC_MD5
+    case GC_MD5:
+      md5_process_bytes (data, len, &ctx->md5Context);
+      break;
+#endif
+
+#ifdef GNULIB_GC_SHA1
+    case GC_SHA1:
+      sha1_process_bytes (data, len, &ctx->sha1Context);
+      break;
+#endif
+
+    default:
+      break;
+    }
+}
+
+const char *
+gc_hash_read (gc_hash_handle handle)
+{
+  _gc_hash_ctx *ctx = handle;
+  const char *ret = NULL;
+
+  switch (ctx->alg)
+    {
+#ifdef GNULIB_GC_MD2
+    case GC_MD2:
+      md2_finish_ctx (&ctx->md2Context, ctx->hash);
+      ret = ctx->hash;
+      break;
+#endif
+
+#ifdef GNULIB_GC_MD4
+    case GC_MD4:
+      md4_finish_ctx (&ctx->md4Context, ctx->hash);
+      ret = ctx->hash;
+      break;
+#endif
+
+#ifdef GNULIB_GC_MD5
+    case GC_MD5:
+      md5_finish_ctx (&ctx->md5Context, ctx->hash);
+      ret = ctx->hash;
+      break;
+#endif
+
+#ifdef GNULIB_GC_SHA1
+    case GC_SHA1:
+      sha1_finish_ctx (&ctx->sha1Context, ctx->hash);
+      ret = ctx->hash;
+      break;
+#endif
+
+    default:
+      return NULL;
+    }
+
+  return ret;
+}
+
+void
+gc_hash_close (gc_hash_handle handle)
+{
+  _gc_hash_ctx *ctx = handle;
+
+  free (ctx);
+}
+
 Gc_rc
 gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
 {
   switch (hash)
     {
-#ifdef GC_USE_MD4
+#ifdef GNULIB_GC_MD2
+    case GC_MD2:
+      md2_buffer (in, inlen, resbuf);
+      break;
+#endif
+
+#ifdef GNULIB_GC_MD4
     case GC_MD4:
       md4_buffer (in, inlen, resbuf);
       break;
 #endif
 
-#ifdef GC_USE_MD5
+#ifdef GNULIB_GC_MD5
     case GC_MD5:
       md5_buffer (in, inlen, resbuf);
       break;
 #endif
 
-#ifdef GC_USE_SHA1
+#ifdef GNULIB_GC_SHA1
     case GC_SHA1:
       sha1_buffer (in, inlen, resbuf);
       break;
@@ -513,7 +801,16 @@ gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
   return GC_OK;
 }
 
-#ifdef GC_USE_MD4
+#ifdef GNULIB_GC_MD2
+Gc_rc
+gc_md2 (const void *in, size_t inlen, void *resbuf)
+{
+  md2_buffer (in, inlen, resbuf);
+  return GC_OK;
+}
+#endif
+
+#ifdef GNULIB_GC_MD4
 Gc_rc
 gc_md4 (const void *in, size_t inlen, void *resbuf)
 {
@@ -522,7 +819,7 @@ gc_md4 (const void *in, size_t inlen, void *resbuf)
 }
 #endif
 
-#ifdef GC_USE_MD5
+#ifdef GNULIB_GC_MD5
 Gc_rc
 gc_md5 (const void *in, size_t inlen, void *resbuf)
 {
@@ -531,7 +828,7 @@ gc_md5 (const void *in, size_t inlen, void *resbuf)
 }
 #endif
 
-#ifdef GC_USE_SHA1
+#ifdef GNULIB_GC_SHA1
 Gc_rc
 gc_sha1 (const void *in, size_t inlen, void *resbuf)
 {
@@ -540,7 +837,7 @@ gc_sha1 (const void *in, size_t inlen, void *resbuf)
 }
 #endif
 
-#ifdef GC_USE_HMAC_MD5
+#ifdef GNULIB_GC_HMAC_MD5
 Gc_rc
 gc_hmac_md5 (const void *key, size_t keylen,
 	     const void *in, size_t inlen, char *resbuf)
@@ -550,7 +847,7 @@ gc_hmac_md5 (const void *key, size_t keylen,
 }
 #endif
 
-#ifdef GC_USE_HMAC_SHA1
+#ifdef GNULIB_GC_HMAC_SHA1
 Gc_rc
 gc_hmac_sha1 (const void *key, size_t keylen,
 	      const void *in, size_t inlen, char *resbuf)