5 files changed, 127 insertions, 134 deletions

diff --git a/src/lib/libcrypto/modes/ccm128.c b/src/lib/libcrypto/modes/ccm128.c
index 0f592dd9e5..c4df198c0b 100644
--- a/src/lib/libcrypto/modes/ccm128.c
+++ b/src/lib/libcrypto/modes/ccm128.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ccm128.c,v 1.10 2025/04/21 16:01:18 jsing Exp $ */
+/* $OpenBSD: ccm128.c,v 1.11 2025/05/18 09:05:59 jsing Exp $ */
 /* ====================================================================
  * Copyright (c) 2011 The OpenSSL Project.  All rights reserved.
  *
@@ -61,7 +61,7 @@ CRYPTO_ccm128_init(CCM128_CONTEXT *ctx,
     unsigned int M, unsigned int L, void *key, block128_f block)
 {
         memset(ctx->nonce.c, 0, sizeof(ctx->nonce.c));
-        ctx->nonce.c[0] = ((u8)(L - 1) & 7) | (u8)(((M - 2)/2) & 7) << 3;
+        ctx->nonce.c[0] = ((uint8_t)(L - 1) & 7) | (uint8_t)(((M - 2)/2) & 7) << 3;
         ctx->blocks = 0;
         ctx->block = block;
         ctx->key = key;
@@ -81,17 +81,17 @@ CRYPTO_ccm128_setiv(CCM128_CONTEXT *ctx,
                 return -1;              /* nonce is too short */
 
         if (sizeof(mlen) == 8 && L >= 3) {
-                ctx->nonce.c[8] = (u8)(mlen >> (56 % (sizeof(mlen)*8)));
-                ctx->nonce.c[9] = (u8)(mlen >> (48 % (sizeof(mlen)*8)));
-                ctx->nonce.c[10] = (u8)(mlen >> (40 % (sizeof(mlen)*8)));
-                ctx->nonce.c[11] = (u8)(mlen >> (32 % (sizeof(mlen)*8)));
+                ctx->nonce.c[8] = (uint8_t)(mlen >> (56 % (sizeof(mlen)*8)));
+                ctx->nonce.c[9] = (uint8_t)(mlen >> (48 % (sizeof(mlen)*8)));
+                ctx->nonce.c[10] = (uint8_t)(mlen >> (40 % (sizeof(mlen)*8)));
+                ctx->nonce.c[11] = (uint8_t)(mlen >> (32 % (sizeof(mlen)*8)));
         } else
                 ctx->nonce.u[1] = 0;
 
-        ctx->nonce.c[12] = (u8)(mlen >> 24);
-        ctx->nonce.c[13] = (u8)(mlen >> 16);
-        ctx->nonce.c[14] = (u8)(mlen >> 8);
-        ctx->nonce.c[15] = (u8)mlen;
+        ctx->nonce.c[12] = (uint8_t)(mlen >> 24);
+        ctx->nonce.c[13] = (uint8_t)(mlen >> 16);
+        ctx->nonce.c[14] = (uint8_t)(mlen >> 8);
+        ctx->nonce.c[15] = (uint8_t)mlen;
 
         ctx->nonce.c[0] &= ~0x40;       /* clear Adata flag */
         memcpy(&ctx->nonce.c[1], nonce, 14 - L);
