progs/perftest.c: Use from Glibc syscall numbers.

[catacomb] / symm / hmac-def.h

diff --git a/symm/hmac-def.h b/symm/hmac-def.h
index 612cc99..76d578d 100644 (file)
--- a/symm/hmac-def.h
+++ b/symm/hmac-def.h
@@ -67,9 +67,12 @@
                                                                        \
 /* --- Useful constants --- */                                         \
                                                                        \
-const octet pre##_hmackeysz[] = { KSZ_ANY, PRE##_STATESZ };            \
-const octet pre##_sslmackeysz[] = { KSZ_ANY, PRE##_STATESZ };          \
-const octet pre##_nmackeysz[] = { KSZ_SET, 2 * PRE##_STATESZ, 0 };     \
+const octet pre##_hmackeysz[] =                                                \
+  { KSZ_ANY | KSZ_16BIT, PRE##_HASHSZ/256, PRE##_HASHSZ%256 };         \
+const octet pre##_sslmackeysz[] =                                      \
+  { KSZ_ANY | KSZ_16BIT, PRE##_HASHSZ/256, PRE##_HASHSZ%256 };         \
+const octet pre##_nmackeysz[] =                                                \
+  { KSZ_SET | KSZ_16BIT, 2*PRE##_HASHSZ/256, 2*PRE##_HASHSZ%256, 0, 0 }; \
                                                                        \
 /* --- @pre_nmacinit@ --- *                                            \
  *                                                                     \
@@ -109,31 +112,28 @@ void pre##_hmacinit(pre##_mackey *key, const void *k, size_t sz)  \
   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);                                           \
-    pre##_done(&ctx, buf);                                             \
-    kbuf = buf;                                                                \
+    pre##_done(&ctx, hbuf);                                            \
+    kbuf = hbuf;                                                       \
     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);                                                    \
-  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);                                                           \
 }                                                                      \
                                                                        \
@@ -153,29 +153,28 @@ void pre##_sslmacinit(pre##_mackey *key, const void *k, size_t sz)        \
 {                                                                      \
   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);                                           \
-    pre##_done(&ctx, buf);                                             \
-    kbuf = buf;                                                                \
+    pre##_done(&ctx, hbuf);                                            \
+    kbuf = hbuf;                                                       \
     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);                                                    \
-  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);                                                           \
 }                                                                      \
                                                                        \
@@ -208,9 +207,7 @@ void pre##_macinit(pre##_macctx *ctx, const pre##_mackey *key)              \
  */                                                                    \
                                                                        \
 void pre##_machash(pre##_macctx *ctx, const void *buf, size_t sz)      \
-{                                                                      \
-  pre##_hash(&ctx->ctx, buf, sz);                                      \
-}                                                                      \
+  { pre##_hash(&ctx->ctx, buf, sz); }                                  \
                                                                        \
 /* --- @pre_macdone@ --- *                                             \
  *                                                                     \
@@ -232,7 +229,7 @@ void pre##_macdone(pre##_macctx *ctx, void *mac)                    \
                                                                        \
 /* --- Generic MAC interface --- */                                    \
                                                                        \
-static const gmac_ops gkops;                                           \
+static const gmac_ops gkops, gnkops, gsslkops;                         \
 static const ghash_ops gops, gnops, gsslops;                           \
                                                                        \
 typedef struct gkctx {                                                 \
@@ -270,7 +267,7 @@ static gmac *gnkey(const void *k, size_t sz)                                \
   gkctx *gk = S_CREATE(gkctx);                                         \
   const octet *kk = k;                                                 \
   assert(keysz(sz, pre##_nmackeysz) == sz);                            \
-  gk->m.ops = &gkops;                                                  \
+  gk->m.ops = &gnkops;                                                 \
   gk->gops = &gnops;                                                   \
   pre##_nmacinit(&gk->k, kk, kk + PRE##_STATESZ);                      \
   return (&gk->m);                                                     \
@@ -279,7 +276,7 @@ static gmac *gnkey(const void *k, size_t sz)                                \
 static gmac *gsslkey(const void *k, size_t sz)                         \
 {                                                                      \
   gkctx *gk = S_CREATE(gkctx);                                         \
-  gk->m.ops = &gkops;                                                  \
+  gk->m.ops = &gsslkops;                                               \
   gk->gops = &gsslops;                                                 \
   pre##_sslmacinit(&gk->k, k, sz);                                     \
   return (&gk->m);                                                     \
@@ -342,10 +339,10 @@ static const ghash_ops gops =                                             \
   { &gch, ghhash, ghdone, ghdestroy, ghcopy };                         \
 static const gchash gnch = { name "-nmac", PRE##_HASHSZ, ghinit };     \
 static const ghash_ops gnops =                                         \
-  { &gch, ghhash, ghdone, ghdestroy, ghcopy };                         \
+  { &gnch, ghhash, ghdone, ghdestroy, ghcopy };                                \
 static const gchash gsslch = { name "-sslmac", PRE##_HASHSZ, ghinit }; \
 static const ghash_ops gsslops =                                       \
-  { &gch, ghhash, ghdone, ghdestroy, ghcopy };                         \
+  { &gsslch, ghhash, ghdone, ghdestroy, ghcopy };                      \
                                                                        \
 HMAC_TESTX(PRE, pre, name, fname)
 
@@ -362,6 +359,7 @@ HMAC_TESTX(PRE, pre, name, fname)
 
 #include <stdio.h>
 
+#include <mLib/macros.h>
 #include <mLib/dstr.h>
 #include <mLib/quis.h>
 #include <mLib/testrig.h>
@@ -402,7 +400,7 @@ static int macverify(dstr *v)                                               \
       csz -= i;                                                                \
     }                                                                  \
     pre##_macdone(&cctx, d.buf);                                       \
-    if (memcmp(d.buf, v[2].buf, PRE##_HASHSZ) != 0) {                  \
+    if (MEMCMP(d.buf, !=, v[2].buf, PRE##_HASHSZ)) {                   \
       printf("\nfail:\n\tstep = %i\n\tinput = `%s'\n\tkey = ",         \
             *ip, v[0].buf);                                            \
       type_hex.dump(&v[1], stdout);                                    \