X-Git-Url: https://git.distorted.org.uk/~mdw/catacomb/blobdiff_plain/12331b2df6b898d74eaee321eda4b0fe703031e5..HEAD:/symm/ecb-def.h

diff --git a/symm/ecb-def.h b/symm/ecb-def.h
index 9f50292e..c69790de 100644
--- a/symm/ecb-def.h
+++ b/symm/ecb-def.h
@@ -65,7 +65,9 @@
  * Use:		Creates an implementation for ECB stealing mode.
  */
 
-#define ECB_DEF(PRE, pre)						\
+#define ECB_DEF(PRE, pre) ECB_DEFX(PRE, pre, #pre, #pre)
+
+#define ECB_DEFX(PRE, pre, name, fname)					\
 									\
 /* --- @pre_ecbsetkey@ --- *						\
  *									\
@@ -78,9 +80,7 @@
  */									\
 									\
 void pre##_ecbsetkey(pre##_ecbctx *ctx, const pre##_ctx *k)		\
-{									\
-  ctx->ctx = *k;							\
-}									\
+  { ctx->ctx = *k; }							\
 									\
 /* --- @pre_ecbinit@ --- *						\
  *									\
@@ -96,11 +96,9 @@ void pre##_ecbsetkey(pre##_ecbctx *ctx, const pre##_ctx *k)		\
  */									\
 									\
 void pre##_ecbinit(pre##_ecbctx *ctx,					\
