X-Git-Url: https://git.distorted.org.uk/~mdw/catacomb/blobdiff_plain/8276a9c565bc29afbc6cc120dfde0801c06c2bbd..1519ef6617fd7351bd40026b9eeb47c7f7f42234:/symm/mgf-def.h

diff --git a/symm/mgf-def.h b/symm/mgf-def.h
index 832cd074..0b2df3d6 100644
--- a/symm/mgf-def.h
+++ b/symm/mgf-def.h
@@ -82,16 +82,10 @@ const octet pre##_mgfkeysz[] = { KSZ_ANY, PRE##_HASHSZ };		\
  */									\
 									\
 void pre##_mgfkeybegin(pre##_mgfctx *k)					\
-{									\
-  k->c = 0;								\
-  k->bsz = 0;								\
-  pre##_init(&k->k);							\
-}									\
+  { k->c = 0; k->off = 0; pre##_init(&k->k); }				\
 									\
 void pre##_mgfkeyadd(pre##_mgfctx *k, const void *p, size_t sz)		\
-{									\
-  pre##_hash(&k->k, p, sz);						\
-}									\
+  { pre##_hash(&k->k, p, sz); }						\
 									\
 /* ---- @pre_mgfinit@ --- *						\
  *									\
@@ -106,12 +100,7 @@ void pre##_mgfkeyadd(pre##_mgfctx *k, const void *p, size_t sz)		\
  */									\
 									\
 void pre##_mgfinit(pre##_mgfctx *k, const void *p, size_t sz)		\
-{									\
-  k->c = 0;								\
-  k->bsz = 0;								\
-  pre##_init(&k->k);							\
-  pre##_hash(&k->k, p, sz);						\
-}									\
+  { k->c = 0; k->off = 0; pre##_init(&k->k); pre##_hash(&k->k, p, sz); } \
 									\
 /* --- @pre_mgfencrypt@ --- *						\
  *									\
@@ -133,54 +122,35 @@ void pre##_mgfinit(pre##_mgfctx *k, const void *p, size_t sz)		\
 void pre##_mgfencrypt(pre##_mgfctx *k, const void *s,			\
 		      void *d, size_t sz)				\
 {									\
+  pre##_ctx h;								\
   const octet *ss = s;							\
   octet *dd = d;							\
+  const octet *p;							\
+  size_t off;								\
 									\
   /* --- Empty the buffer if there's anything there --- */		\
 									\
-  if (k->bsz) {								\
-    const octet *p = k->buf + PRE##_HASHSZ - k->bsz;			\
-    size_t n = sz > k->bsz ? k->bsz : sz;				\
-    sz -= n;								\
-    k->bsz -= n;							\
-    if (dd) {								\
-      if (!ss) {							\
-	memcpy(dd, p, n);						\
-	dd += n;							\
-      } else {								\
-	while (n) {							\
-	  *dd++ = *ss++ ^ *p++;						\
-	  n--;								\
-	}								\
-      }									\
-    }									\
+  if (k->off) {								\
+    p = k->b + PRE##_HASHSZ - k->off;					\
+    off = sz > k->off ? k->off : sz;					\
+    sz -= off; k->off -= off;						\
+    if (!dd) /* do nothing */;						\
+    else if (!ss) { memcpy(dd, p, off); dd += off; }			\
+    else while (off--) *dd++ = *ss++ ^ *p++;				\
   }									\
 									\
   /* --- While necessary, generate some more mask --- */		\
 									\
   while (sz) {								\
-    pre##_ctx c = k->k;		/* Not quick! */			\
-    size_t n;								\
-									\
-    STORE32(k->buf, k->c);						\
-    k->c++;								\
-    pre##_hash(&c, k->buf, 4);						\
-    pre##_done(&c, k->buf);						\
-    n = sz > PRE##_HASHSZ ? PRE##_HASHSZ : sz;				\
-    k->bsz = PRE##_HASHSZ - n;						\
-    sz -= n;								\
-    if (dd) {								\
-      const octet *p = k->buf;						\
-      if (!ss) {							\
-	memcpy(dd, p, n);						\
-	dd += n;							\
-      } else {								\
-	while (n) {							\
-	  *dd++ = *ss++ ^ *p++;						\
-	  n--;								\
-	}								\
-      }									\
-    }									\
+    STORE32(k->b, k->c); k->c++;					\
+    h = k->k; pre##_hash(&h, k->b, 4); pre##_done(&h, k->b);		\
+    off = sz > PRE##_HASHSZ ? PRE##_HASHSZ : sz;			\
+    k->off = PRE##_HASHSZ - off;					\
+    sz -= off;								\
+    p = k->b;								\
+    if (!dd) /* do nothing */;						\
+    else if (!ss) { memcpy(dd, p, off); dd += off; }			\
+    else while (off--) *dd++ = *ss++ ^ *p++;				\
   }									\
 }									\
 									\
@@ -196,10 +166,7 @@ void pre##_mgfencrypt(pre##_mgfctx *k, const void *s,			\
  */									\
 									\
 void pre##_mgfsetindex(pre##_mgfctx *k, uint32 c)			\
-{									\
-  k->c = c;								\
-  k->bsz = 0;								\
-}									\
+  { k->c = c; k->off = 0; }						\
 									\
 /* --- Generic cipher interface --- */					\
 									\
@@ -219,17 +186,10 @@ 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##_mgfencrypt(&g->k, s, t, sz);					\
-}									\
+  { gctx *g = (gctx *)c; pre##_mgfencrypt(&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##_mgf,								\
@@ -320,10 +280,7 @@ static uint32 grword(grand *r)						\
 }									\
 									\
 static void grfill(grand *r, void *p, size_t sz)			\
-{									\
-  grctx *g = (grctx *)r;						\
-  pre##_mgfencrypt(&g->k, 0, p, sz);					\
-}									\
+  { grctx *g = (grctx *)r; pre##_mgfencrypt(&g->k, 0, p, sz); }		\
 									\
 static const grand_ops grops = {					\
   name "-mgf",								\
@@ -359,9 +316,7 @@ MGF_TESTX(PRE, pre, name, fname)
 
 #ifdef TEST_RIG
 
-#include <stdio.h>
-
-#include "daftstory.h"
+#include "modes-test.h"
 
 /* --- @MGF_TEST@ --- *
  *
@@ -372,81 +327,23 @@ MGF_TESTX(PRE, pre, name, fname)
 
 #define MGF_TESTX(PRE, pre, name, fname)				\
 									\
-/* --- Initial plaintext for the test --- */				\
-									\
-static const octet text[] = TEXT;					\
+static pre##_mgfctx ctx;						\
 									\
-/* --- Key and IV to use --- */						\
+static void pre##_mgf_test_setup(const octet *k, size_t ksz)		\
+  { pre##_mgfinit(&ctx, k, ksz); }					\
 									\
-static const octet key[] = KEY;						\
+static void pre##_mgf_test_reset(const octet *iv)			\
+  { pre##_mgfsetindex(&ctx, 0); }					\
 									\
-/* --- Buffers for encryption and decryption output --- */		\
+static void pre##_mgf_test_enc(const octet *s, octet *d, size_t sz)	\
+  { pre##_mgfencrypt(&ctx, s, d, sz); }					\
 									\
-static octet ct[sizeof(text)];						\
-static octet pt[sizeof(text)];						\
-									\
-static void hexdump(const octet *p, size_t sz)				\
+int main(int argc, char *argv[])					\
 {									\
-  const octet *q = p + sz;						\
-  for (sz = 0; p < q; p++, sz++) {					\
-    printf("%02x", *p);							\
-    if ((sz + 1) % PRE##_HASHSZ == 0)					\
-      putchar(':');							\
-  }									\
-}									\
-									\
-int main(void)								\
-{									\
-  size_t sz = 0, rest;							\
-  pre##_mgfctx ctx;							\
-  int status = 0;							\
-  int done = 0;								\
-									\
-  size_t keysz = strlen((const char *)key);				\
-									\
-  fputs(name "-mgf: ", stdout);						\
-									\
-  pre##_mgfinit(&ctx, key, keysz);					\
-									\
-  while (sz <= sizeof(text)) {						\
-    rest = sizeof(text) - sz;						\
-    memcpy(ct, text, sizeof(text));					\
-    pre##_mgfsetindex(&ctx, 0);						\
-    pre##_mgfencrypt(&ctx, ct, ct, sz);					\
-    pre##_mgfencrypt(&ctx, ct + sz, ct + sz, rest);			\
-    memcpy(pt, ct, sizeof(text));					\
-    pre##_mgfsetindex(&ctx, 0);						\
-    pre##_mgfencrypt(&ctx, pt, pt, rest);				\
-    pre##_mgfencrypt(&ctx, pt + rest, pt + rest, sz);			\
-    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);			\
-	printf(", "); hexdump(text + sz, rest);				\
-	fputc('\n', stdout);						\
-      printf("\tciphertext     = "); hexdump(ct, sz);			\
-	printf(", "); hexdump(ct + sz, rest);				\
-	fputc('\n', stdout);						\
-      printf("\trecovered text = "); hexdump(pt, sz);			\
-	printf(", "); hexdump(pt + sz, rest);				\
-	fputc('\n', stdout);						\
-      fputc('\n', stdout);						\
-    }									\
-    if (sz < 63)							\
-      sz++;								\
-    else								\
-      sz += 9;								\
-  }									\
-									\
-  fputs(status ? " failed\n" : " ok\n", stdout);			\
-  return (status);							\
+  return test_encmode(fname "-mgf", 0, PRE##_HASHSZ, 1, 0,		\
+		      pre##_mgf_test_setup, pre##_mgf_test_reset,	\
+		      pre##_mgf_test_enc, pre##_mgf_test_enc,		\
+		      argc, argv);					\
 }
 
 #else