key/key-io.c: Add low-level `key_mergeline' and `key_extractline' functions.

[catacomb] / symm / mgf-def.h

diff --git a/symm/mgf-def.h b/symm/mgf-def.h
index aad09a4..0b2df3d 100644 (file)
--- 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",                                                         \