X-Git-Url: https://git.distorted.org.uk/~mdw/catacomb/blobdiff_plain/0fee61eb2ff1807c5f32a34499ef2753b6fcd9a5..HEAD:/symm/ofb-def.h

diff --git a/symm/ofb-def.h b/symm/ofb-def.h
index 10f799c3..e065f08a 100644
--- a/symm/ofb-def.h
+++ b/symm/ofb-def.h
@@ -56,6 +56,10 @@
 #  include "paranoia.h"
 #endif
 
+#ifndef CATACOMB_RSVR_H
+#  include "rsvr.h"
+#endif
+
 /*----- Macros ------------------------------------------------------------*/
 
 /* --- @OFB_DEF@ --- *
@@ -103,7 +107,7 @@ void pre##_ofbgetiv(const pre##_ofbctx *ctx, void *iv)			\
  */									\
 									\
 void pre##_ofbsetiv(pre##_ofbctx *ctx, const void *iv)			\
-  { memcpy(ctx->b, iv, PRE##_BLKSZ); ctx->off = PRE##_BLKSZ; }		\
+  { memcpy(ctx->b, iv, PRE##_BLKSZ); ctx->off = 0; }			\
 									\
 /* --- @pre_ofbbdry@ --- *						\
  *									\
@@ -122,7 +126,7 @@ void pre##_ofbbdry(pre##_ofbctx *ctx)					\
   BLKC_LOAD(PRE, t, ctx->b);						\
   pre##_eblk(&ctx->ctx, t, t);						\
   BLKC_STORE(PRE, ctx->b, t);						\
-  ctx->off = PRE##_BLKSZ;						\
+  ctx->off = 0;								\
   BURN(t);								\
 }									\
 									\
@@ -181,62 +185,67 @@ void pre##_ofbinit(pre##_ofbctx *ctx,					\
  *		cipher as a random data generator.			\
  */									\
 									\
+static const rsvr_policy pre##_ofbpolicy = { 0, PRE##_BLKSZ, PRE##_BLKSZ }; \
+									\
 void pre##_ofbencrypt(pre##_ofbctx *ctx,				\
 		      const void *src, void *dest,			\
 		      size_t sz)					\
 {									\
-  const octet *s = src;							\
+  rsvr_plan plan;							\
+  const octet *s = src, *p;						\
   octet *d = dest;							\
-  unsigned off = ctx->off;						\
   uint32 t[PRE##_BLKSZ/4], u[PRE##_BLKSZ/4];				\
-  octet y;								\
-									\
-  /* --- Empty blocks are trivial --- */				\
-									\
-  if (!sz) return;							\
-									\
-  /* --- If I can deal with the block from my buffer, do that --- */	\
-									\
-  if (sz < PRE##_BLKSZ - off) goto small;				\
-									\
-  /* --- Finish off what's left in my buffer --- */			\
-									\
-  if (!d) sz -= PRE##_BLKSZ - off;					\
-  else while (off < PRE##_BLKSZ)					\
-    { y = s ? *s++ : 0; *d++ = ctx->b[off++] ^ y; sz--; }		\
-									\
-  /* --- Main encryption loop --- */					\
 									\
+  /* Construct a plan and prepare to follow through. */			\
+  rsvr_mkplan(&plan, &pre##_ofbpolicy, ctx->off, sz);			\
   BLKC_LOAD(PRE, t, ctx->b);						\
 									\
-  for (;;) {								\
-    pre##_eblk(&ctx->ctx, t, t);					\
-    if (sz < PRE##_BLKSZ) break;					\
-    if (!d) /* do nothing */;						\
-    else if (!s) { BLKC_STORE(PRE, d, t); d += PRE##_BLKSZ; }		\
-    else {								\
-      BLKC_LOAD(PRE, u, s); s += PRE##_BLKSZ;				\
-      BLKC_XSTORE(PRE, d, t, u); d += PRE##_BLKSZ;			\
+  /* Initial portion, fulfilled from the buffer.  If the chunk is small	\
+   * enough, then this will be the only portion.  If the buffer is	\
+   * currently empty, then we must prepare it.				\
+   */									\
+  if (plan.head) {							\
+    if (!ctx->off) {							\
+      pre##_eblk(&ctx->ctx, t, t);					\
+      BLKC_STORE(PRE, ctx->b, t);					\
     }									\
-    sz -= PRE##_BLKSZ;							\
+    p = ctx->b + ctx->off; ctx->off += plan.head;			\
+    if (!d) /* nothing to do */;					\
+    else if (!s) { memcpy(d, p, plan.head); d += plan.head; }		\
+    else while (plan.head--) *d++ = *s++ ^ *p++;			\
   }									\
 									\
-  BLKC_STORE(PRE, ctx->b, t);						\
-  off = 0;								\
+  /* If the buffer is all used, then reset it ready for next time. */	\
+  ctx->off -= plan.from_rsvr;						\
 									\
-  /* --- Tidying up the tail end --- */					\
-									\
-  if (sz) {								\
-  small:								\
-    if (!d) off += sz;							\
-    else do { y = s ? *s++ : 0; *d++ = ctx->b[off++] ^ y; sz--; }	\
-    while (sz);								\
+  /* Handle multiple whole blocks. */					\
+  if (!d) while (plan.from_input) {					\
+    pre##_eblk(&ctx->ctx, t, t);					\
+    plan.from_input -= PRE##_BLKSZ;					\
+  } else if (!s) while (plan.from_input) {				\
+    pre##_eblk(&ctx->ctx, t, t);					\
+    BLKC_STORE(PRE, d, t); d += PRE##_BLKSZ;				\
+    plan.from_input -= PRE##_BLKSZ;					\
+  } else while (plan.from_input) {					\
+    pre##_eblk(&ctx->ctx, t, t);					\
+    BLKC_LOAD(PRE, u, s); s += PRE##_BLKSZ;				\
+    BLKC_XSTORE(PRE, d, t, u); d += PRE##_BLKSZ;			\
+    plan.from_input -= PRE##_BLKSZ;					\
   }									\
 									\
-  /* --- Done --- */							\
-									\
-  ctx->off = off;							\
-  return;								\
+  /* Final portion.  Note that the buffer must be empty if there is a	\
+   * tail, since otherwise the input data would have been part of the	\
+   * head portion instad. */						\
+  if (!plan.tail)							\
+    BLKC_STORE(PRE, ctx->b, t);						\
+  else {								\
+    pre##_eblk(&ctx->ctx, t, t);					\
+    BLKC_STORE(PRE, ctx->b, t);						\
+    p = ctx->b; ctx->off += plan.tail;					\
+    if (!d) /* nothing to do */;					\
+    else if (!s) { memcpy(d, p, plan.tail); d += plan.tail; }		\
+    else while (plan.tail--) *d++ = *s++ ^ *p++;			\
+  }									\
 }									\
 									\
 /* --- Generic cipher interface --- */					\