-		     const void *key, size_t sz,			\
-		     const void *iv)					\
-{									\
-  pre##_init(&ctx->ctx, key, sz);					\
-}									\
+		   const void *key, size_t sz,				\
+		   const void *iv)					\
+  { pre##_init(&ctx->ctx, key, sz); }					\
 									\
 /* --- @pre_ecbencrypt@ --- *						\
  *									\
@@ -118,16 +116,19 @@ void pre##_ecbinit(pre##_ecbctx *ctx,					\
  */									\
 									\
 void pre##_ecbencrypt(pre##_ecbctx *ctx,				\
-			const void *src, void *dest,			\
-			size_t sz)					\
+		      const void *src, void *dest,			\
+		      size_t sz)					\
 {									\
   const octet *s = src;							\
   octet *d = dest;							\
+  uint32 t[PRE##_BLKSZ/4];						\
+  octet b[PRE##_BLKSZ];							\
+  octet y;								\
+  unsigned i;								\
 									\
-  /* --- Empty blocks are trivial --- */				\
+  /* --- Empty blocks are trivial, and ECB is stateless --- */		\
 									\
-  if (!sz)								\
-    return;								\
+  if (!sz || !d) return;						\
 									\
   /* --- Short blocks aren't allowed in ECB --- *			\
    *									\
@@ -144,19 +145,11 @@ void pre##_ecbencrypt(pre##_ecbctx *ctx,				\
    * Hopefully...							\
    */									\
 									\
-  while (sz >= 2 * PRE##_BLKSZ || sz == PRE##_BLKSZ) {			\
-    uint32 x[PRE##_BLKSZ / 4];						\
-    if (!s)								\
-      BLKC_ZERO(PRE, x);						\
-    else {								\
-      BLKC_LOAD(PRE, x, s);						\
-      s += PRE##_BLKSZ;							\
-    }									\
-    pre##_eblk(&ctx->ctx, x, x);					\
-    if (d) {								\
-      BLKC_STORE(PRE, d, x);						\
-      d += PRE##_BLKSZ;							\
-    }									\
+  while (sz >= 2*PRE##_BLKSZ || sz == PRE##_BLKSZ) {			\
+    if (!s) BLKC_ZERO(PRE, t);						\
+    else { BLKC_LOAD(PRE, t, s); s += PRE##_BLKSZ; }			\
+    pre##_eblk(&ctx->ctx, t, t);					\
+    BLKC_STORE(PRE, d, t); d += PRE##_BLKSZ;				\
     sz -= PRE##_BLKSZ;							\
   }									\
 									\
@@ -166,9 +159,6 @@ void pre##_ecbencrypt(pre##_ecbctx *ctx,				\
    */									\
 									\
   if (sz) {								\
-    uint32 x[PRE##_BLKSZ / 4];						\
-    octet b[PRE##_BLKSZ];						\
-    unsigned i;								\
 									\
     /* --- Let @sz@ be the size of the partial block --- */		\
 									\
@@ -181,14 +171,10 @@ void pre##_ecbencrypt(pre##_ecbctx *ctx,				\
      * out yet, because I've not read the partial plaintext block.	\
      */									\
 									\
-    if (!s)								\
-      BLKC_ZERO(PRE, x);						\
-    else {								\
-      BLKC_LOAD(PRE, x, s);						\
-      s += PRE##_BLKSZ;							\
-    }									\
-    pre##_eblk(&ctx->ctx, x, x);					\
-    BLKC_STORE(PRE, b, x);						\
+    if (!s) BLKC_ZERO(PRE, t);						\
+    else { BLKC_LOAD(PRE, t, s); s += PRE##_BLKSZ; }			\
+    pre##_eblk(&ctx->ctx, t, t);					\
+    BLKC_STORE(PRE, b, t);						\
 									\
     /* --- Second stage --- *						\
      *									\
@@ -197,15 +183,11 @@ void pre##_ecbencrypt(pre##_ecbctx *ctx,				\
      * ciphertext block.						\
      */									\
 									\
-    if (d) d += PRE##_BLKSZ;						\
-    for (i = 0; i < sz; i++) {						\
-      register octet y = b[i];						\
-      b[i] = s[i];							\
-      if (d) d[i] = y;							\
-    }									\
-    BLKC_LOAD(PRE, x, b);						\
-    pre##_eblk(&ctx->ctx, x, x);					\
-    if (d) BLKC_STORE(PRE, d - PRE##_BLKSZ, x);				\
+    d += PRE##_BLKSZ;							\
+    for (i = 0; i < sz; i++) { y = b[i]; b[i] = s[i]; d[i] = y; }	\
+    BLKC_LOAD(PRE, t, b);						\
+    pre##_eblk(&ctx->ctx, t, t);					\
+    BLKC_STORE(PRE, d - PRE##_BLKSZ, t);				\
   }									\
 									\
   /* --- Done --- */							\
@@ -234,11 +216,14 @@ void pre##_ecbdecrypt(pre##_ecbctx *ctx,				\
 {									\
   const octet *s = src;							\
   octet *d = dest;							\
+  uint32 t[PRE##_BLKSZ/4];						\
+  octet b[PRE##_BLKSZ];							\
+  octet y;								\
+  unsigned i;								\
 									\
   /* --- Empty blocks are trivial --- */				\
 									\
-  if (!sz)								\
-    return;								\
+  if (!sz) return;							\
 									\
   /* --- Short blocks aren't allowed in ECB --- *			\
    *									\
@@ -254,13 +239,10 @@ void pre##_ecbdecrypt(pre##_ecbctx *ctx,				\
    * Each block is just handed to the block cipher in turn.		\
    */									\
 									\
-  while (sz >= 2 * PRE##_BLKSZ || sz == PRE##_BLKSZ) {			\
-    uint32 x[PRE##_BLKSZ / 4];						\
-    BLKC_LOAD(PRE, x, s);						\
-    pre##_dblk(&ctx->ctx, x, x);					\
-    BLKC_STORE(PRE, d, x);						\
-    s += PRE##_BLKSZ;							\
-    d += PRE##_BLKSZ;							\
+  while (sz >= 2*PRE##_BLKSZ || sz == PRE##_BLKSZ) {			\
+    BLKC_LOAD(PRE, t, s); s += PRE##_BLKSZ;				\
+    pre##_dblk(&ctx->ctx, t, t);					\
+    BLKC_STORE(PRE, d, t); d += PRE##_BLKSZ;				\
     sz -= PRE##_BLKSZ;							\
   }									\
 									\
@@ -270,9 +252,6 @@ void pre##_ecbdecrypt(pre##_ecbctx *ctx,				\
    */									\
 									\
   if (sz) {								\
-    uint32 x[PRE##_BLKSZ / 4];						\
-    octet b[PRE##_BLKSZ];						\
-    unsigned i;								\
 									\
     /* --- Let @sz@ be the size of the partial block --- */		\
 									\
@@ -284,9 +263,9 @@ void pre##_ecbdecrypt(pre##_ecbctx *ctx,				\
      * is carried over for the next encryption operation.		\
      */									\
 									\
-    BLKC_LOAD(PRE, x, s);						\
-    pre##_dblk(&ctx->ctx, x, x);					\
-    BLKC_STORE(PRE, b, x);						\
+    BLKC_LOAD(PRE, t, s);						\
+    pre##_dblk(&ctx->ctx, t, t);					\
+    BLKC_STORE(PRE, b, t);						\
 									\
     /* --- Second stage --- *						\
      *									\
@@ -297,14 +276,10 @@ void pre##_ecbdecrypt(pre##_ecbctx *ctx,				\
 									\
     s += PRE##_BLKSZ;							\
     d += PRE##_BLKSZ;							\
-    for (i = 0; i < sz; i++) {						\
-      register octet y = s[i];						\
-      d[i] = b[i];							\
-      b[i] = y;								\
-    }									\
-    BLKC_LOAD(PRE, x, b);						\
-    pre##_dblk(&ctx->ctx, x, x);					\
-    BLKC_STORE(PRE, d - PRE##_BLKSZ, x);				\
+    for (i = 0; i < sz; i++) { y = s[i]; d[i] = b[i]; b[i] = y; }	\
+    BLKC_LOAD(PRE, t, b);						\
+    pre##_dblk(&ctx->ctx, t, t);					\
+    BLKC_STORE(PRE, d - PRE##_BLKSZ, t);				\
   }									\
 									\
   /* --- Done --- */							\
@@ -330,23 +305,13 @@ static gcipher *ginit(const void *k, size_t sz)				\
 }									\
 									\
 static void gencrypt(gcipher *c, const void *s, void *t, size_t sz)	\
-{									\
-  gctx *g = (gctx *)c;							\
-  pre##_ecbencrypt(&g->k, s, t, sz);					\
-}									\
+  { gctx *g = (gctx *)c; pre##_ecbencrypt(&g->k, s, t, sz); }		\
 									\
 static void gdecrypt(gcipher *c, const void *s, void *t, size_t sz)	\
-{									\
-  gctx *g = (gctx *)c;							\
-  pre##_ecbdecrypt(&g->k, s, t, sz);					\
-}									\
+  { gctx *g = (gctx *)c; pre##_ecbdecrypt(&g->k, s, t, sz); }		\
 									\
 static void gdestroy(gcipher *c)					\
-{									\
-  gctx *g = (gctx *)c;							\
-  BURN(*g);								\
-  S_DESTROY(g);								\
-}									\
+  { gctx *g = (gctx *)c; BURN(*g); S_DESTROY(g); }			\
 									\
 static const gcipher_ops gops = {					\
   &pre##_ecb,								\
@@ -354,19 +319,19 @@ static const gcipher_ops gops = {					\
 };									\
 									\
 const gccipher pre##_ecb = {						\
-  #pre "-ecb", pre##_keysz, PRE##_BLKSZ,				\
+  name "-ecb", pre##_keysz, PRE##_BLKSZ,				\
   ginit									\
 };									\
 									\
-ECB_TEST(PRE, pre)
+ECB_TESTX(PRE, pre, name, fname)
 
 /*----- Test rig ----------------------------------------------------------*/
 
-#ifdef TEST_RIG
+#define ECB_TEST(PRE, pre) ECB_TESTX(PRE, pre, #pre, #pre)
 
-#include <stdio.h>
+#ifdef TEST_RIG
 
-#include "daftstory.h"
+#include "modes-test.h"
 
 /* --- @ECB_TEST@ --- *
  *
@@ -375,91 +340,34 @@ ECB_TEST(PRE, pre)
  * Use:		Standard test rig for ECB functions.
  */
 
-#define ECB_TEST(PRE, pre)						\
-									\
-/* --- Initial plaintext for the test --- */				\
+#define ECB_TESTX(PRE, pre, name, fname)				\
 									\
-static const octet text[] = TEXT;					\
+static pre##_ctx key;							\
+static pre##_ecbctx ctx;						\
 									\
-/* --- Key and IV to use --- */						\
+static void pre##_ecb_test_setup(const octet *k, size_t ksz)		\
+  { pre##_init(&key, k, ksz); pre##_ecbsetkey(&ctx, &key); }		\
 									\
-static const octet key[] = KEY;						\
-static const octet iv[] = IV;						\
+static void pre##_ecb_test_reset(const octet *iv)			\
+  { ; }									\
 									\
-/* --- Buffers for encryption and decryption output --- */		\
+static void pre##_ecb_test_enc(const octet *s, octet *d, size_t sz)	\
+  { pre##_ecbencrypt(&ctx, s, d, sz); }					\
 									\
-static octet ct[sizeof(text)];						\
-static octet pt[sizeof(text)];						\
+static void pre##_ecb_test_dec(const octet *s, octet *d, size_t sz)	\
+  { pre##_ecbdecrypt(&ctx, s, d, sz); }					\
 									\
-static void hexdump(const octet *p, size_t sz, size_t off)		\
+int main(int argc, char *argv[])					\
 {									\
-  const octet *q = p + sz;						\
-  for (sz = 0; p < q; p++, sz++) {					\
-    printf("%02x", *p);							\
-    if ((off + sz + 1) % PRE##_BLKSZ == 0)				\
-      putchar(':');							\
-  }									\
-}									\
-									\
-int main(void)								\
-{									\
-  size_t sz = 0, rest;							\
-  pre##_ecbctx ctx;							\
-  int status = 0;							\
-  int done = 0;								\
-									\
-  size_t keysz = PRE##_KEYSZ ?						\
-    PRE##_KEYSZ : strlen((const char *)key);				\
-									\
-  fputs(#pre "-ecb: ", stdout);						\
-									\
-  pre##_ecbinit(&ctx, key, keysz, iv);					\
-									\
-  while (sz <= sizeof(text)) {						\
-    rest = sizeof(text) - sz;						\
-    if ((sz != 0 && sz < PRE##_BLKSZ) ||				\
-	(rest != 0 && rest < PRE##_BLKSZ))				\
-      goto next;							\
-    memcpy(ct, text, sizeof(text));					\
-    pre##_ecbencrypt(&ctx, ct, ct, sz);					\
-    pre##_ecbencrypt(&ctx, ct + sz, ct + sz, rest);			\
-    memcpy(pt, ct, sizeof(text));					\
-    pre##_ecbdecrypt(&ctx, pt, pt, sz);					\
-    pre##_ecbdecrypt(&ctx, pt + sz, pt + sz, rest);			\
-    if (memcmp(pt, text, sizeof(text)) == 0) {				\
-      done++;								\
-      if (sizeof(text) < 40 || done % 8 == 0)				\
-	fputc('.', stdout);						\
-      if (done % 480 == 0)						\
-	fputs("\n\t", stdout);						\
-      fflush(stdout);							\
-    } else {								\
-      printf("\nError (sz = %lu)\n", (unsigned long)sz);		\
-      status = 1;							\
-      printf("\tplaintext      = "); hexdump(text, sz, 0);		\
-	printf(", "); hexdump(text + sz, rest, sz);			\
-	fputc('\n', stdout);						\
-      printf("\tciphertext     = "); hexdump(ct, sz, 0);		\
-	printf(", "); hexdump(ct + sz, rest, sz);			\
-	fputc('\n', stdout);						\
-      printf("\trecovered text = "); hexdump(pt, sz, 0);		\
-	printf(", "); hexdump(pt + sz, rest, sz);			\
-	fputc('\n', stdout);						\
-      fputc('\n', stdout);						\
-    }									\
-  next:									\
-    if (sz < 63)							\
-      sz++;								\
-    else								\
-      sz += 9;								\
-  }									\
-									\
-  fputs(status ? " failed\n" : " ok\n", stdout);			\
-  return (status);							\
+  return test_encmode(fname "-ecb", PRE##_KEYSZ, PRE##_BLKSZ,		\
+		      PRE##_BLKSZ, TEMF_REFALIGN,			\
+		      pre##_ecb_test_setup, pre##_ecb_test_reset,	\
+		      pre##_ecb_test_enc, pre##_ecb_test_dec,		\
+		      argc, argv);					\
 }
 
 #else
-#  define ECB_TEST(PRE, pre)
+#  define ECB_TESTX(PRE, pre, name, fname)
 #endif
 
 /*----- That's all, folks -------------------------------------------------*/