base/asm-common.h (x86), and knock-on: Add macros for full-size regs.

[catacomb] / symm / cbc-def.h

diff --git a/symm/cbc-def.h b/symm/cbc-def.h
index 3a5c9a2..480f579 100644 (file)
--- a/symm/cbc-def.h
+++ b/symm/cbc-def.h
@@ -81,9 +81,7 @@
  */                                                                    \
                                                                        \
 void pre##_cbcgetiv(const pre##_cbcctx *ctx, void *iv)                 \
-{                                                                      \
-  BLKC_STORE(PRE, iv, ctx->iv);                                                \
-}                                                                      \
+  { BLKC_STORE(PRE, iv, ctx->a); }                                     \
                                                                        \
 /* --- @pre_cbcsetiv@ --- *                                            \
  *                                                                     \
@@ -96,9 +94,7 @@ void pre##_cbcgetiv(const pre##_cbcctx *ctx, void *iv)                        \
  */                                                                    \
                                                                        \
 void pre##_cbcsetiv(pre##_cbcctx *ctx, const void *iv)                 \
-{                                                                      \
-  BLKC_LOAD(PRE, ctx->iv, iv);                                         \
-}                                                                      \
+  { BLKC_LOAD(PRE, ctx->a, iv); }                                      \
                                                                        \
 /* --- @pre_cbcsetkey@ --- *                                           \
  *                                                                     \
@@ -111,9 +107,7 @@ void pre##_cbcsetiv(pre##_cbcctx *ctx, const void *iv)                      \
  */                                                                    \
                                                                        \
 void pre##_cbcsetkey(pre##_cbcctx *ctx, const pre##_ctx *k)            \
-{                                                                      \
-  ctx->ctx = *k;                                                       \
-}                                                                      \
+  { ctx->ctx = *k; }                                                   \
                                                                        \
 /* --- @pre_cbcinit@ --- *                                             \
  *                                                                     \
@@ -135,8 +129,9 @@ void pre##_cbcinit(pre##_cbcctx *ctx,                                       \
                   const void *iv)                                      \
 {                                                                      \
   static const octet zero[PRE##_BLKSZ] = { 0 };                                \
+                                                                       \
   pre##_init(&ctx->ctx, key, sz);                                      \
-  BLKC_LOAD(PRE, ctx->iv, iv ? iv : zero);                             \
+  BLKC_LOAD(PRE, ctx->a, iv ? iv : zero);                              \
 }                                                                      \
                                                                        \
 /* --- @pre_cbcencrypt@ --- *                                          \
@@ -160,11 +155,13 @@ void pre##_cbcencrypt(pre##_cbcctx *ctx,                          \
 {                                                                      \
   const octet *s = src;                                                        \
   octet *d = dest;                                                     \
+  octet b[PRE##_BLKSZ], bb[PRE##_BLKSZ];                               \
+  octet y;                                                             \
+  unsigned i;                                                          \
                                                                        \
   /* --- Empty blocks are trivial --- */                               \
                                                                        \