@@ -116,29 +116,29 @@ CRYPTO_ccm128_aad(CCM128_CONTEXT *ctx,
             ctx->blocks++;
 
         if (alen < (0x10000 - 0x100)) {
-                ctx->cmac.c[0] ^= (u8)(alen >> 8);
-                ctx->cmac.c[1] ^= (u8)alen;
+                ctx->cmac.c[0] ^= (uint8_t)(alen >> 8);
+                ctx->cmac.c[1] ^= (uint8_t)alen;
                 i = 2;
         } else if (sizeof(alen) == 8 &&
             alen >= (size_t)1 << (32 % (sizeof(alen)*8))) {
                 ctx->cmac.c[0] ^= 0xFF;
                 ctx->cmac.c[1] ^= 0xFF;
-                ctx->cmac.c[2] ^= (u8)(alen >> (56 % (sizeof(alen)*8)));
-                ctx->cmac.c[3] ^= (u8)(alen >> (48 % (sizeof(alen)*8)));
-                ctx->cmac.c[4] ^= (u8)(alen >> (40 % (sizeof(alen)*8)));
-                ctx->cmac.c[5] ^= (u8)(alen >> (32 % (sizeof(alen)*8)));
-                ctx->cmac.c[6] ^= (u8)(alen >> 24);
-                ctx->cmac.c[7] ^= (u8)(alen >> 16);
-                ctx->cmac.c[8] ^= (u8)(alen >> 8);
-                ctx->cmac.c[9] ^= (u8)alen;
+                ctx->cmac.c[2] ^= (uint8_t)(alen >> (56 % (sizeof(alen)*8)));
+                ctx->cmac.c[3] ^= (uint8_t)(alen >> (48 % (sizeof(alen)*8)));
+                ctx->cmac.c[4] ^= (uint8_t)(alen >> (40 % (sizeof(alen)*8)));
+                ctx->cmac.c[5] ^= (uint8_t)(alen >> (32 % (sizeof(alen)*8)));
+                ctx->cmac.c[6] ^= (uint8_t)(alen >> 24);
+                ctx->cmac.c[7] ^= (uint8_t)(alen >> 16);
+                ctx->cmac.c[8] ^= (uint8_t)(alen >> 8);
+                ctx->cmac.c[9] ^= (uint8_t)alen;
                 i = 10;
         } else {
                 ctx->cmac.c[0] ^= 0xFF;
                 ctx->cmac.c[1] ^= 0xFE;
-                ctx->cmac.c[2] ^= (u8)(alen >> 24);
-                ctx->cmac.c[3] ^= (u8)(alen >> 16);
-                ctx->cmac.c[4] ^= (u8)(alen >> 8);
-                ctx->cmac.c[5] ^= (u8)alen;
+                ctx->cmac.c[2] ^= (uint8_t)(alen >> 24);
+                ctx->cmac.c[3] ^= (uint8_t)(alen >> 16);
+                ctx->cmac.c[4] ^= (uint8_t)(alen >> 8);
+                ctx->cmac.c[5] ^= (uint8_t)alen;
                 i = 6;
         }
 
@@ -160,7 +160,7 @@ static void
 ctr64_inc(unsigned char *counter)
 {
         unsigned int n = 8;
-        u8 c;
+        uint8_t c;
 
         counter += 8;
         do {
@@ -184,8 +184,8 @@ CRYPTO_ccm128_encrypt(CCM128_CONTEXT *ctx,
         block128_f       block = ctx->block;
         void            *key = ctx->key;
         union {
-                u64 u[2];
-                u8 c[16];
+                uint64_t u[2];
+                uint8_t c[16];
         } scratch;
 
         if (!(flags0 & 0x40))
@@ -211,16 +211,16 @@ CRYPTO_ccm128_encrypt(CCM128_CONTEXT *ctx,
         while (len >= 16) {
 #ifdef __STRICT_ALIGNMENT
                 union {
-                        u64 u[2];
-                        u8 c[16];
+                        uint64_t u[2];
+                        uint8_t c[16];
                 } temp;
 
                 memcpy(temp.c, inp, 16);
                 ctx->cmac.u[0] ^= temp.u[0];
                 ctx->cmac.u[1] ^= temp.u[1];
 #else
-                ctx->cmac.u[0] ^= ((u64 *)inp)[0];
-                ctx->cmac.u[1] ^= ((u64 *)inp)[1];
+                ctx->cmac.u[0] ^= ((uint64_t *)inp)[0];
+                ctx->cmac.u[1] ^= ((uint64_t *)inp)[1];
 #endif
                 (*block)(ctx->cmac.c, ctx->cmac.c, key);
                 (*block)(ctx->nonce.c, scratch.c, key);
@@ -230,8 +230,8 @@ CRYPTO_ccm128_encrypt(CCM128_CONTEXT *ctx,
                 temp.u[1] ^= scratch.u[1];
                 memcpy(out, temp.c, 16);
 #else
-                ((u64 *)out)[0] = scratch.u[0] ^ ((u64 *)inp)[0];
-                ((u64 *)out)[1] = scratch.u[1] ^ ((u64 *)inp)[1];
+                ((uint64_t *)out)[0] = scratch.u[0] ^ ((u64 *)inp)[0];
+                ((uint64_t *)out)[1] = scratch.u[1] ^ ((u64 *)inp)[1];
 #endif
                 inp += 16;
                 out += 16;
@@ -271,8 +271,8 @@ CRYPTO_ccm128_decrypt(CCM128_CONTEXT *ctx,
         block128_f       block = ctx->block;
         void            *key = ctx->key;
         union {
-                u64 u[2];
-                u8 c[16];
+                uint64_t u[2];
+                uint8_t c[16];
         } scratch;
 
         if (!(flags0 & 0x40))
@@ -293,8 +293,8 @@ CRYPTO_ccm128_decrypt(CCM128_CONTEXT *ctx,
         while (len >= 16) {
 #ifdef __STRICT_ALIGNMENT
                 union {
-                        u64 u[2];
-                        u8 c[16];
+                        uint64_t u[2];
+                        uint8_t c[16];
                 } temp;
 #endif
                 (*block)(ctx->nonce.c, scratch.c, key);
@@ -305,10 +305,10 @@ CRYPTO_ccm128_decrypt(CCM128_CONTEXT *ctx,
                 ctx->cmac.u[1] ^= (scratch.u[1] ^= temp.u[1]);
                 memcpy(out, scratch.c, 16);
 #else
-                ctx->cmac.u[0] ^= (((u64 *)out)[0] = scratch.u[0] ^
-                    ((u64 *)inp)[0]);
-                ctx->cmac.u[1] ^= (((u64 *)out)[1] = scratch.u[1] ^
-                    ((u64 *)inp)[1]);
+                ctx->cmac.u[0] ^= (((uint64_t *)out)[0] = scratch.u[0] ^
+                    ((uint64_t *)inp)[0]);
+                ctx->cmac.u[1] ^= (((uint64_t *)out)[1] = scratch.u[1] ^
+                    ((uint64_t *)inp)[1]);
 #endif
                 (*block)(ctx->cmac.c, ctx->cmac.c, key);
 
@@ -363,8 +363,8 @@ CRYPTO_ccm128_encrypt_ccm64(CCM128_CONTEXT *ctx,
         block128_f       block = ctx->block;
         void            *key = ctx->key;
         union {
-                u64 u[2];
-                u8 c[16];
+                uint64_t u[2];
+                uint8_t c[16];
         } scratch;
 
         if (!(flags0 & 0x40))
@@ -430,8 +430,8 @@ CRYPTO_ccm128_decrypt_ccm64(CCM128_CONTEXT *ctx,
         block128_f       block = ctx->block;
         void            *key = ctx->key;
         union {
-                u64 u[2];
-                u8 c[16];
+                uint64_t u[2];
+                uint8_t c[16];
         } scratch;
 
         if (!(flags0 & 0x40))
diff --git a/src/lib/libcrypto/modes/ctr128.c b/src/lib/libcrypto/modes/ctr128.c
index 30563ed6e3..87d9abb355 100644
--- a/src/lib/libcrypto/modes/ctr128.c
+++ b/src/lib/libcrypto/modes/ctr128.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ctr128.c,v 1.17 2025/04/23 10:09:08 jsing Exp $ */
+/* $OpenBSD: ctr128.c,v 1.18 2025/05/18 09:05:59 jsing Exp $ */
 /* ====================================================================
  * Copyright (c) 2008 The OpenSSL Project.  All rights reserved.
  *
@@ -63,8 +63,8 @@
 static void
 ctr128_inc(unsigned char *counter)
 {
-        u32 n = 16;
-        u8  c;
+        uint32_t n = 16;
+        uint8_t  c;
 
         do {
                 --n;
@@ -175,8 +175,8 @@ LCRYPTO_ALIAS(CRYPTO_ctr128_encrypt);
 static void
 ctr96_inc(unsigned char *counter)
 {
-        u32 n = 12;
-        u8  c;
+        uint32_t n = 12;
+        uint8_t  c;
 
         do {
                 --n;
@@ -223,7 +223,7 @@ CRYPTO_ctr128_encrypt_ctr32(const unsigned char *in, unsigned char *out,
                  * overflow, which is then handled by limiting the
                  * amount of blocks to the exact overflow point...
                  */
-                ctr32 += (u32)blocks;
+                ctr32 += (uint32_t)blocks;
                 if (ctr32 < blocks) {
                         blocks -= ctr32;
                         ctr32 = 0;
diff --git a/src/lib/libcrypto/modes/gcm128.c b/src/lib/libcrypto/modes/gcm128.c
index ed7373d56e..8714a33c2c 100644
--- a/src/lib/libcrypto/modes/gcm128.c
+++ b/src/lib/libcrypto/modes/gcm128.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: gcm128.c,v 1.39 2025/05/18 07:26:09 jsing Exp $ */
+/* $OpenBSD: gcm128.c,v 1.40 2025/05/18 09:05:59 jsing Exp $ */
 /* ====================================================================
  * Copyright (c) 2010 The OpenSSL Project.  All rights reserved.
  *
@@ -56,10 +56,10 @@
 #include "modes_local.h"
 
 static void
-gcm_init_4bit(u128 Htable[16], u64 H[2])
+gcm_init_4bit(u128 Htable[16], uint64_t H[2])
 {
         u128 V;
-        u64 T;
+        uint64_t T;
         int i;
 
         Htable[0].hi = 0;
@@ -113,13 +113,13 @@ static const uint16_t rem_4bit[16] = {
 };
 
 static void
-gcm_gmult_4bit(u64 Xi[2], const u128 Htable[16])
+gcm_gmult_4bit(uint64_t Xi[2], const u128 Htable[16])
 {
         u128 Z;
         int cnt = 15;
         size_t rem, nlo, nhi;
 
-        nlo = ((const u8 *)Xi)[15];
+        nlo = ((const uint8_t *)Xi)[15];
         nhi = nlo >> 4;
         nlo &= 0xf;
 
@@ -130,21 +130,21 @@ gcm_gmult_4bit(u64 Xi[2], const u128 Htable[16])
                 rem = (size_t)Z.lo & 0xf;
                 Z.lo = (Z.hi << 60)|(Z.lo >> 4);
                 Z.hi = (Z.hi >> 4);
-                Z.hi ^= (u64)rem_4bit[rem] << 48;
+                Z.hi ^= (uint64_t)rem_4bit[rem] << 48;
                 Z.hi ^= Htable[nhi].hi;
                 Z.lo ^= Htable[nhi].lo;
 
                 if (--cnt < 0)
                         break;
 
-                nlo = ((const u8 *)Xi)[cnt];
+                nlo = ((const uint8_t *)Xi)[cnt];
                 nhi = nlo >> 4;
                 nlo &= 0xf;
 
                 rem = (size_t)Z.lo & 0xf;
                 Z.lo = (Z.hi << 60)|(Z.lo >> 4);
                 Z.hi = (Z.hi >> 4);
-                Z.hi ^= (u64)rem_4bit[rem] << 48;
+                Z.hi ^= (uint64_t)rem_4bit[rem] << 48;
                 Z.hi ^= Htable[nlo].hi;
                 Z.lo ^= Htable[nlo].lo;
         }
@@ -161,8 +161,8 @@ gcm_gmult_4bit(u64 Xi[2], const u128 Htable[16])
  * non-trivial optimization[s]...
  */
 static void
-gcm_ghash_4bit(u64 Xi[2], const u128 Htable[16],
-    const u8 *inp, size_t len)
+gcm_ghash_4bit(uint64_t Xi[2], const u128 Htable[16],
+    const uint8_t *inp, size_t len)
 {
         u128 Z;
         int cnt;
@@ -171,7 +171,7 @@ gcm_ghash_4bit(u64 Xi[2], const u128 Htable[16],
 #if 1
         do {
                 cnt = 15;
-                nlo = ((const u8 *)Xi)[15];
+                nlo = ((const uint8_t *)Xi)[15];
                 nlo ^= inp[15];
                 nhi = nlo >> 4;
                 nlo &= 0xf;
@@ -183,14 +183,14 @@ gcm_ghash_4bit(u64 Xi[2], const u128 Htable[16],
                         rem = (size_t)Z.lo & 0xf;
                         Z.lo = (Z.hi << 60)|(Z.lo >> 4);
                         Z.hi = (Z.hi >> 4);
-                        Z.hi ^= (u64)rem_4bit[rem] << 48;
+                        Z.hi ^= (uint64_t)rem_4bit[rem] << 48;
                         Z.hi ^= Htable[nhi].hi;
                         Z.lo ^= Htable[nhi].lo;
 
                         if (--cnt < 0)
                                 break;
 
-                        nlo = ((const u8 *)Xi)[cnt];
+                        nlo = ((const uint8_t *)Xi)[cnt];
                         nlo ^= inp[cnt];
                         nhi = nlo >> 4;
                         nlo &= 0xf;
@@ -198,7 +198,7 @@ gcm_ghash_4bit(u64 Xi[2], const u128 Htable[16],
                         rem = (size_t)Z.lo & 0xf;
                         Z.lo = (Z.hi << 60)|(Z.lo >> 4);
                         Z.hi = (Z.hi >> 4);
-                        Z.hi ^= (u64)rem_4bit[rem] << 48;
+                        Z.hi ^= (uint64_t)rem_4bit[rem] << 48;
                         Z.hi ^= Htable[nlo].hi;
                         Z.lo ^= Htable[nlo].lo;
                 }
@@ -210,7 +210,7 @@ gcm_ghash_4bit(u64 Xi[2], const u128 Htable[16],
      * cache footprint...
      */
         u128 Hshr4[16]; /* Htable shifted right by 4 bits */
-        u8 Hshl4[16];   /* Htable shifted left  by 4 bits */
+        uint8_t Hshl4[16];      /* Htable shifted left  by 4 bits */
         static const unsigned short rem_8bit[256] = {
                 0x0000, 0x01C2, 0x0384, 0x0246, 0x0708, 0x06CA, 0x048C, 0x054E,
                 0x0E10, 0x0FD2, 0x0D94, 0x0C56, 0x0918, 0x08DA, 0x0A9C, 0x0B5E,
@@ -255,12 +255,12 @@ gcm_ghash_4bit(u64 Xi[2], const u128 Htable[16],
                 Z.lo = Htable[cnt].lo;
                 Hshr4[cnt].lo = (Z.hi << 60)|(Z.lo >> 4);
                 Hshr4[cnt].hi = (Z.hi >> 4);
-                Hshl4[cnt] = (u8)(Z.lo << 4);
+                Hshl4[cnt] = (uint8_t)(Z.lo << 4);
         }
 
         do {
                 for (Z.lo = 0, Z.hi = 0, cnt = 15; cnt; --cnt) {
-                        nlo = ((const u8 *)Xi)[cnt];
+                        nlo = ((const uint8_t *)Xi)[cnt];
                         nlo ^= inp[cnt];
                         nhi = nlo >> 4;
                         nlo &= 0xf;
@@ -275,10 +275,10 @@ gcm_ghash_4bit(u64 Xi[2], const u128 Htable[16],
 
                         Z.hi ^= Hshr4[nhi].hi;
                         Z.lo ^= Hshr4[nhi].lo;
-                        Z.hi ^= (u64)rem_8bit[rem ^ Hshl4[nhi]] << 48;
+                        Z.hi ^= (uint64_t)rem_8bit[rem ^ Hshl4[nhi]] << 48;
                 }
 
-                nlo = ((const u8 *)Xi)[0];
+                nlo = ((const uint8_t *)Xi)[0];
                 nlo ^= inp[0];
                 nhi = nlo >> 4;
                 nlo &= 0xf;
@@ -293,7 +293,7 @@ gcm_ghash_4bit(u64 Xi[2], const u128 Htable[16],
 
                 Z.hi ^= Htable[nhi].hi;
                 Z.lo ^= Htable[nhi].lo;
-                Z.hi ^= ((u64)rem_8bit[rem << 4]) << 48;
+                Z.hi ^= ((uint64_t)rem_8bit[rem << 4]) << 48;
 #endif
 
                 Xi[0] = htobe64(Z.hi);
@@ -302,7 +302,7 @@ gcm_ghash_4bit(u64 Xi[2], const u128 Htable[16],
 }
 
 static inline void
-gcm_mul(GCM128_CONTEXT *ctx, u64 u[2])
+gcm_mul(GCM128_CONTEXT *ctx, uint64_t u[2])
 {
         gcm_gmult_4bit(u, ctx->Htable);
 }
@@ -313,12 +313,12 @@ gcm_ghash(GCM128_CONTEXT *ctx, const uint8_t *in, size_t len)
         gcm_ghash_4bit(ctx->Xi.u, ctx->Htable, in, len);
 }
 #else
-void gcm_gmult_4bit(u64 Xi[2], const u128 Htable[16]);
-void gcm_ghash_4bit(u64 Xi[2], const u128 Htable[16], const u8 *inp,
+void gcm_gmult_4bit(uint64_t Xi[2], const u128 Htable[16]);
+void gcm_ghash_4bit(uint64_t Xi[2], const u128 Htable[16], const uint8_t *inp,
     size_t len);
 
 static inline void
-gcm_mul(GCM128_CONTEXT *ctx, u64 u[2])
+gcm_mul(GCM128_CONTEXT *ctx, uint64_t u[2])
 {
         ctx->gmult(u, ctx->Htable);
 }
@@ -350,27 +350,27 @@ gcm_ghash(GCM128_CONTEXT *ctx, const uint8_t *in, size_t len)
          defined(_M_IX86)       || defined(_M_AMD64)    || defined(_M_X64))
 #  define GHASH_ASM_X86_OR_64
 
-void gcm_init_clmul(u128 Htable[16], const u64 Xi[2]);
-void gcm_gmult_clmul(u64 Xi[2], const u128 Htable[16]);
-void gcm_ghash_clmul(u64 Xi[2], const u128 Htable[16], const u8 *inp,
+void gcm_init_clmul(u128 Htable[16], const uint64_t Xi[2]);
+void gcm_gmult_clmul(uint64_t Xi[2], const u128 Htable[16]);
+void gcm_ghash_clmul(uint64_t Xi[2], const u128 Htable[16], const uint8_t *inp,
     size_t len);
 
 #  if   defined(__i386) || defined(__i386__) || defined(_M_IX86)
 #   define GHASH_ASM_X86
-void gcm_gmult_4bit_mmx(u64 Xi[2], const u128 Htable[16]);
-void gcm_ghash_4bit_mmx(u64 Xi[2], const u128 Htable[16], const u8 *inp,
+void gcm_gmult_4bit_mmx(uint64_t Xi[2], const u128 Htable[16]);
+void gcm_ghash_4bit_mmx(uint64_t Xi[2], const u128 Htable[16], const uint8_t *inp,
     size_t len);
 
-void gcm_gmult_4bit_x86(u64 Xi[2], const u128 Htable[16]);
-void gcm_ghash_4bit_x86(u64 Xi[2], const u128 Htable[16], const u8 *inp,
+void gcm_gmult_4bit_x86(uint64_t Xi[2], const u128 Htable[16]);
+void gcm_ghash_4bit_x86(uint64_t Xi[2], const u128 Htable[16], const uint8_t *inp,
     size_t len);
 #  endif
 # elif defined(__arm__) || defined(__arm)
 #  include "arm_arch.h"
 #  if __ARM_ARCH__>=7 && !defined(__STRICT_ALIGNMENT)
 #   define GHASH_ASM_ARM
-void gcm_gmult_neon(u64 Xi[2], const u128 Htable[16]);
-void gcm_ghash_neon(u64 Xi[2], const u128 Htable[16], const u8 *inp,
+void gcm_gmult_neon(uint64_t Xi[2], const u128 Htable[16]);
+void gcm_ghash_neon(uint64_t Xi[2], const u128 Htable[16], const uint8_t *inp,
     size_t len);
 #  endif
 # endif
@@ -452,7 +452,7 @@ CRYPTO_gcm128_setiv(GCM128_CONTEXT *ctx, const unsigned char *iv, size_t len)
                 ctr = 1;
         } else {
                 size_t i;
-                u64 len0 = len;
+                uint64_t len0 = len;
 
                 while (len >= 16) {
                         for (i = 0; i < 16; ++i)
@@ -485,7 +485,7 @@ CRYPTO_gcm128_aad(GCM128_CONTEXT *ctx, const unsigned char *aad, size_t len)
 {
         size_t i;
         unsigned int n;
-        u64 alen = ctx->len.u[0];
+        uint64_t alen = ctx->len.u[0];
 
         if (ctx->len.u[1])
                 return -2;
@@ -533,7 +533,7 @@ CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx,
 {
         unsigned int n, ctr;
         size_t i;
-        u64 mlen = ctx->len.u[1];
+        uint64_t mlen = ctx->len.u[1];
         block128_f block = ctx->block;
         void *key = ctx->key;
 
@@ -670,7 +670,7 @@ CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx,
 {
         unsigned int n, ctr;
         size_t i;
-        u64 mlen = ctx->len.u[1];
+        uint64_t mlen = ctx->len.u[1];
         block128_f block = ctx->block;
         void *key = ctx->key;
 
@@ -692,7 +692,7 @@ CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx,
                 do {    /* always true actually */
                         if (n) {
                                 while (n && len) {
-                                        u8 c = *(in++);
+                                        uint8_t c = *(in++);
                                         *(out++) = c ^ ctx->EKi.c[n];
                                         ctx->Xi.c[n] ^= c;
                                         --len;
@@ -775,7 +775,7 @@ CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx,
                                 ctx->Yi.d[3] = htobe32(ctr);
 
                                 while (len--) {
-                                        u8 c = in[n];
+                                        uint8_t c = in[n];
                                         ctx->Xi.c[n] ^= c;
                                         out[n] = c ^ ctx->EKi.c[n];
                                         ++n;
@@ -786,7 +786,7 @@ CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx,
                         return 0;
                 } while (0);
         for (i = 0; i < len; ++i) {
-                u8 c;
+                uint8_t c;
                 if (n == 0) {
                         (*block)(ctx->Yi.c, ctx->EKi.c, key);
                         ++ctr;
@@ -812,7 +812,7 @@ CRYPTO_gcm128_encrypt_ctr32(GCM128_CONTEXT *ctx,
 {
         unsigned int n, ctr;
         size_t i;
-        u64 mlen = ctx->len.u[1];
+        uint64_t mlen = ctx->len.u[1];
         void *key = ctx->key;
 
         mlen += len;
@@ -886,7 +886,7 @@ CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx,
 {
         unsigned int n, ctr;
         size_t i;
-        u64 mlen = ctx->len.u[1];
+        uint64_t mlen = ctx->len.u[1];
         void *key = ctx->key;
 
         mlen += len;
@@ -905,7 +905,7 @@ CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx,
         n = ctx->mres;
         if (n) {
                 while (n && len) {
-                        u8 c = *(in++);
+                        uint8_t c = *(in++);
                         *(out++) = c ^ ctx->EKi.c[n];
                         ctx->Xi.c[n] ^= c;
                         --len;
@@ -945,7 +945,7 @@ CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx,
                 ++ctr;
                 ctx->Yi.d[3] = htobe32(ctr);
                 while (len--) {
-                        u8 c = in[n];
+                        uint8_t c = in[n];
                         ctx->Xi.c[n] ^= c;
                         out[n] = c ^ ctx->EKi.c[n];
                         ++n;
@@ -961,8 +961,8 @@ int
 CRYPTO_gcm128_finish(GCM128_CONTEXT *ctx, const unsigned char *tag,
     size_t len)
 {
-        u64 alen = ctx->len.u[0] << 3;
-        u64 clen = ctx->len.u[1] << 3;
+        uint64_t alen = ctx->len.u[0] << 3;
+        uint64_t clen = ctx->len.u[1] << 3;
 
         if (ctx->mres || ctx->ares)
                 gcm_mul(ctx, ctx->Xi.u);
diff --git a/src/lib/libcrypto/modes/modes_local.h b/src/lib/libcrypto/modes/modes_local.h
index 81994876e3..d833d40ee3 100644
--- a/src/lib/libcrypto/modes/modes_local.h
+++ b/src/lib/libcrypto/modes/modes_local.h
@@ -1,4 +1,4 @@
-/* $OpenBSD: modes_local.h,v 1.5 2025/05/17 14:43:17 jsing Exp $ */
+/* $OpenBSD: modes_local.h,v 1.6 2025/05/18 09:05:59 jsing Exp $ */
 /* ====================================================================
  * Copyright (c) 2010 The OpenSSL Project.  All rights reserved.
  *
@@ -15,37 +15,30 @@
 __BEGIN_HIDDEN_DECLS
 
 #if defined(_LP64)
-typedef long i64;
-typedef unsigned long u64;
 #define U64(C) C##UL
 #else
-typedef long long i64;
-typedef unsigned long long u64;
 #define U64(C) C##ULL
 #endif
 
-typedef unsigned int u32;
-typedef unsigned char u8;
-
 /* GCM definitions */
 
 typedef struct {
-        u64 hi, lo;
+        uint64_t hi, lo;
 } u128;
 
 struct gcm128_context {
         /* Following 6 names follow names in GCM specification */
         union {
-                u64 u[2];
-                u32 d[4];
-                u8 c[16];
+                uint64_t u[2];
+                uint32_t d[4];
+                uint8_t c[16];
                 size_t t[16/sizeof(size_t)];
         } Yi, EKi, EK0, len, Xi, H;
         /* Relative position of Xi, H and pre-computed Htable is used
          * in some assembler modules, i.e. don't change the order! */
         u128 Htable[16];
-        void (*gmult)(u64 Xi[2], const u128 Htable[16]);
-        void (*ghash)(u64 Xi[2], const u128 Htable[16], const u8 *inp,
+        void (*gmult)(uint64_t Xi[2], const u128 Htable[16]);
+        void (*ghash)(uint64_t Xi[2], const u128 Htable[16], const uint8_t *inp,
             size_t len);
         unsigned int mres, ares;
         block128_f block;
@@ -59,10 +52,10 @@ struct xts128_context {
 
 struct ccm128_context {
         union {
-                u64 u[2];
-                u8 c[16];
+                uint64_t u[2];
+                uint8_t c[16];
         } nonce, cmac;
-        u64 blocks;
+        uint64_t blocks;
         block128_f block;
         void *key;
 };
diff --git a/src/lib/libcrypto/modes/xts128.c b/src/lib/libcrypto/modes/xts128.c
index 789af9ef65..9c863e73d6 100644
--- a/src/lib/libcrypto/modes/xts128.c
+++ b/src/lib/libcrypto/modes/xts128.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: xts128.c,v 1.14 2025/04/21 16:01:18 jsing Exp $ */
+/* $OpenBSD: xts128.c,v 1.15 2025/05/18 09:05:59 jsing Exp $ */
 /* ====================================================================
  * Copyright (c) 2011 The OpenSSL Project.  All rights reserved.
  *
@@ -61,9 +61,9 @@ CRYPTO_xts128_encrypt(const XTS128_CONTEXT *ctx, const unsigned char iv[16],
     size_t len, int enc)
 {
         union {
-                u64 u[2];
-                u32 d[4];
-                u8 c[16];
+                uint64_t u[2];
+                uint32_t d[4];
+                uint8_t c[16];
         } tweak, scratch;
         unsigned int i;
 
@@ -83,8 +83,8 @@ CRYPTO_xts128_encrypt(const XTS128_CONTEXT *ctx, const unsigned char iv[16],
                 scratch.u[0] ^= tweak.u[0];
                 scratch.u[1] ^= tweak.u[1];
 #else
-                scratch.u[0] = ((u64 *)inp)[0] ^ tweak.u[0];
-                scratch.u[1] = ((u64 *)inp)[1] ^ tweak.u[1];
+                scratch.u[0] = ((uint64_t *)inp)[0] ^ tweak.u[0];
+                scratch.u[1] = ((uint64_t *)inp)[1] ^ tweak.u[1];
 #endif
                 (*ctx->block1)(scratch.c, scratch.c, ctx->key1);
 #ifdef __STRICT_ALIGNMENT
@@ -92,8 +92,8 @@ CRYPTO_xts128_encrypt(const XTS128_CONTEXT *ctx, const unsigned char iv[16],
                 scratch.u[1] ^= tweak.u[1];
                 memcpy(out, scratch.c, 16);
 #else
-                ((u64 *)out)[0] = scratch.u[0] ^= tweak.u[0];
-                ((u64 *)out)[1] = scratch.u[1] ^= tweak.u[1];
+                ((uint64_t *)out)[0] = scratch.u[0] ^= tweak.u[0];
+                ((uint64_t *)out)[1] = scratch.u[1] ^= tweak.u[1];
 #endif
                 inp += 16;
                 out += 16;
@@ -115,15 +115,15 @@ CRYPTO_xts128_encrypt(const XTS128_CONTEXT *ctx, const unsigned char iv[16],
                 for (c = 0, i = 0; i < 16; ++i) {
                         /*+ substitutes for |, because c is 1 bit */
                         c += ((size_t)tweak.c[i]) << 1;
-                        tweak.c[i] = (u8)c;
+                        tweak.c[i] = (uint8_t)c;
                         c = c >> 8;
                 }
-                tweak.c[0] ^= (u8)(0x87 & (0 - c));
+                tweak.c[0] ^= (uint8_t)(0x87 & (0 - c));
 #endif
         }
         if (enc) {
                 for (i = 0; i < len; ++i) {
-                        u8 ch = inp[i];
+                        uint8_t ch = inp[i];
                         out[i] = scratch.c[i];
                         scratch.c[i] = ch;
                 }
@@ -135,8 +135,8 @@ CRYPTO_xts128_encrypt(const XTS128_CONTEXT *ctx, const unsigned char iv[16],
                 memcpy(out - 16, scratch.c, 16);
         } else {
                 union {
-                        u64 u[2];
-                        u8 c[16];
+                        uint64_t u[2];
+                        uint8_t c[16];
                 } tweak1;
 
 #if BYTE_ORDER == LITTLE_ENDIAN
@@ -152,25 +152,25 @@ CRYPTO_xts128_encrypt(const XTS128_CONTEXT *ctx, const unsigned char iv[16],
                 for (c = 0, i = 0; i < 16; ++i) {
                         /*+ substitutes for |, because c is 1 bit */
                         c += ((size_t)tweak.c[i]) << 1;
-                        tweak1.c[i] = (u8)c;
+                        tweak1.c[i] = (uint8_t)c;
                         c = c >> 8;
                 }
-                tweak1.c[0] ^= (u8)(0x87 & (0 - c));
+                tweak1.c[0] ^= (uint8_t)(0x87 & (0 - c));
 #endif
 #ifdef __STRICT_ALIGNMENT
                 memcpy(scratch.c, inp, 16);
                 scratch.u[0] ^= tweak1.u[0];
                 scratch.u[1] ^= tweak1.u[1];
 #else
-                scratch.u[0] = ((u64 *)inp)[0] ^ tweak1.u[0];
-                scratch.u[1] = ((u64 *)inp)[1] ^ tweak1.u[1];
+                scratch.u[0] = ((uint64_t *)inp)[0] ^ tweak1.u[0];
+                scratch.u[1] = ((uint64_t *)inp)[1] ^ tweak1.u[1];
 #endif
                 (*ctx->block1)(scratch.c, scratch.c, ctx->key1);
                 scratch.u[0] ^= tweak1.u[0];
                 scratch.u[1] ^= tweak1.u[1];
 
                 for (i = 0; i < len; ++i) {
-                        u8 ch = inp[16 + i];
+                        uint8_t ch = inp[16 + i];
                         out[16 + i] = scratch.c[i];
                         scratch.c[i] = ch;
                 }
@@ -182,8 +182,8 @@ CRYPTO_xts128_encrypt(const XTS128_CONTEXT *ctx, const unsigned char iv[16],
                 scratch.u[1] ^= tweak.u[1];
                 memcpy(out, scratch.c, 16);
 #else
-                ((u64 *)out)[0] = scratch.u[0] ^ tweak.u[0];
-                ((u64 *)out)[1] = scratch.u[1] ^ tweak.u[1];
+                ((uint64_t *)out)[0] = scratch.u[0] ^ tweak.u[0];
+                ((uint64_t *)out)[1] = scratch.u[1] ^ tweak.u[1];
 #endif
         }