modes/ocb128.c: ocb_lookup_l to allow non-contiguous lookup

[openssl.git] / crypto / modes / ofb128.c

diff --git a/crypto/modes/ofb128.c b/crypto/modes/ofb128.c
index ae264c832c5fefba52f611d2fe265917a383dc24..4dbaccd7a6aebe7d670338e390d342f7ff9978bc 100644 (file)
--- a/crypto/modes/ofb128.c
+++ b/crypto/modes/ofb128.c
@@ -6,7 +6,7 @@
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer. 
+ *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
@@ -48,7 +48,8 @@
  *
  */
 
-#include <stddef.h>
+#include <openssl/crypto.h>
+#include "modes_lcl.h"
 #include <string.h>
 
 #ifndef MODES_DEBUG
@@ -58,73 +59,66 @@
 #endif
 #include <assert.h>
 
-#include "modes.h"
-
-#define STRICT_ALIGNMENT
-#if defined(__i386) || defined(__i386__) || \
-    defined(__x86_64) || defined(__x86_64__) || \
-    defined(_M_IX86) || defined(_M_AMD64) || defined(_M_X64) || \
-    defined(__s390__) || defined(__s390x__)
-#  undef STRICT_ALIGNMENT
-#endif
-
-/* The input and output encrypted as though 128bit ofb mode is being
- * used.  The extra state information to record how much of the
- * 128bit block we have used is contained in *num;
+/*
+ * The input and output encrypted as though 128bit ofb mode is being used.
+ * The extra state information to record how much of the 128bit block we have
+ * used is contained in *num;
  */
 void CRYPTO_ofb128_encrypt(const unsigned char *in, unsigned char *out,
-                       size_t len, const void *key,
-                       unsigned char ivec[16], int *num,
-                       block_f block)
+                           size_t len, const void *key,
+                           unsigned char ivec[16], int *num, block128_f block)
 {
-       unsigned int n;
-       size_t l=0;
+    unsigned int n;
+    size_t l = 0;
 
-       assert(in && out && key && ivec && num);
+    assert(in && out && key && ivec && num);
 
-       n = *num;
+    n = *num;
 
 #if !defined(OPENSSL_SMALL_FOOTPRINT)
-       if (16%sizeof(size_t) == 0) do { /* always true actually */
-               while (n && len) {
-                       *(out++) = *(in++) ^ ivec[n];
-                       --len;
-                       n = (n+1) % 16;
-               }
-#if defined(STRICT_ALIGNMENT)
-               if (((size_t)in|(size_t)out|(size_t)ivec)%sizeof(size_t) != 0)
-                       break;
-#endif
-               while (len>=16) {
-                       (*block)(ivec, ivec, key);
-                       for (n=0; n<16; n+=sizeof(size_t))
-                               *(size_t*)(out+n) =
-                               *(size_t*)(in+n) ^ *(size_t*)(ivec+n);
-                       len -= 16;
-                       out += 16;
-                       in  += 16;
-               }
-               n = 0;
-               if (len) {
-                       (*block)(ivec, ivec, key);
-                       while (len--) {
-                               out[n] = in[n] ^ ivec[n];
-                               ++n;
-                       }
-               }
-               *num = n;
-               return;
-       } while(0);
-       /* the rest would be commonly eliminated by x86* compiler */
+    if (16 % sizeof(size_t) == 0) { /* always true actually */
+        do {
+            while (n && len) {
+                *(out++) = *(in++) ^ ivec[n];
+                --len;
+                n = (n + 1) % 16;
+            }
+# if defined(STRICT_ALIGNMENT)
+            if (((size_t)in | (size_t)out | (size_t)ivec) % sizeof(size_t) !=
+                0)
+                break;
+# endif
+            while (len >= 16) {
+                (*block) (ivec, ivec, key);
+                for (; n < 16; n += sizeof(size_t))
+                    *(size_t *)(out + n) =
+                        *(size_t *)(in + n) ^ *(size_t *)(ivec + n);
+                len -= 16;
+                out += 16;
+                in += 16;
+                n = 0;
+            }
+            if (len) {
+                (*block) (ivec, ivec, key);
+                while (len--) {
+                    out[n] = in[n] ^ ivec[n];
+                    ++n;
+                }
+            }
+            *num = n;
+            return;
+        } while (0);
+    }
+    /* the rest would be commonly eliminated by x86* compiler */
 #endif
-       while (l<len) {
-               if (n==0) {
-                       (*block)(ivec, ivec, key);
-               }
-               out[l] = in[l] ^ ivec[n];
-               ++l;
-               n = (n+1) % 16;
-       }
+    while (l < len) {
+        if (n == 0) {
+            (*block) (ivec, ivec, key);
+        }
+        out[l] = in[l] ^ ivec[n];
+        ++l;
+        n = (n + 1) % 16;
+    }
 
-       *num=n;
+    *num = n;
 }