-  if (!sz)                                                             \
-    return;                                                            \
+  if (!sz) return;                                                     \
                                                                        \
   /* --- Extra magical case for a short block --- *                    \
    *                                                                   \
@@ -174,18 +171,13 @@ void pre##_cbcencrypt(pre##_cbcctx *ctx,                          \
    */                                                                  \
                                                                        \
   if (sz < PRE##_BLKSZ) {                                              \
-    octet b[PRE##_BLKSZ];                                              \
-    unsigned i;                                                                \
-                                                                       \
-    pre##_eblk(&ctx->ctx, ctx->iv, ctx->iv);                           \
-    BLKC_STORE(PRE, b, ctx->iv);                                       \
-    if (d) {                                                           \
-      for (i = 0; i < sz; i++)                                         \
-       d[i] = b[i] ^ (s ? s[i] : 0);                                   \
-    }                                                                  \
+    pre##_eblk(&ctx->ctx, ctx->a, ctx->a);                             \
+    BLKC_STORE(PRE, b, ctx->a);                                                \
+    if (!d) d = bb;                                                    \
+    for (i = 0; i < sz; i++) d[i] = b[i] ^ (s ? s[i] : 0);             \
     memmove(b, b + sz, PRE##_BLKSZ - sz);                              \
     memcpy(b + PRE##_BLKSZ - sz, d, sz);                               \
-    BLKC_LOAD(PRE, ctx->iv, b);                                                \
+    BLKC_LOAD(PRE, ctx->a, b);                                         \
     return;                                                            \
   }                                                                    \
                                                                        \
@@ -196,16 +188,10 @@ void pre##_cbcencrypt(pre##_cbcctx *ctx,                          \
    * and keep a copy of the ciphertext for the next block.             \
    */                                                                  \
                                                                        \
-  while (sz >= 2 * PRE##_BLKSZ || sz == PRE##_BLKSZ) {                 \
-    if (s) {                                                           \
-      BLKC_XLOAD(PRE, ctx->iv, s);                                     \
-      s += PRE##_BLKSZ;                                                        \
-    }                                                                  \
-    pre##_eblk(&ctx->ctx, ctx->iv, ctx->iv);                           \
-    if (d) {                                                           \
-      BLKC_STORE(PRE, d, ctx->iv);                                     \
-      d += PRE##_BLKSZ;                                                        \
-    }                                                                  \
+  while (sz >= 2*PRE##_BLKSZ || sz == PRE##_BLKSZ) {                   \
+    if (s) { BLKC_XLOAD(PRE, ctx->a, s); s += PRE##_BLKSZ; }           \
+    pre##_eblk(&ctx->ctx, ctx->a, ctx->a);                             \
+    if (d) { BLKC_STORE(PRE, d, ctx->a); d += PRE##_BLKSZ; }           \
     sz -= PRE##_BLKSZ;                                                 \
   }                                                                    \
                                                                        \
@@ -215,8 +201,6 @@ void pre##_cbcencrypt(pre##_cbcctx *ctx,                            \
    */                                                                  \
                                                                        \
   if (sz) {                                                            \
-    octet b[PRE##_BLKSZ];                                              \
-    unsigned i;                                                                \
                                                                        \
     /* --- Let @sz@ be the size of the partial block --- */            \
                                                                        \
@@ -230,9 +214,9 @@ void pre##_cbcencrypt(pre##_cbcctx *ctx,                            \
      * block.                                                          \
      */                                                                        \
                                                                        \
-    if (s) BLKC_XLOAD(PRE, ctx->iv, s);                                        \
-    pre##_eblk(&ctx->ctx, ctx->iv, ctx->iv);                           \
-    BLKC_STORE(PRE, b, ctx->iv);                                       \
+    if (s) BLKC_XLOAD(PRE, ctx->a, s);                                 \
+    pre##_eblk(&ctx->ctx, ctx->a, ctx->a);                             \
+    BLKC_STORE(PRE, b, ctx->a);                                                \
                                                                        \
     /* --- Second stage --- *                                          \
      *                                                                 \
@@ -244,13 +228,13 @@ void pre##_cbcencrypt(pre##_cbcctx *ctx,                          \
     if (s) s += PRE##_BLKSZ;                                           \
     if (d) d += PRE##_BLKSZ;                                           \
     for (i = 0; i < sz; i++) {                                         \
-      register octet x = b[i];                                         \
+      y = b[i];                                                                \
       if (s) b[i] ^= s[i];                                             \
-      if (d) d[i] = x;                                                 \
+      if (d) d[i] = y;                                                 \
     }                                                                  \
-    BLKC_LOAD(PRE, ctx->iv, b);                                                \
-    pre##_eblk(&ctx->ctx, ctx->iv, ctx->iv);                           \
-    if (d) BLKC_STORE(PRE, d - PRE##_BLKSZ, ctx->iv);                  \
+    BLKC_LOAD(PRE, ctx->a, b);                                         \
+    pre##_eblk(&ctx->ctx, ctx->a, ctx->a);                             \
+    if (d) BLKC_STORE(PRE, d - PRE##_BLKSZ, ctx->a);                   \
   }                                                                    \
                                                                        \
   /* --- Done --- */                                                   \
@@ -279,11 +263,14 @@ void pre##_cbcdecrypt(pre##_cbcctx *ctx,                          \
 {                                                                      \
   const octet *s = src;                                                        \
   octet *d = dest;                                                     \
+  uint32 t[PRE##_BLKSZ/4], u[PRE##_BLKSZ/4];                           \
+  octet b[PRE##_BLKSZ], c[PRE##_BLKSZ];                                        \
+  octet y;                                                             \
+  unsigned i;                                                          \
                                                                        \
   /* --- Empty blocks are trivial --- */                               \
                                                                        \
-  if (!sz)                                                             \
-    return;                                                            \
+  if (!sz) return;                                                     \
                                                                        \
   /* --- Extra magical case for a short block --- *                    \
    *                                                                   \
@@ -293,19 +280,12 @@ void pre##_cbcdecrypt(pre##_cbcctx *ctx,                          \
    */                                                                  \
                                                                        \
   if (sz < PRE##_BLKSZ) {                                              \
-    octet b[PRE##_BLKSZ], c[PRE##_BLKSZ];                              \
-    unsigned i;                                                                \
-                                                                       \
-    pre##_eblk(&ctx->ctx, ctx->iv, ctx->iv);                           \
-    BLKC_STORE(PRE, b, ctx->iv);                                       \
-    for (i = 0; i < sz; i++) {                                         \
-      register octet x = s[i];                                         \
-      d[i] = b[i] ^ x;                                                 \
-      c[i] = x;                                                                \
-    }                                                                  \
+    pre##_eblk(&ctx->ctx, ctx->a, ctx->a);                             \
+    BLKC_STORE(PRE, b, ctx->a);                                                \
+    for (i = 0; i < sz; i++) { y = s[i]; d[i] = b[i] ^ y; c[i] = y; }  \
     memmove(b, b + sz, PRE##_BLKSZ - sz);                              \
     memcpy(b + PRE##_BLKSZ - sz, c, sz);                               \
-    BLKC_LOAD(PRE, ctx->iv, b);                                                \
+    BLKC_LOAD(PRE, ctx->a, b);                                         \
     return;                                                            \
   }                                                                    \
                                                                        \
@@ -316,14 +296,11 @@ void pre##_cbcdecrypt(pre##_cbcctx *ctx,                          \
    * and keep a copy of the ciphertext for the next block.             \
    */                                                                  \
                                                                        \
-  while (sz >= 2 * PRE##_BLKSZ || sz == PRE##_BLKSZ) {                 \
-    uint32 b[PRE##_BLKSZ / 4], niv[PRE##_BLKSZ / 4];                   \
-    BLKC_LOAD(PRE, niv, s);                                            \
-    pre##_dblk(&ctx->ctx, niv, b);                                     \
-    BLKC_XSTORE(PRE, d, b, ctx->iv);                                   \
-    BLKC_MOVE(PRE, ctx->iv, niv);                                      \
-    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, u);                                       \
+    BLKC_XSTORE(PRE, d, u, ctx->a); d += PRE##_BLKSZ;                  \
+    BLKC_MOVE(PRE, ctx->a, t);                                         \
     sz -= PRE##_BLKSZ;                                                 \
   }                                                                    \
                                                                        \
@@ -333,9 +310,6 @@ void pre##_cbcdecrypt(pre##_cbcctx *ctx,                            \
    */                                                                  \
                                                                        \
   if (sz) {                                                            \
-    octet b[PRE##_BLKSZ];                                              \
-    uint32 bk[PRE##_BLKSZ / 4], niv[PRE##_BLKSZ / 4];                  \
-    unsigned i;                                                                \
                                                                        \
     /* --- Let @sz@ be the size of the partial block --- */            \
                                                                        \
@@ -347,8 +321,8 @@ void pre##_cbcdecrypt(pre##_cbcctx *ctx,                            \
      * is carried over for the next encryption operation.              \
      */                                                                        \
                                                                        \
-    BLKC_LOAD(PRE, niv, s);                                            \
-    pre##_dblk(&ctx->ctx, niv, bk);                                    \
+    BLKC_LOAD(PRE, t, s);                                              \
+    pre##_dblk(&ctx->ctx, t, u);                                       \
                                                                        \
     /* --- Second stage --- *                                          \
      *                                                                 \
@@ -358,14 +332,10 @@ void pre##_cbcdecrypt(pre##_cbcctx *ctx,                          \
      * three.                                                          \
      */                                                                        \
                                                                        \
-    BLKC_STORE(PRE, b, bk);                                            \
+    BLKC_STORE(PRE, b, u);                                             \
     s += PRE##_BLKSZ;                                                  \
     d += PRE##_BLKSZ;                                                  \
-    for (i = 0; i < sz; i++) {                                         \
-      register octet x = s[i];                                         \
-      d[i] = b[i] ^ x;                                                 \
-      b[i] = x;                                                                \
-    }                                                                  \
+    for (i = 0; i < sz; i++) { y = s[i]; d[i] = b[i] ^ y; b[i] = y; }  \
                                                                        \
     /* --- Third stage --- *                                           \
      *                                                                 \
@@ -373,10 +343,10 @@ void pre##_cbcdecrypt(pre##_cbcctx *ctx,                          \
      * recover the complete plaintext block.                           \
      */                                                                        \
                                                                        \
-    BLKC_LOAD(PRE, bk, b);                                             \
-    pre##_dblk(&ctx->ctx, bk, bk);                                     \
-    BLKC_XSTORE(PRE, d - PRE##_BLKSZ, bk, ctx->iv);                    \
-    BLKC_MOVE(PRE, ctx->iv, niv);                                      \
+    BLKC_LOAD(PRE, u, b);                                              \
+    pre##_dblk(&ctx->ctx, u, u);                                       \
+    BLKC_XSTORE(PRE, d - PRE##_BLKSZ, u, ctx->a);                      \
+    BLKC_MOVE(PRE, ctx->a, t);                                         \
   }                                                                    \
                                                                        \
   /* --- Done --- */                                                   \
@@ -402,29 +372,16 @@ 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##_cbcencrypt(&g->k, s, t, sz);                                   \
-}                                                                      \
+  { gctx *g = (gctx *)c; pre##_cbcencrypt(&g->k, s, t, sz); }          \
                                                                        \
 static void gdecrypt(gcipher *c, const void *s, void *t, size_t sz)    \
-{                                                                      \
-  gctx *g = (gctx *)c;                                                 \
-  pre##_cbcdecrypt(&g->k, s, t, sz);                                   \
-}                                                                      \
+  { gctx *g = (gctx *)c; pre##_cbcdecrypt(&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 void gsetiv(gcipher *c, const void *iv)                         \
-{                                                                      \
-  gctx *g = (gctx *)c;                                                 \
-  pre##_cbcsetiv(&g->k, iv);                                           \
-}                                                                      \
+  { gctx *g = (gctx *)c; pre##_cbcsetiv(&g->k, iv); }                  \
                                                                        \
 static const gcipher_ops gops = {                                      \
   &pre##_cbc,                                                          \