1 files changed, 42 insertions, 38 deletions

diff --git a/src/lib/libcrypto/modes/ofb128.c b/src/lib/libcrypto/modes/ofb128.c
index 3cf5d98150..9ef812a08b 100644
--- a/src/lib/libcrypto/modes/ofb128.c
+++ b/src/lib/libcrypto/modes/ofb128.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ofb128.c,v 1.5 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: ofb128.c,v 1.6 2023/07/08 14:55:36 beck Exp $ */
 /* ====================================================================
  * Copyright (c) 2008 The OpenSSL Project.  All rights reserved.
  *
@@ -7,7 +7,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
@@ -63,57 +63,61 @@
  * 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,
-                        block128_f block)
+void
+CRYPTO_ofb128_encrypt(const unsigned char *in, unsigned char *out,
+    size_t len, const void *key,
+    unsigned char ivec[16], int *num,
+    block128_f block)
 {
         unsigned int n;
-        size_t l=0;
+        size_t l = 0;
 
         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 (16 % sizeof(size_t) == 0)
+                do { /* always true actually */
+                        while (n && len) {
+                                *(out++) = *(in++) ^ ivec[n];
+                                --len;
+                                n = (n + 1) % 16;
+                        }
 #ifdef __STRICT_ALIGNMENT
-                if (((size_t)in|(size_t)out|(size_t)ivec)%sizeof(size_t) != 0)
-                        break;
+                        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;
+                        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;
                         }
-                }
-                *num = n;
-                return;
-        } while(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) {
+        while (l < len) {
+                if (n == 0) {
                         (*block)(ivec, ivec, key);
                 }
                 out[l] = in[l] ^ ivec[n];
                 ++l;
-                n = (n+1) % 16;
+                n = (n + 1) % 16;
         }
 
-        *num=n;
+        *num = n;
 }