1 files changed, 57 insertions, 47 deletions

diff --git a/src/lib/libcrypto/modes/cbc128.c b/src/lib/libcrypto/modes/cbc128.c
index f2eebc6e7a..27a2241ad4 100644
--- a/src/lib/libcrypto/modes/cbc128.c
+++ b/src/lib/libcrypto/modes/cbc128.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cbc128.c,v 1.6 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: cbc128.c,v 1.7 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
@@ -66,117 +66,127 @@
 #define STRICT_ALIGNMENT 0
 #endif
 
-void CRYPTO_cbc128_encrypt(const unsigned char *in, unsigned char *out,
-                        size_t len, const void *key,
-                        unsigned char ivec[16], block128_f block)
+void
+CRYPTO_cbc128_encrypt(const unsigned char *in, unsigned char *out,
+    size_t len, const void *key,
+    unsigned char ivec[16], block128_f block)
 {
         size_t n;
         const unsigned char *iv = ivec;
 
 #if !defined(OPENSSL_SMALL_FOOTPRINT)
         if (STRICT_ALIGNMENT &&
-            ((size_t)in|(size_t)out|(size_t)ivec)%sizeof(size_t) != 0) {
-                while (len>=16) {
-                        for(n=0; n<16; ++n)
+            ((size_t)in|(size_t)out|(size_t)ivec) % sizeof(size_t) != 0) {
+                while (len >= 16) {
+                        for (n = 0; n < 16; ++n)
                                 out[n] = in[n] ^ iv[n];
                         (*block)(out, out, key);
                         iv = out;
                         len -= 16;
-                        in  += 16;
+                        in += 16;
                         out += 16;
                 }
         } else {
-                while (len>=16) {
-                        for(n=0; n<16; n+=sizeof(size_t))
-                                *(size_t*)(out+n) =
-                                *(size_t*)(in+n) ^ *(size_t*)(iv+n);
+                while (len >= 16) {
+                        for (n = 0; n < 16; n += sizeof(size_t))
+                                *(size_t *)(out + n) =
+                                    *(size_t *)(in + n) ^ *(size_t *)(iv + n);
                         (*block)(out, out, key);
                         iv = out;
                         len -= 16;
-                        in  += 16;
+                        in += 16;
                         out += 16;
                 }
         }
 #endif
         while (len) {
-                for(n=0; n<16 && n<len; ++n)
+                for (n = 0; n < 16 && n < len; ++n)
                         out[n] = in[n] ^ iv[n];
-                for(; n<16; ++n)
+                for (; n < 16; ++n)
                         out[n] = iv[n];
                 (*block)(out, out, key);
                 iv = out;
-                if (len<=16) break;
+                if (len <= 16)
+                        break;
                 len -= 16;
-                in  += 16;
+                in += 16;
                 out += 16;
         }
-        memmove(ivec,iv,16);
+        memmove(ivec, iv, 16);
 }
 
-void CRYPTO_cbc128_decrypt(const unsigned char *in, unsigned char *out,
-                        size_t len, const void *key,
-                        unsigned char ivec[16], block128_f block)
+void
+CRYPTO_cbc128_decrypt(const unsigned char *in, unsigned char *out,
+    size_t len, const void *key,
+    unsigned char ivec[16], block128_f block)
 {
         size_t n;
-        union { size_t t[16/sizeof(size_t)]; unsigned char c[16]; } tmp;
+        union {
+                size_t t[16/sizeof(size_t)];
+                unsigned char c[16];
+        } tmp;
 
 #if !defined(OPENSSL_SMALL_FOOTPRINT)
         if (in != out) {
                 const unsigned char *iv = ivec;
 
                 if (STRICT_ALIGNMENT &&
-                    ((size_t)in|(size_t)out|(size_t)ivec)%sizeof(size_t) != 0) {
-                        while (len>=16) {
+                    ((size_t)in|(size_t)out|(size_t)ivec) % sizeof(size_t) !=
+                    0) {
+                        while (len >= 16) {
                                 (*block)(in, out, key);
-                                for(n=0; n<16; ++n)
+                                for (n = 0; n < 16; ++n)
                                         out[n] ^= iv[n];
                                 iv = in;
                                 len -= 16;
-                                in  += 16;
+                                in += 16;
                                 out += 16;
                         }
-                } else if (16%sizeof(size_t) == 0) { /* always true */
-                        while (len>=16) {
-                                size_t *out_t=(size_t *)out, *iv_t=(size_t *)iv;
+                } else if (16 % sizeof(size_t) == 0) { /* always true */
+                        while (len >= 16) {
+                                size_t *out_t = (size_t *)out,
+                                       *iv_t = (size_t *)iv;
 
                                 (*block)(in, out, key);
-                                for(n=0; n<16/sizeof(size_t); n++)
+                                for (n = 0; n < 16/sizeof(size_t); n++)
                                         out_t[n] ^= iv_t[n];
                                 iv = in;
                                 len -= 16;
-                                in  += 16;
+                                in += 16;
                                 out += 16;
                         }
                 }
-                memmove(ivec,iv,16);
+                memmove(ivec, iv, 16);
         } else {
                 if (STRICT_ALIGNMENT &&
-                    ((size_t)in|(size_t)out|(size_t)ivec)%sizeof(size_t) != 0) {
+                    ((size_t)in|(size_t)out|(size_t)ivec) % sizeof(size_t) !=
+                    0) {
                         unsigned char c;
-                        while (len>=16) {
+                        while (len >= 16) {
                                 (*block)(in, tmp.c, key);
-                                for(n=0; n<16; ++n) {
+                                for (n = 0; n < 16; ++n) {
                                         c = in[n];
                                         out[n] = tmp.c[n] ^ ivec[n];
                                         ivec[n] = c;
                                 }
                                 len -= 16;
-                                in  += 16;
+                                in += 16;
                                 out += 16;
                         }
-                } else if (16%sizeof(size_t) == 0) { /* always true */
-                        while (len>=16) {
-                                size_t c, *out_t=(size_t *)out, *ivec_t=(size_t *)ivec;
-                                const size_t *in_t=(const size_t *)in;
+                } else if (16 % sizeof(size_t) == 0) { /* always true */
+                        while (len >= 16) {
+                                size_t c, *out_t = (size_t *)out,
+                                       *ivec_t = (size_t *)ivec;
+                                const size_t *in_t = (const size_t *)in;
 
                                 (*block)(in, tmp.c, key);
-                                for(n=0; n<16/sizeof(size_t); n++) {
+                                for (n = 0; n < 16/sizeof(size_t); n++) {
                                         c = in_t[n];
                                         out_t[n] = tmp.t[n] ^ ivec_t[n];
                                         ivec_t[n] = c;
                                 }
                                 len -= 16;
-                                in  += 16;
+                                in += 16;
                                 out += 16;
                         }
                 }
@@ -185,18 +195,18 @@ void CRYPTO_cbc128_decrypt(const unsigned char *in, unsigned char *out,
         while (len) {
                 unsigned char c;
                 (*block)(in, tmp.c, key);
-                for(n=0; n<16 && n<len; ++n) {
+                for (n = 0; n < 16 && n < len; ++n) {
                         c = in[n];
                         out[n] = tmp.c[n] ^ ivec[n];
                         ivec[n] = c;
                 }
-                if (len<=16) {
-                        for (; n<16; ++n)
+                if (len <= 16) {
+                        for (; n < 16; ++n)
                                 ivec[n] = in[n];
                         break;
                 }
                 len -= 16;
-                in  += 16;
+                in += 16;
                 out += 16;
         }
 }