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

[catacomb] / symm / ecb-def.h

diff --git a/symm/ecb-def.h b/symm/ecb-def.h
index 026343c..c69790d 100644 (file)
--- a/symm/ecb-def.h
+++ b/symm/ecb-def.h
@@ -80,9 +80,7 @@
  */                                                                    \
                                                                        \
 void pre##_ecbsetkey(pre##_ecbctx *ctx, const pre##_ctx *k)            \
-{                                                                      \
-  ctx->ctx = *k;                                                       \
-}                                                                      \
+  { ctx->ctx = *k; }                                                   \
                                                                        \
 /* --- @pre_ecbinit@ --- *                                             \
  *                                                                     \
@@ -98,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@ --- *                                          \
  *                                                                     \
@@ -120,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 --- *                      \
    *                                                                   \
@@ -146,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;                                                 \
   }                                                                    \
                                                                        \
@@ -168,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 --- */            \
                                                                        \
@@ -183,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 --- *                                          \
      *                                                                 \
@@ -199,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 --- */                                                   \
@@ -236,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 --- *                      \
    *                                                                   \
@@ -256,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;                                                 \
   }                                                                    \
                                                                        \
@@ -272,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 --- */            \
                                                                        \
@@ -286,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 --- *                                          \
      *                                                                 \
@@ -299,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 --- */                                                   \
@@ -332,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,                                                          \