@fails-components/webtransport 0.0.1 → 0.0.2

package/third_party/boringssl/src/crypto/asn1/time_support.c

@@ -56,7 +56,7 @@
  * Hudson (tjh@cryptsoft.com). */
 
 #if defined(__linux__) && !defined(_POSIX_C_SOURCE)
-#define _POSIX_C_SOURCE 201410L  /* for gmtime_r */
+#define _POSIX_C_SOURCE 201410L  // for gmtime_r
 #endif
 
 #include "internal.h"
@@ -77,7 +77,7 @@ struct tm *OPENSSL_gmtime(const time_t *time, struct tm *result) {
 #endif
 }
 
-/* Convert date to and from julian day Uses Fliegel & Van Flandern algorithm */
+// Convert date to and from julian day Uses Fliegel & Van Flandern algorithm
 static long date_to_julian(int y, int m, int d) {
   return (1461 * (y + 4800 + (m - 14) / 12)) / 4 +
          (367 * (m - 2 - 12 * ((m - 14) / 12))) / 12 -
@@ -99,20 +99,20 @@ static void julian_to_date(long jd, int *y, int *m, int *d) {
   *y = 100 * (n - 49) + i + L;
 }
 
-/* Convert tm structure and offset into julian day and seconds */
+// Convert tm structure and offset into julian day and seconds
 static int julian_adj(const struct tm *tm, int off_day, long offset_sec,
                       long *pday, int *psec) {
   int offset_hms, offset_day;
   long time_jd;
   int time_year, time_month, time_day;
-  /* split offset into days and day seconds */
+  // split offset into days and day seconds
   offset_day = offset_sec / SECS_PER_DAY;
-  /* Avoid sign issues with % operator */
+  // Avoid sign issues with % operator
   offset_hms = offset_sec - (offset_day * SECS_PER_DAY);
   offset_day += off_day;
-  /* Add current time seconds to offset */
+  // Add current time seconds to offset
   offset_hms += tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec;
-  /* Adjust day seconds if overflow */
+  // Adjust day seconds if overflow
   if (offset_hms >= SECS_PER_DAY) {
     offset_day++;
     offset_hms -= SECS_PER_DAY;
@@ -121,7 +121,7 @@ static int julian_adj(const struct tm *tm, int off_day, long offset_sec,
     offset_hms += SECS_PER_DAY;
   }
 
-  /* Convert date of time structure into a Julian day number. */
+  // Convert date of time structure into a Julian day number.
 
   time_year = tm->tm_year + 1900;
   time_month = tm->tm_mon + 1;
@@ -129,7 +129,7 @@ static int julian_adj(const struct tm *tm, int off_day, long offset_sec,
 
   time_jd = date_to_julian(time_year, time_month, time_day);
 
-  /* Work out Julian day of new date */
+  // Work out Julian day of new date
   time_jd += offset_day;
 
   if (time_jd < 0) {
@@ -145,12 +145,12 @@ int OPENSSL_gmtime_adj(struct tm *tm, int off_day, long offset_sec) {
   int time_sec, time_year, time_month, time_day;
   long time_jd;
 
-  /* Convert time and offset into julian day and seconds */
+  // Convert time and offset into julian day and seconds
   if (!julian_adj(tm, off_day, offset_sec, &time_jd, &time_sec)) {
     return 0;
   }
 
-  /* Convert Julian day back to date */
+  // Convert Julian day back to date
 
   julian_to_date(time_jd, &time_year, &time_month, &time_day);
 
@@ -158,7 +158,7 @@ int OPENSSL_gmtime_adj(struct tm *tm, int off_day, long offset_sec) {
     return 0;
   }
 
-  /* Update tm structure */
+  // Update tm structure
 
   tm->tm_year = time_year - 1900;
   tm->tm_mon = time_month - 1;
@@ -185,7 +185,7 @@ int OPENSSL_gmtime_diff(int *out_days, int *out_secs, const struct tm *from,
 
   diff_day = to_jd - from_jd;
   diff_sec = to_sec - from_sec;
-  /* Adjust differences so both positive or both negative */
+  // Adjust differences so both positive or both negative
   if (diff_day > 0 && diff_sec < 0) {
     diff_day--;
     diff_sec += SECS_PER_DAY;

package/third_party/boringssl/src/crypto/bio/connect.c

@@ -117,7 +117,8 @@ static int closesocket(int sock) {
 // split_host_and_port sets |*out_host| and |*out_port| to the host and port
 // parsed from |name|. It returns one on success or zero on error. Even when
 // successful, |*out_port| may be NULL on return if no port was specified.
-static int split_host_and_port(char **out_host, char **out_port, const char *name) {
+static int split_host_and_port(char **out_host, char **out_port,
+                               const char *name) {
   const char *host, *port = NULL;
   size_t host_len = 0;
 
@@ -466,8 +467,7 @@ static long conn_ctrl(BIO *bio, int cmd, long num, void *ptr) {
     case BIO_CTRL_FLUSH:
       break;
     case BIO_CTRL_GET_CALLBACK: {
-      int (**fptr)(const BIO *bio, int state, int xret);
-      fptr = (int (**)(const BIO *bio, int state, int xret))ptr;
+      int (**fptr)(const BIO *bio, int state, int xret) = ptr;
       *fptr = data->info_callback;
     } break;
     default:
@@ -485,7 +485,13 @@ static long conn_callback_ctrl(BIO *bio, int cmd, bio_info_cb fp) {
 
   switch (cmd) {
     case BIO_CTRL_SET_CALLBACK:
+      // This is the actual type signature of |fp|. The caller is expected to
+      // cast it to |bio_info_cb| due to the |BIO_callback_ctrl| calling
+      // convention.
+      OPENSSL_MSVC_PRAGMA(warning(push))
+      OPENSSL_MSVC_PRAGMA(warning(disable : 4191))
       data->info_callback = (int (*)(const struct bio_st *, int, int))fp;
+      OPENSSL_MSVC_PRAGMA(warning(pop))
       break;
     default:
       ret = 0;

package/third_party/boringssl/src/crypto/bytestring/bytestring_test.cc

@@ -24,9 +24,9 @@
 #include <openssl/crypto.h>
 #include <openssl/span.h>
 
-#include "internal.h"
 #include "../internal.h"
 #include "../test/test_util.h"
+#include "internal.h"
 
 
 TEST(CBSTest, Skip) {
@@ -1493,3 +1493,127 @@ TEST(CBBTest, Unicode) {
   EXPECT_EQ(4u, cbb_get_utf8_len(0x10000));
   EXPECT_EQ(4u, cbb_get_utf8_len(0x10ffff));
 }
+
+TEST(CBSTest, BogusTime) {
+  static const struct {
+    const char *timestring;
+  } kBogusTimeTests[] = {
+      {""},
+      {"invalidtimesZ"},
+      {"Z"},
+      {"0000"},
+      {"9999Z"},
+      {"00000000000000000000000000000Z"},
+      {"19491231235959"},
+      {"500101000000.001Z"},
+      {"500101000000+6"},
+      {"-1970010100000Z"},
+      {"7a0101000000Z"},
+      {"20500101000000-6"},
+      {"20500101000000.001"},
+      {"20500229000000Z"},
+      {"220229000000Z"},
+      {"20500132000000Z"},
+      {"220132000000Z"},
+      {"20500332000000Z"},
+      {"220332000000Z"},
+      {"20500532000000Z"},
+      {"220532000000Z"},
+      {"20500732000000Z"},
+      {"220732000000Z"},
+      {"20500832000000Z"},
+      {"220832000000Z"},
+      {"20501032000000Z"},
+      {"221032000000Z"},
+      {"20501232000000Z"},
+      {"221232000000Z"},
+      {"20500431000000Z"},
+      {"220431000000Z"},
+      {"20500631000000Z"},
+      {"220631000000Z"},
+      {"20500931000000Z"},
+      {"220931000000Z"},
+      {"20501131000000Z"},
+      {"221131000000Z"},
+      {"20501100000000Z"},
+      {"221100000000Z"},
+      {"19500101000000+0600"},
+  };
+  for (const auto &t : kBogusTimeTests) {
+    SCOPED_TRACE(t.timestring);
+    CBS cbs;
+    CBS_init(&cbs, (const uint8_t *)t.timestring, strlen(t.timestring));
+    EXPECT_FALSE(CBS_parse_generalized_time(&cbs, NULL,
+                                            /*allow_timezone_offset=*/0));
+    EXPECT_FALSE(CBS_parse_utc_time(&cbs, NULL, /*allow_timezone_offset=*/1));
+  }
+  static const struct {
+    const char *timestring;
+  } kUTCTZTests[] = {
+      {"480711220333-0700"},
+      {"140704000000-0700"},
+      {"480222202332-0500"},
+      {"480726113216-0000"},
+      {"480726113216-2359"},
+  };
+  for (const auto &t : kUTCTZTests) {
+    SCOPED_TRACE(t.timestring);
+    CBS cbs;
+    CBS_init(&cbs, (const uint8_t *)t.timestring, strlen(t.timestring));
+    EXPECT_FALSE(CBS_parse_generalized_time(&cbs, NULL,
+                                            /*allow_timezone_offset=*/0));
+    EXPECT_FALSE(CBS_parse_generalized_time(&cbs, NULL,
+                                            /*allow_timezone_offset=*/1));
+    EXPECT_TRUE(CBS_parse_utc_time(&cbs, NULL, /*allow_timezone_offset=*/1));
+    EXPECT_FALSE(CBS_parse_utc_time(&cbs, NULL, /*allow_timezone_offset=*/0));
+  }
+  static const struct {
+    const char *timestring;
+  } kBogusUTCTZTests[] = {
+      {"480711220333-0160"},
+      {"140704000000-9999"},
+      {"480222202332-2400"},
+  };
+  for (const auto &t : kBogusUTCTZTests) {
+    SCOPED_TRACE(t.timestring);
+    CBS cbs;
+    CBS_init(&cbs, (const uint8_t *)t.timestring, strlen(t.timestring));
+    EXPECT_FALSE(CBS_parse_generalized_time(&cbs, NULL,
+                                            /*allow_timezone_offset=*/0));
+    EXPECT_FALSE(CBS_parse_utc_time(&cbs, NULL, /*allow_timezone_offset=*/1));
+  }
+  static const struct {
+    const char *timestring;
+  } kGenTZTests[] = {
+      {"20480711220333-0000"},
+      {"20140704000000-0100"},
+      {"20460311174630-0300"},
+      {"20140704000000-2359"},
+  };
+  for (const auto &t : kGenTZTests) {
+    SCOPED_TRACE(t.timestring);
+    CBS cbs;
+    CBS_init(&cbs, (const uint8_t *)t.timestring, strlen(t.timestring));
+    EXPECT_FALSE(CBS_parse_generalized_time(&cbs, NULL,
+                                            /*allow_timezone_offset=*/0));
+    EXPECT_TRUE(CBS_parse_generalized_time(&cbs, NULL,
+                                           /*allow_timezone_offset=*/1));
+    EXPECT_FALSE(CBS_parse_utc_time(&cbs, NULL, /*allow_timezone_offset=*/1));
+    EXPECT_FALSE(CBS_parse_utc_time(&cbs, NULL, /*allow_timezone_offset=*/0));
+  }
+  static const struct {
+    const char *timestring;
+  } kBogusGenTZTests[] = {
+      {"20480222202332-2400"},
+      {"20140704000000-9999"},
+      {"20480726113216-0160"},
+  };
+  for (const auto &t : kBogusGenTZTests) {
+    SCOPED_TRACE(t.timestring);
+    CBS cbs;
+    CBS_init(&cbs, (const uint8_t *)t.timestring, strlen(t.timestring));
+    EXPECT_FALSE(CBS_parse_generalized_time(&cbs, NULL,
+                                            /*allow_timezone_offset=*/0));
+    EXPECT_FALSE(CBS_parse_utc_time(&cbs, NULL, /*allow_timezone_offset=*/1));
+  }
+}

package/third_party/boringssl/src/crypto/bytestring/cbb.c

@@ -542,14 +542,11 @@ int CBB_add_asn1_int64(CBB *cbb, int64_t value) {
     return CBB_add_asn1_uint64(cbb, value);
   }
 
-  union {
-    int64_t i;
-    uint8_t bytes[sizeof(int64_t)];
-  } u;
-  u.i = value;
+  uint8_t bytes[sizeof(int64_t)];
+  memcpy(bytes, &value, sizeof(value));
   int start = 7;
   // Skip leading sign-extension bytes unless they are necessary.
-  while (start > 0 && (u.bytes[start] == 0xff && (u.bytes[start - 1] & 0x80))) {
+  while (start > 0 && (bytes[start] == 0xff && (bytes[start - 1] & 0x80))) {
     start--;
   }
 
@@ -558,7 +555,7 @@ int CBB_add_asn1_int64(CBB *cbb, int64_t value) {
     return 0;
   }
   for (int i = start; i >= 0; i--) {
-    if (!CBB_add_u8(&child, u.bytes[i])) {
+    if (!CBB_add_u8(&child, bytes[i])) {
       return 0;
     }
   }

package/third_party/boringssl/src/crypto/bytestring/cbs.c

@@ -12,15 +12,18 @@
  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
 
-#include <openssl/mem.h>
+#include <openssl/asn1.h>
 #include <openssl/bytestring.h>
+#include <openssl/mem.h>
 
 #include <assert.h>
+#include <ctype.h>
 #include <inttypes.h>
 #include <string.h>
 
-#include "internal.h"
+#include "../asn1/internal.h"
 #include "../internal.h"
+#include "internal.h"
 
 
 void CBS_init(CBS *cbs, const uint8_t *data, size_t len) {
@@ -496,15 +499,12 @@ int CBS_get_asn1_int64(CBS *cbs, int64_t *out) {
   if (len > sizeof(int64_t)) {
     return 0;
   }
-  union {
-    int64_t i;
-    uint8_t bytes[sizeof(int64_t)];
-  } u;
-  memset(u.bytes, is_negative ? 0xff : 0, sizeof(u.bytes));  // Sign-extend.
+  uint8_t sign_extend[sizeof(int64_t)];
+  memset(sign_extend, is_negative ? 0xff : 0, sizeof(sign_extend));
   for (size_t i = 0; i < len; i++) {
-    u.bytes[i] = data[len - i - 1];
+    sign_extend[i] = data[len - i - 1];
   }
-  *out = u.i;
+  memcpy(out, sign_extend, sizeof(sign_extend));
   return 1;
 }
 
@@ -723,3 +723,161 @@ err:
   CBB_cleanup(&cbb);
   return NULL;
 }
+
+static int cbs_get_two_digits(CBS *cbs, int *out) {
+  uint8_t first_digit, second_digit;
+  if (!CBS_get_u8(cbs, &first_digit)) {
+    return 0;
+  }
+  if (!isdigit(first_digit)) {
+    return 0;
+  }
+  if (!CBS_get_u8(cbs, &second_digit)) {
+    return 0;
+  }
+  if (!isdigit(second_digit)) {
+    return 0;
+  }
+  *out = (first_digit - '0') * 10 + (second_digit - '0');
+  return 1;
+}
+
+static int is_valid_day(int year, int month, int day) {
+  if (day < 1) {
+    return 0;
+  }
+  switch (month) {
+    case 1:
+    case 3:
+    case 5:
+    case 7:
+    case 8:
+    case 10:
+    case 12:
+      return day <= 31;
+    case 4:
+    case 6:
+    case 9:
+    case 11:
+      return day <= 30;
+    case 2:
+      if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
+        return day <= 29;
+      } else {
+        return day <= 28;
+      }
+    default:
+      return 0;
+  }
+}
+
+static int CBS_parse_rfc5280_time_internal(const CBS *cbs, int is_gentime,
+                                           int allow_timezone_offset,
+                                           struct tm *out_tm) {
+  int year, month, day, hour, min, sec, tmp;
+  CBS copy = *cbs;
+  uint8_t tz;
+
+  if (is_gentime) {
+    if (!cbs_get_two_digits(&copy, &tmp)) {
+      return 0;
+    }
+    year = tmp * 100;
+    if (!cbs_get_two_digits(&copy, &tmp)) {
+      return 0;
+    }
+      year += tmp;
+  } else {
+    year = 1900;
+    if (!cbs_get_two_digits(&copy, &tmp)) {
+      return 0;
+    }
+    year += tmp;
+    if (year < 1950) {
+      year += 100;
+    }
+    if (year >= 2050) {
+      return 0;  // A Generalized time must be used.
+    }
+  }
+  if (!cbs_get_two_digits(&copy, &month) || month < 1 ||
+      month > 12 ||  // Reject invalid months.
+      !cbs_get_two_digits(&copy, &day) ||
+      !is_valid_day(year, month, day) ||  // Reject invalid days.
+      !cbs_get_two_digits(&copy, &hour) ||
+      hour > 23 ||  // Reject invalid hours.
+      !cbs_get_two_digits(&copy, &min) ||
+      min > 59 ||  // Reject invalid minutes.
+      !cbs_get_two_digits(&copy, &sec) || sec > 59 || !CBS_get_u8(&copy, &tz)) {
+    return 0;
+  }
+
+  int offset_sign = 0;
+  switch (tz) {
+    case 'Z':
+      break;  // We correctly have 'Z' on the end as per spec.
+    case '+':
+      offset_sign = 1;
+      break;  // Should not be allowed per RFC 5280.
+    case '-':
+      offset_sign = -1;
+      break;  // Should not be allowed per RFC 5280.
+    default:
+      return 0;  // Reject anything else after the time.
+  }
+
+  // If allow_timezone_offset is non-zero, allow for a four digit timezone
+  // offset to be specified even though this is not allowed by RFC 5280. We are
+  // permissive of this for UTCTimes due to the unfortunate existence of
+  // artisinally rolled long lived certificates that were baked into places that
+  // are now difficult to change. These certificates were generated with the
+  // 'openssl' command that permissively allowed the creation of certificates
+  // with notBefore and notAfter times specified as strings for direct
+  // certificate inclusion on the command line. For context see cl/237068815.
+  //
+  // TODO(bbe): This has been expunged from public web-pki as the ecosystem has
+  // managed to encourage CA compliance with standards. We should find a way to
+  // get rid of this or make it off by default.
+  int offset_seconds = 0;
+  if (offset_sign != 0) {
+    if (!allow_timezone_offset) {
+      return 0;
+    }
+    int offset_hours, offset_minutes;
+    if (!cbs_get_two_digits(&copy, &offset_hours) ||
+        offset_hours > 23 ||  // Reject invalid hours.
+        !cbs_get_two_digits(&copy, &offset_minutes) ||
+        offset_minutes > 59) {  // Reject invalid minutes.
+      return 0;
+    }
+    offset_seconds = offset_sign * (offset_hours * 3600 + offset_minutes * 60);
+  }
+
+  if (CBS_len(&copy) != 0) {
+    return 0;  // Reject invalid lengths.
+  }
+
+  if (out_tm != NULL) {
+    // Fill in the tm fields corresponding to what we validated.
+    out_tm->tm_year = year - 1900;
+    out_tm->tm_mon = month - 1;
+    out_tm->tm_mday = day;
+    out_tm->tm_hour = hour;
+    out_tm->tm_min = min;
+    out_tm->tm_sec = sec;
+    if (offset_seconds && !OPENSSL_gmtime_adj(out_tm, 0, offset_seconds)) {
+      return 0;
+    }
+  }
+  return 1;
+}
+
+int CBS_parse_generalized_time(const CBS *cbs, struct tm *out_tm,
+                               int allow_timezone_offset) {
+  return CBS_parse_rfc5280_time_internal(cbs, 1, allow_timezone_offset, out_tm);
+}
+
+int CBS_parse_utc_time(const CBS *cbs, struct tm *out_tm,
+                       int allow_timezone_offset) {
+  return CBS_parse_rfc5280_time_internal(cbs, 0, allow_timezone_offset, out_tm);
+}

package/third_party/boringssl/src/crypto/cipher_extra/e_aesctrhmac.c

@@ -38,11 +38,9 @@ struct aead_aes_ctr_hmac_sha256_ctx {
 OPENSSL_STATIC_ASSERT(sizeof(((EVP_AEAD_CTX *)NULL)->state) >=
                           sizeof(struct aead_aes_ctr_hmac_sha256_ctx),
                       "AEAD state is too small");
-#if defined(__GNUC__) || defined(__clang__)
 OPENSSL_STATIC_ASSERT(alignof(union evp_aead_ctx_st_state) >=
                           alignof(struct aead_aes_ctr_hmac_sha256_ctx),
                       "AEAD state has insufficient alignment");
-#endif
 
 static void hmac_init(SHA256_CTX *out_inner, SHA256_CTX *out_outer,
                       const uint8_t hmac_key[32]) {

package/third_party/boringssl/src/crypto/cipher_extra/e_aesgcmsiv.c

@@ -45,10 +45,8 @@ struct aead_aes_gcm_siv_asm_ctx {
 OPENSSL_STATIC_ASSERT(sizeof(((EVP_AEAD_CTX *)NULL)->state) + 8 >=
                           sizeof(struct aead_aes_gcm_siv_asm_ctx),
                       "AEAD state is too small");
-#if defined(__GNUC__) || defined(__clang__)
 OPENSSL_STATIC_ASSERT(alignof(union evp_aead_ctx_st_state) >= 8,
                       "AEAD state has insufficient alignment");
-#endif
 
 // asm_ctx_from_ctx returns a 16-byte aligned context pointer from |ctx|.
 static struct aead_aes_gcm_siv_asm_ctx *asm_ctx_from_ctx(
@@ -262,17 +260,10 @@ static void gcm_siv_asm_polyval(uint8_t out_tag[16], const uint8_t *in,
     aesgcmsiv_polyval_horner(out_tag, auth_key, scratch, 1);
   }
 
-  union {
-    uint8_t c[16];
-    struct {
-      uint64_t ad;
-      uint64_t in;
-    } bitlens;
-  } length_block;
-
-  length_block.bitlens.ad = ad_len * 8;
-  length_block.bitlens.in = in_len * 8;
-  aesgcmsiv_polyval_horner(out_tag, auth_key, length_block.c, 1);
+  uint8_t length_block[16];
+  CRYPTO_store_u64_le(length_block, ad_len * 8);
+  CRYPTO_store_u64_le(length_block + 8, in_len * 8);
+  aesgcmsiv_polyval_horner(out_tag, auth_key, length_block, 1);
 
   for (size_t i = 0; i < 12; i++) {
     out_tag[i] ^= nonce[i];
@@ -289,18 +280,15 @@ static void aead_aes_gcm_siv_asm_crypt_last_block(
     int is_128_bit, uint8_t *out, const uint8_t *in, size_t in_len,
     const uint8_t tag[16],
     const struct aead_aes_gcm_siv_asm_ctx *enc_key_expanded) {
-  alignas(16) union {
-    uint8_t c[16];
-    uint32_t u32[4];
-  } counter;
+  alignas(16) uint8_t counter[16];
   OPENSSL_memcpy(&counter, tag, sizeof(counter));
-  counter.c[15] |= 0x80;
-  counter.u32[0] += in_len / 16;
+  counter[15] |= 0x80;
+  CRYPTO_store_u32_le(counter, CRYPTO_load_u32_le(counter) + in_len / 16);
 
   if (is_128_bit) {
-    aes128gcmsiv_ecb_enc_block(&counter.c[0], &counter.c[0], enc_key_expanded);
+    aes128gcmsiv_ecb_enc_block(counter, counter, enc_key_expanded);
   } else {
-    aes256gcmsiv_ecb_enc_block(&counter.c[0], &counter.c[0], enc_key_expanded);
+    aes256gcmsiv_ecb_enc_block(counter, counter, enc_key_expanded);
   }
 
   const size_t last_bytes_offset = in_len & ~15;
@@ -308,7 +296,7 @@ static void aead_aes_gcm_siv_asm_crypt_last_block(
   uint8_t *last_bytes_out = &out[last_bytes_offset];
   const uint8_t *last_bytes_in = &in[last_bytes_offset];
   for (size_t i = 0; i < last_bytes_len; i++) {
-    last_bytes_out[i] = last_bytes_in[i] ^ counter.c[i];
+    last_bytes_out[i] = last_bytes_in[i] ^ counter[i];
   }
 }
 
@@ -489,18 +477,11 @@ static int aead_aes_gcm_siv_asm_open(const EVP_AEAD_CTX *ctx, uint8_t *out,
                              scratch, 1);
   }
 
-  union {
-    uint8_t c[16];
-    struct {
-      uint64_t ad;
-      uint64_t in;
-    } bitlens;
-  } length_block;
-
-  length_block.bitlens.ad = ad_len * 8;
-  length_block.bitlens.in = plaintext_len * 8;
+  uint8_t length_block[16];
+  CRYPTO_store_u64_le(length_block, ad_len * 8);
+  CRYPTO_store_u64_le(length_block + 8, plaintext_len * 8);
   aesgcmsiv_polyval_horner(calculated_tag, (const uint8_t *)record_auth_key,
-                           length_block.c, 1);
+                           length_block, 1);
 
   for (size_t i = 0; i < 12; i++) {
     calculated_tag[i] ^= nonce[i];
@@ -572,11 +553,9 @@ struct aead_aes_gcm_siv_ctx {
 OPENSSL_STATIC_ASSERT(sizeof(((EVP_AEAD_CTX *)NULL)->state) >=
                           sizeof(struct aead_aes_gcm_siv_ctx),
                       "AEAD state is too small");
-#if defined(__GNUC__) || defined(__clang__)
 OPENSSL_STATIC_ASSERT(alignof(union evp_aead_ctx_st_state) >=
                           alignof(struct aead_aes_gcm_siv_ctx),
                       "AEAD state has insufficient alignment");
-#endif
 
 static int aead_aes_gcm_siv_init(EVP_AEAD_CTX *ctx, const uint8_t *key,
                                  size_t key_len, size_t tag_len) {
@@ -619,18 +598,15 @@ static void aead_aes_gcm_siv_cleanup(EVP_AEAD_CTX *ctx) {}
 static void gcm_siv_crypt(uint8_t *out, const uint8_t *in, size_t in_len,
                           const uint8_t initial_counter[AES_BLOCK_SIZE],
                           block128_f enc_block, const AES_KEY *key) {
-  union {
-    uint32_t w[4];
-    uint8_t c[16];
-  } counter;
+  uint8_t counter[16];
 
-  OPENSSL_memcpy(counter.c, initial_counter, AES_BLOCK_SIZE);
-  counter.c[15] |= 0x80;
+  OPENSSL_memcpy(counter, initial_counter, AES_BLOCK_SIZE);
+  counter[15] |= 0x80;
 
   for (size_t done = 0; done < in_len;) {
     uint8_t keystream[AES_BLOCK_SIZE];
-    enc_block(counter.c, keystream, key);
-    counter.w[0]++;
+    enc_block(counter, keystream, key);
+    CRYPTO_store_u32_le(counter, CRYPTO_load_u32_le(counter) + 1);
 
     size_t todo = AES_BLOCK_SIZE;
     if (in_len - done < todo) {
@@ -670,17 +646,10 @@ static void gcm_siv_polyval(
     CRYPTO_POLYVAL_update_blocks(&polyval_ctx, scratch, sizeof(scratch));
   }
 
-  union {
-    uint8_t c[16];
-    struct {
-      uint64_t ad;
-      uint64_t in;
-    } bitlens;
-  } length_block;
-
-  length_block.bitlens.ad = ad_len * 8;
-  length_block.bitlens.in = in_len * 8;
-  CRYPTO_POLYVAL_update_blocks(&polyval_ctx, length_block.c,
+  uint8_t length_block[16];
+  CRYPTO_store_u64_le(length_block, ad_len * 8);
+  CRYPTO_store_u64_le(length_block + 8, in_len * 8);
+  CRYPTO_POLYVAL_update_blocks(&polyval_ctx, length_block,
                                sizeof(length_block));
 
   CRYPTO_POLYVAL_finish(&polyval_ctx, out_tag);

package/third_party/boringssl/src/crypto/cipher_extra/e_chacha20poly1305.c

@@ -35,11 +35,9 @@ struct aead_chacha20_poly1305_ctx {
 OPENSSL_STATIC_ASSERT(sizeof(((EVP_AEAD_CTX *)NULL)->state) >=
                           sizeof(struct aead_chacha20_poly1305_ctx),
                       "AEAD state is too small");
-#if defined(__GNUC__) || defined(__clang__)
 OPENSSL_STATIC_ASSERT(alignof(union evp_aead_ctx_st_state) >=
                           alignof(struct aead_chacha20_poly1305_ctx),
                       "AEAD state has insufficient alignment");
-#endif
 
 static int aead_chacha20_poly1305_init(EVP_AEAD_CTX *ctx, const uint8_t *key,
                                        size_t key_len, size_t tag_len) {

package/third_party/boringssl/src/crypto/cipher_extra/e_tls.c

@@ -48,11 +48,9 @@ OPENSSL_STATIC_ASSERT(EVP_MAX_MD_SIZE < 256,
 OPENSSL_STATIC_ASSERT(sizeof(((EVP_AEAD_CTX *)NULL)->state) >=
                           sizeof(AEAD_TLS_CTX),
                       "AEAD state is too small");
-#if defined(__GNUC__) || defined(__clang__)
 OPENSSL_STATIC_ASSERT(alignof(union evp_aead_ctx_st_state) >=
                           alignof(AEAD_TLS_CTX),
                       "AEAD state has insufficient alignment");
-#endif
 
 static void aead_tls_cleanup(EVP_AEAD_CTX *ctx) {
   AEAD_TLS_CTX *tls_ctx = (AEAD_TLS_CTX *)&ctx->state;