symm/hmac-def.h: Set HMAC keys up in a more principled manner.

No longer does it reach into the hash context and run `HASH_compress' by
hand.

This means that nothing assumes that `HASH_compress' exists any more.

diff --git a/symm/hmac-def.h b/symm/hmac-def.h
index 8e869358b2c0bd60a206e96db9db76577bdd2ee4..e639b8cbeb089a73a1931aac8e840b204b538a0e 100644 (file)
--- a/symm/hmac-def.h
+++ b/symm/hmac-def.h
@@ -113,31 +113,28 @@ void pre##_hmacinit(pre##_mackey *key, const void *k, size_t sz)  \
   int i;                                                               \
   const octet *kbuf = k;                                               \
   pre##_ctx ctx;                                                       \
   int i;                                                               \
   const octet *kbuf = k;                                               \
   pre##_ctx ctx;                                                       \

-  octet buf[PRE##_HASHSZ];                                             \
+  octet hbuf[PRE##_HASHSZ], buf[PRE##_BUFSZ];                          \

                                                                        \
   if (sz > PRE##_BUFSZ)        {                                               \
     pre##_init(&ctx);                                                  \
     pre##_hash(&ctx, k, sz);                                           \
                                                                        \
   if (sz > PRE##_BUFSZ)        {                                               \
     pre##_init(&ctx);                                                  \
     pre##_hash(&ctx, k, sz);                                           \

-    pre##_done(&ctx, buf);                                             \
-    kbuf = buf;                                                                \
+    pre##_done(&ctx, hbuf);                                            \
+    kbuf = hbuf;                                                       \

     sz = PRE##_HASHSZ;                                                 \
   }                                                                    \
                                                                        \
   pre##_init(&ctx);                                                    \
     sz = PRE##_HASHSZ;                                                 \
   }                                                                    \
                                                                        \
   pre##_init(&ctx);                                                    \

-  memset(ctx.buf, 0x5c, PRE##_BUFSZ);                                  \
-  for (i = 0; i < sz; i++)                                             \
-    ctx.buf[i] ^= kbuf[i];                                             \
-  pre##_compress(&ctx, ctx.buf);                                       \
-  pre##_state(&ctx, key->ochain);                                      \
+  memset(buf, 0x5c, PRE##_BUFSZ);                                      \
+  for (i = 0; i < sz; i++) buf[i] ^= kbuf[i];                          \
+  pre##_hash(&ctx, buf, PRE##_BUFSZ);                                  \
+  key->ocount = pre##_state(&ctx, key->ochain);                                \

                                                                        \
   pre##_init(&ctx);                                                    \
                                                                        \
   pre##_init(&ctx);                                                    \

-  memset(ctx.buf, 0x36, PRE##_BUFSZ);                                  \
-  for (i = 0; i < sz; i++)                                             \
-    ctx.buf[i] ^= kbuf[i];                                             \
-  pre##_compress(&ctx, ctx.buf);                                       \
-  pre##_state(&ctx, key->ichain);                                      \
+  memset(buf, 0x36, PRE##_BUFSZ);                                      \
+  for (i = 0; i < sz; i++) buf[i] ^= kbuf[i];                          \
+  pre##_hash(&ctx, buf, PRE##_BUFSZ);                                  \
+  key->icount = pre##_state(&ctx, key->ichain);                                \

                                                                        \
                                                                        \

-  key->ocount = key->icount = PRE##_BUFSZ;                             \

   BURN(ctx);                                                           \
 }                                                                      \
                                                                        \
   BURN(ctx);                                                           \
 }                                                                      \
                                                                        \


@@ -157,29 +154,28 @@ void pre##_sslmacinit(pre##_mackey *key, const void *k, size_t sz)        \
 {                                                                      \
   const octet *kbuf = k;                                               \
   pre##_ctx ctx;                                                       \
 {                                                                      \
   const octet *kbuf = k;                                               \
   pre##_ctx ctx;                                                       \

-  octet buf[PRE##_HASHSZ];                                             \
+  octet hbuf[PRE##_HASHSZ], buf[PRE##_BUFSZ];                          \

                                                                        \
   if (sz > PRE##_BUFSZ)        {                                               \
     pre##_init(&ctx);                                                  \
     pre##_hash(&ctx, k, sz);                                           \
                                                                        \
   if (sz > PRE##_BUFSZ)        {                                               \
     pre##_init(&ctx);                                                  \
     pre##_hash(&ctx, k, sz);                                           \

-    pre##_done(&ctx, buf);                                             \
-    kbuf = buf;                                                                \
+    pre##_done(&ctx, hbuf);                                            \
+    kbuf = hbuf;                                                       \

     sz = PRE##_HASHSZ;                                                 \
   }                                                                    \
                                                                        \
   pre##_init(&ctx);                                                    \
     sz = PRE##_HASHSZ;                                                 \
   }                                                                    \
                                                                        \
   pre##_init(&ctx);                                                    \

-  memcpy(ctx.buf, kbuf, sz);                                           \
-  memset(ctx.buf + sz, 0x5c, PRE##_BUFSZ - sz);                                \
-  pre##_compress(&ctx, ctx.buf);                                       \
-  pre##_state(&ctx, key->ochain);                                      \
+  memcpy(buf, kbuf, sz);                                               \
+  memset(buf + sz, 0x5c, PRE##_BUFSZ - sz);                            \
+  pre##_hash(&ctx, buf, PRE##_BUFSZ);                                  \
+  key->ocount = pre##_state(&ctx, key->ochain);                                \

                                                                        \
   pre##_init(&ctx);                                                    \
                                                                        \
   pre##_init(&ctx);                                                    \

-  memcpy(ctx.buf, kbuf, sz);                                           \
-  memset(ctx.buf + sz, 0x36, PRE##_BUFSZ - sz);                                \
-  pre##_compress(&ctx, ctx.buf);                                       \
-  pre##_state(&ctx, key->ichain);                                      \
+  memcpy(buf, kbuf, sz);                                               \
+  memset(buf + sz, 0x36, PRE##_BUFSZ - sz);                            \
+  pre##_hash(&ctx, buf, PRE##_BUFSZ);                                  \
+  key->icount = pre##_state(&ctx, key->ichain);                                \

                                                                        \
                                                                        \

-  key->ocount = key->icount = PRE##_BUFSZ;                             \

   BURN(ctx);                                                           \
 }                                                                      \
                                                                        \
   BURN(ctx);                                                           \
 }                                                                      \
                                                                        \