grpc 1.69.0 → 1.70.1

data/third_party/boringssl-with-bazel/src/crypto/fipsmodule/rsa/{rsa_impl.c.inc → rsa_impl.cc.inc}

@@ -79,10 +79,8 @@ int rsa_check_public_key(const RSA *rsa) {
     return 0;
   }
 
-  // TODO(davidben): 16384-bit RSA is huge. Can we bring this down to a limit of
-  // 8192-bit?
   unsigned n_bits = BN_num_bits(rsa->n);
-  if (n_bits > 16 * 1024) {
+  if (n_bits > OPENSSL_RSA_MAX_MODULUS_BITS) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_MODULUS_TOO_LARGE);
     return 0;
   }
@@ -149,8 +147,7 @@ static int ensure_fixed_copy(BIGNUM **out, const BIGNUM *in, int width) {
     return 1;
   }
   BIGNUM *copy = BN_dup(in);
-  if (copy == NULL ||
-      !bn_resize_words(copy, width)) {
+  if (copy == NULL || !bn_resize_words(copy, width)) {
     BN_free(copy);
     return 0;
   }
@@ -173,6 +170,7 @@ static int freeze_private_key(RSA *rsa, BN_CTX *ctx) {
   }
 
   int ret = 0;
+  const BIGNUM *n_fixed;
   CRYPTO_MUTEX_lock_write(&rsa->lock);
   if (rsa->private_key_frozen) {
     ret = 1;
@@ -196,7 +194,7 @@ static int freeze_private_key(RSA *rsa, BN_CTX *ctx) {
       goto err;
     }
   }
-  const BIGNUM *n_fixed = &rsa->mont_n->N;
+  n_fixed = &rsa->mont_n->N;
 
   // The only public upper-bound of |rsa->d| is the bit length of |rsa->n|. The
   // ASN.1 serialization of RSA private keys unfortunately leaks the byte length
@@ -233,9 +231,8 @@ static int freeze_private_key(RSA *rsa, BN_CTX *ctx) {
       // Key generation relies on this function to compute |iqmp|.
       if (rsa->iqmp == NULL) {
         BIGNUM *iqmp = BN_new();
-        if (iqmp == NULL ||
-            !bn_mod_inverse_secret_prime(iqmp, rsa->q, rsa->p, ctx,
-                                         rsa->mont_p)) {
+        if (iqmp == NULL || !bn_mod_inverse_secret_prime(iqmp, rsa->q, rsa->p,
+                                                         ctx, rsa->mont_p)) {
           BN_free(iqmp);
           goto err;
         }
@@ -302,9 +299,7 @@ void rsa_invalidate_key(RSA *rsa) {
   rsa->blinding_fork_generation = 0;
 }
 
-size_t rsa_default_size(const RSA *rsa) {
-  return BN_num_bytes(rsa->n);
-}
+size_t rsa_default_size(const RSA *rsa) { return BN_num_bytes(rsa->n); }
 
 // MAX_BLINDINGS_PER_RSA defines the maximum number of cached BN_BLINDINGs per
 // RSA*. Then this limit is exceeded, BN_BLINDING objects will be created and
@@ -344,8 +339,11 @@ static BN_BLINDING *rsa_blinding_get(RSA *rsa, size_t *index_used,
     rsa->blinding_fork_generation = fork_generation;
   }
 
-  uint8_t *const free_inuse_flag =
-      OPENSSL_memchr(rsa->blindings_inuse, 0, rsa->num_blindings);
+  uint8_t *const free_inuse_flag = reinterpret_cast<uint8_t *>(
+      OPENSSL_memchr(rsa->blindings_inuse, 0, rsa->num_blindings));
+  size_t new_num_blindings;
+  BN_BLINDING **new_blindings;
+  uint8_t *new_blindings_inuse;
   if (free_inuse_flag != NULL) {
     *free_inuse_flag = 1;
     *index_used = free_inuse_flag - rsa->blindings_inuse;
@@ -365,7 +363,7 @@ static BN_BLINDING *rsa_blinding_get(RSA *rsa, size_t *index_used,
   // Double the length of the cache.
   static_assert(MAX_BLINDINGS_PER_RSA < UINT_MAX / 2,
                 "MAX_BLINDINGS_PER_RSA too large");
-  size_t new_num_blindings = rsa->num_blindings * 2;
+  new_num_blindings = rsa->num_blindings * 2;
   if (new_num_blindings == 0) {
     new_num_blindings = 1;
   }
@@ -374,9 +372,10 @@ static BN_BLINDING *rsa_blinding_get(RSA *rsa, size_t *index_used,
   }
   assert(new_num_blindings > rsa->num_blindings);
 
-  BN_BLINDING **new_blindings =
-      OPENSSL_calloc(new_num_blindings, sizeof(BN_BLINDING *));
-  uint8_t *new_blindings_inuse = OPENSSL_malloc(new_num_blindings);
+  new_blindings = reinterpret_cast<BN_BLINDING **>(
+      OPENSSL_calloc(new_num_blindings, sizeof(BN_BLINDING *)));
+  new_blindings_inuse =
+      reinterpret_cast<uint8_t *>(OPENSSL_malloc(new_num_blindings));
   if (new_blindings == NULL || new_blindings_inuse == NULL) {
     goto err;
   }
@@ -447,7 +446,7 @@ int rsa_default_sign_raw(RSA *rsa, size_t *out_len, uint8_t *out,
     return 0;
   }
 
-  buf = OPENSSL_malloc(rsa_size);
+  buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(rsa_size));
   if (buf == NULL) {
     goto err;
   }
@@ -529,7 +528,7 @@ int rsa_verify_raw_no_self_test(RSA *rsa, size_t *out_len, uint8_t *out,
     buf = out;
   } else {
     // Allocate a temporary buffer to hold the padded plaintext.
-    buf = OPENSSL_malloc(rsa_size);
+    buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(rsa_size));
     if (buf == NULL) {
       goto err;
     }
@@ -582,9 +581,8 @@ err:
   return ret;
 }
 
-int RSA_verify_raw(RSA *rsa, size_t *out_len, uint8_t *out,
-                                size_t max_out, const uint8_t *in,
-                                size_t in_len, int padding) {
+int RSA_verify_raw(RSA *rsa, size_t *out_len, uint8_t *out, size_t max_out,
+                   const uint8_t *in, size_t in_len, int padding) {
   boringssl_ensure_rsa_self_test();
   return rsa_verify_raw_no_self_test(rsa, out_len, out, max_out, in, in_len,
                                      padding);
@@ -601,7 +599,7 @@ int rsa_default_private_transform(RSA *rsa, uint8_t *out, const uint8_t *in,
   BN_CTX *ctx = NULL;
   size_t blinding_index = 0;
   BN_BLINDING *blinding = NULL;
-  int ret = 0;
+  int ret = 0, do_blinding;
 
   ctx = BN_CTX_new();
   if (ctx == NULL) {
@@ -634,7 +632,7 @@ int rsa_default_private_transform(RSA *rsa, uint8_t *out, const uint8_t *in,
     goto err;
   }
 
-  const int do_blinding =
+  do_blinding =
       (rsa->flags & (RSA_FLAG_NO_BLINDING | RSA_FLAG_NO_PUBLIC_EXPONENT)) == 0;
 
   if (rsa->e == NULL && do_blinding) {
@@ -697,8 +695,7 @@ int rsa_default_private_transform(RSA *rsa, uint8_t *out, const uint8_t *in,
     }
   }
 
-  if (do_blinding &&
-      !BN_BLINDING_invert(result, blinding, rsa->mont_n, ctx)) {
+  if (do_blinding && !BN_BLINDING_invert(result, blinding, rsa->mont_n, ctx)) {
     goto err;
   }
 
@@ -741,7 +738,7 @@ static int mod_montgomery(BIGNUM *r, const BIGNUM *I, const BIGNUM *p,
     return 0;
   }
 
-  if (// Reduce mod p with Montgomery reduction. This computes I * R^-1 mod p.
+  if (  // Reduce mod p with Montgomery reduction. This computes I * R^-1 mod p.
       !BN_from_montgomery(r, I, mont_p, ctx) ||
       // Multiply by R^2 and do another Montgomery reduction to compute
       // I * R^-1 * R^2 * R^-1 = I mod p.
@@ -777,8 +774,8 @@ static int mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx) {
   BN_CTX_start(ctx);
   r1 = BN_CTX_get(ctx);
   m1 = BN_CTX_get(ctx);
-  if (r1 == NULL ||
-      m1 == NULL) {
+  BIGNUM *n, *p, *q;
+  if (r1 == NULL || m1 == NULL) {
     goto err;
   }
 
@@ -789,15 +786,15 @@ static int mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx) {
   // Use the minimal-width versions of |n|, |p|, and |q|. Either works, but if
   // someone gives us non-minimal values, these will be slightly more efficient
   // on the non-Montgomery operations.
-  const BIGNUM *n = &rsa->mont_n->N;
-  const BIGNUM *p = &rsa->mont_p->N;
-  const BIGNUM *q = &rsa->mont_q->N;
+  n = &rsa->mont_n->N;
+  p = &rsa->mont_p->N;
+  q = &rsa->mont_q->N;
 
   // This is a pre-condition for |mod_montgomery|. It was already checked by the
   // caller.
   declassify_assert(BN_ucmp(I, n) < 0);
 
-  if (// |m1| is the result modulo |q|.
+  if (  // |m1| is the result modulo |q|.
       !mod_montgomery(r1, I, q, rsa->mont_q, p, ctx) ||
       !BN_mod_exp_mont_consttime(m1, r1, rsa->dmq1_fixed, q, ctx,
                                  rsa->mont_q) ||
@@ -883,10 +880,12 @@ static int ensure_bignum(BIGNUM **out) {
 //     then []
 //     else let (high, low) = divrem 64 x in low : bnWords high
 //
-// showWord x = let (high, low) = divrem 32 x in printf "TOBN(0x%08x, 0x%08x)" high low
+// showWord x = let (high, low) = divrem 32 x in printf "TOBN(0x%08x, 0x%08x)"
+// high low
 //
 // output :: String
-// output = intercalate ", " $ map showWord $ bnWords $ converge (2 ^ (pow2 `div` 2))
+// output = intercalate ", " $ map showWord $ bnWords $ converge (2 ^ (pow2
+// `div` 2))
 //
 // To verify this number, check that n² < 2⁴⁰⁹⁵ < (n+1)², where n is value
 // represented here. Note the components are listed in little-endian order. Here
@@ -964,7 +963,7 @@ static int generate_prime(BIGNUM *out, int bits, const BIGNUM *e,
   // 22.21518251065506
   // >>> f(2048, 3, 8*2048)
   // 22.211701985875937
-  if (bits >= INT_MAX/32) {
+  if (bits >= INT_MAX / 32) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_MODULUS_TOO_LARGE);
     return 0;
   }
@@ -1088,16 +1087,18 @@ static int rsa_generate_key_impl(RSA *rsa, int bits, const BIGNUM *e_value,
   int ret = 0;
   int prime_bits = bits / 2;
   BN_CTX *ctx = BN_CTX_new();
+  BIGNUM *totient, *pm1, *qm1, *sqrt2, *pow2_prime_bits_100, *pow2_prime_bits;
+  int sqrt2_bits;
   if (ctx == NULL) {
     goto bn_err;
   }
   BN_CTX_start(ctx);
-  BIGNUM *totient = BN_CTX_get(ctx);
-  BIGNUM *pm1 = BN_CTX_get(ctx);
-  BIGNUM *qm1 = BN_CTX_get(ctx);
-  BIGNUM *sqrt2 = BN_CTX_get(ctx);
-  BIGNUM *pow2_prime_bits_100 = BN_CTX_get(ctx);
-  BIGNUM *pow2_prime_bits = BN_CTX_get(ctx);
+  totient = BN_CTX_get(ctx);
+  pm1 = BN_CTX_get(ctx);
+  qm1 = BN_CTX_get(ctx);
+  sqrt2 = BN_CTX_get(ctx);
+  pow2_prime_bits_100 = BN_CTX_get(ctx);
+  pow2_prime_bits = BN_CTX_get(ctx);
   if (totient == NULL || pm1 == NULL || qm1 == NULL || sqrt2 == NULL ||
       pow2_prime_bits_100 == NULL || pow2_prime_bits == NULL ||
       !BN_set_bit(pow2_prime_bits_100, prime_bits - 100) ||
@@ -1106,12 +1107,9 @@ static int rsa_generate_key_impl(RSA *rsa, int bits, const BIGNUM *e_value,
   }
 
   // We need the RSA components non-NULL.
-  if (!ensure_bignum(&rsa->n) ||
-      !ensure_bignum(&rsa->d) ||
-      !ensure_bignum(&rsa->e) ||
-      !ensure_bignum(&rsa->p) ||
-      !ensure_bignum(&rsa->q) ||
-      !ensure_bignum(&rsa->dmp1) ||
+  if (!ensure_bignum(&rsa->n) || !ensure_bignum(&rsa->d) ||
+      !ensure_bignum(&rsa->e) || !ensure_bignum(&rsa->p) ||
+      !ensure_bignum(&rsa->q) || !ensure_bignum(&rsa->dmp1) ||
       !ensure_bignum(&rsa->dmq1)) {
     goto bn_err;
   }
@@ -1124,7 +1122,7 @@ static int rsa_generate_key_impl(RSA *rsa, int bits, const BIGNUM *e_value,
   if (!bn_set_words(sqrt2, kBoringSSLRSASqrtTwo, kBoringSSLRSASqrtTwoLen)) {
     goto bn_err;
   }
-  int sqrt2_bits = kBoringSSLRSASqrtTwoLen * BN_BITS2;
+  sqrt2_bits = kBoringSSLRSASqrtTwoLen * BN_BITS2;
   assert(sqrt2_bits == (int)BN_num_bits(sqrt2));
   if (sqrt2_bits > prime_bits) {
     // For key sizes up to 4096 (prime_bits = 2048), this is exactly
@@ -1185,7 +1183,7 @@ static int rsa_generate_key_impl(RSA *rsa, int bits, const BIGNUM *e_value,
 
   assert(BN_num_bits(pm1) == (unsigned)prime_bits);
   assert(BN_num_bits(qm1) == (unsigned)prime_bits);
-  if (// Calculate n.
+  if (  // Calculate n.
       !bn_mul_consttime(rsa->n, rsa->p, rsa->q, ctx) ||
       // Calculate d mod (p-1).
       !bn_div_consttime(NULL, rsa->dmp1, rsa->d, pm1, prime_bits, ctx) ||
@@ -1331,8 +1329,7 @@ int RSA_generate_key_fips(RSA *rsa, int bits, BN_GENCB *cb) {
   }
 
   BIGNUM *e = BN_new();
-  int ret = e != NULL &&
-            BN_set_word(e, RSA_F4) &&
+  int ret = e != NULL && BN_set_word(e, RSA_F4) &&
             RSA_generate_key_ex_maybe_fips(rsa, bits, e, cb, /*check_fips=*/1);
   BN_free(e);
 

data/third_party/boringssl-with-bazel/src/crypto/fipsmodule/self_check/{fips.c.inc → fips.cc.inc}

@@ -1,4 +1,4 @@
-/* Copyright (c) 2017, Google Inc.
+/* Copyright 2017 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -30,6 +30,14 @@ int FIPS_mode_set(int on) { return on == FIPS_mode(); }
 
 const char *FIPS_module_name(void) { return "BoringCrypto"; }
 
+int CRYPTO_has_asm(void) {
+#if defined(OPENSSL_NO_ASM)
+  return 0;
+#else
+  return 1;
+#endif
+}
+
 uint32_t FIPS_version(void) {
   return 0;
 }
@@ -77,8 +85,8 @@ size_t FIPS_read_counter(enum fips_counter_t counter) {
     abort();
   }
 
-  const size_t *array =
-      CRYPTO_get_thread_local(OPENSSL_THREAD_LOCAL_FIPS_COUNTERS);
+  const size_t *array = reinterpret_cast<const size_t *>(
+      CRYPTO_get_thread_local(OPENSSL_THREAD_LOCAL_FIPS_COUNTERS));
   if (!array) {
     return 0;
   }
@@ -92,11 +100,11 @@ void boringssl_fips_inc_counter(enum fips_counter_t counter) {
     abort();
   }
 
-  size_t *array =
-      CRYPTO_get_thread_local(OPENSSL_THREAD_LOCAL_FIPS_COUNTERS);
+  size_t *array = reinterpret_cast<size_t *>(
+      CRYPTO_get_thread_local(OPENSSL_THREAD_LOCAL_FIPS_COUNTERS));
   if (!array) {
     const size_t num_bytes = sizeof(size_t) * (fips_counter_max + 1);
-    array = OPENSSL_zalloc(num_bytes);
+    array = reinterpret_cast<size_t *>(OPENSSL_zalloc(num_bytes));
     if (!array) {
       return;
     }

data/third_party/boringssl-with-bazel/src/crypto/fipsmodule/self_check/{self_check.c.inc → self_check.cc.inc}

@@ -1,4 +1,4 @@
-/* Copyright (c) 2017, Google Inc.
+/* Copyright 2017 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -24,14 +24,15 @@
 #include <openssl/dh.h>
 #include <openssl/digest.h>
 #include <openssl/ec.h>
-#include <openssl/ecdsa.h>
 #include <openssl/ec_key.h>
+#include <openssl/ecdsa.h>
 #include <openssl/hkdf.h>
 #include <openssl/hmac.h>
 #include <openssl/nid.h>
 #include <openssl/rsa.h>
 #include <openssl/sha.h>
 
+#include "../../bcm_support.h"
 #include "../../internal.h"
 #include "../delocate.h"
 #include "../dh/internal.h"
@@ -47,27 +48,27 @@
 // compile the real logic.
 #if defined(_MSC_VER)
 
-int BORINGSSL_self_test(void) {
-  return 0;
-}
+int BORINGSSL_self_test(void) { return 0; }
 
 #else
 
-static void hexdump(const uint8_t *in, size_t len) {
+static void hexdump(FILE *out, const void *in, size_t len) {
+  const uint8_t *in8 = reinterpret_cast<const uint8_t *>(in);
   for (size_t i = 0; i < len; i++) {
-    fprintf(stderr, "%02x", in[i]);
+    fprintf(out, "%02x", in8[i]);
   }
 }
 
 static int check_test(const void *expected, const void *actual,
                       size_t expected_len, const char *name) {
   if (OPENSSL_memcmp(actual, expected, expected_len) != 0) {
-    fprintf(stderr, "%s failed.\nExpected:   ", name);
-    hexdump(expected, expected_len);
-    fprintf(stderr, "\nCalculated: ");
-    hexdump(actual, expected_len);
-    fprintf(stderr, "\n");
-    fflush(stderr);
+    FILE *err = CRYPTO_get_stderr();
+    fprintf(err, "%s failed.\nExpected:   ", name);
+    hexdump(err, expected, expected_len);
+    fprintf(err, "\nCalculated: ");
+    hexdump(err, actual, expected_len);
+    fprintf(err, "\n");
+    fflush(err);
     return 0;
   }
   return 1;
@@ -195,7 +196,7 @@ static RSA *self_test_rsa_key(void) {
   };
 
   RSA *rsa = RSA_new();
-  if (rsa == NULL ||
+  if (rsa == NULL ||  //
       !set_bignum(&rsa->n, kN, sizeof(kN)) ||
       !set_bignum(&rsa->e, kE, sizeof(kE)) ||
       !set_bignum(&rsa->d, kD, sizeof(kD)) ||
@@ -294,7 +295,7 @@ static int boringssl_self_test_rsa(void) {
 
   RSA *const rsa_key = self_test_rsa_key();
   if (rsa_key == NULL) {
-    fprintf(stderr, "RSA key construction failed\n");
+    fprintf(CRYPTO_get_stderr(), "RSA key construction failed\n");
     goto err;
   }
   // Disable blinding for the power-on tests because it's not needed and
@@ -338,7 +339,7 @@ static int boringssl_self_test_rsa(void) {
                              output, &sig_len, rsa_key) ||
       !check_test(kRSASignSignature, output, sizeof(kRSASignSignature),
                   "RSA-sign KAT")) {
-    fprintf(stderr, "RSA signing test failed.\n");
+    fprintf(CRYPTO_get_stderr(), "RSA signing test failed.\n");
     goto err;
   }
 
@@ -376,7 +377,7 @@ static int boringssl_self_test_rsa(void) {
   if (!rsa_verify_no_self_test(NID_sha256, kRSAVerifyDigest,
                                sizeof(kRSAVerifyDigest), kRSAVerifySignature,
                                sizeof(kRSAVerifySignature), rsa_key)) {
-    fprintf(stderr, "RSA-verify KAT failed.\n");
+    fprintf(CRYPTO_get_stderr(), "RSA-verify KAT failed.\n");
     goto err;
   }
 
@@ -394,10 +395,15 @@ static int boringssl_self_test_ecc(void) {
   EC_POINT *ec_point_in = NULL;
   EC_POINT *ec_point_out = NULL;
   BIGNUM *ec_scalar = NULL;
+  const EC_GROUP *ec_group = NULL;
+
+  // The 'k' value for ECDSA is fixed to avoid an entropy draw.
+  uint8_t ecdsa_k[32] = {0};
+  ecdsa_k[31] = 42;
 
   ec_key = self_test_ecdsa_key();
   if (ec_key == NULL) {
-    fprintf(stderr, "ECDSA KeyGen failed\n");
+    fprintf(CRYPTO_get_stderr(), "ECDSA KeyGen failed\n");
     goto err;
   }
 
@@ -417,10 +423,6 @@ static int boringssl_self_test_ecc(void) {
       0x70, 0xb5, 0xbb, 0x0d, 0xfd, 0x8e, 0x0c, 0x02, 0x3f,
   };
 
-  // The 'k' value for ECDSA is fixed to avoid an entropy draw.
-  uint8_t ecdsa_k[32] = {0};
-  ecdsa_k[31] = 42;
-
   uint8_t ecdsa_sign_output[64];
   size_t ecdsa_sign_output_len;
   if (!ecdsa_sign_fixed_with_nonce_for_known_answer_test(
@@ -429,7 +431,7 @@ static int boringssl_self_test_ecc(void) {
           sizeof(ecdsa_k)) ||
       !check_test(kECDSASignSig, ecdsa_sign_output, sizeof(ecdsa_sign_output),
                   "ECDSA-sign signature")) {
-    fprintf(stderr, "ECDSA-sign KAT failed.\n");
+    fprintf(CRYPTO_get_stderr(), "ECDSA-sign KAT failed.\n");
     goto err;
   }
 
@@ -450,7 +452,7 @@ static int boringssl_self_test_ecc(void) {
   if (!ecdsa_verify_fixed_no_self_test(
           kECDSAVerifyDigest, sizeof(kECDSAVerifyDigest), kECDSAVerifySig,
           sizeof(kECDSAVerifySig), ec_key)) {
-    fprintf(stderr, "ECDSA-verify KAT failed.\n");
+    fprintf(CRYPTO_get_stderr(), "ECDSA-verify KAT failed.\n");
     goto err;
   }
 
@@ -481,7 +483,7 @@ static int boringssl_self_test_ecc(void) {
       0x7c, 0x41, 0x8f, 0xaf, 0x9c, 0x40, 0xaf, 0x2e, 0x4a, 0x0c,
   };
 
-  const EC_GROUP *ec_group = EC_group_p256();
+  ec_group = EC_group_p256();
   ec_point_in = EC_POINT_new(ec_group);
   ec_point_out = EC_POINT_new(ec_group);
   ec_scalar = BN_new();
@@ -496,7 +498,7 @@ static int boringssl_self_test_ecc(void) {
                           z_comp_result, sizeof(z_comp_result), NULL) ||
       !check_test(kP256PointResult, z_comp_result, sizeof(z_comp_result),
                   "Z Computation Result")) {
-    fprintf(stderr, "Z-computation KAT failed.\n");
+    fprintf(CRYPTO_get_stderr(), "Z-computation KAT failed.\n");
     goto err;
   }
 
@@ -575,7 +577,7 @@ static int boringssl_self_test_ffdh(void) {
       dh_compute_key_padded_no_self_test(dh_out, ffdhe2048_value, dh) !=
           sizeof(dh_out) ||
       !check_test(kDHOutput, dh_out, sizeof(dh_out), "FFC DH")) {
-    fprintf(stderr, "FFDH failed.\n");
+    fprintf(CRYPTO_get_stderr(), "FFDH failed.\n");
     goto err;
   }
 
@@ -598,7 +600,7 @@ static void run_self_test_rsa(void) {
   FIPS_service_indicator_unlock_state();
 }
 
-DEFINE_STATIC_ONCE(g_self_test_once_rsa);
+DEFINE_STATIC_ONCE(g_self_test_once_rsa)
 
 void boringssl_ensure_rsa_self_test(void) {
   CRYPTO_once(g_self_test_once_rsa_bss_get(), run_self_test_rsa);
@@ -612,7 +614,7 @@ static void run_self_test_ecc(void) {
   FIPS_service_indicator_unlock_state();
 }
 
-DEFINE_STATIC_ONCE(g_self_test_once_ecc);
+DEFINE_STATIC_ONCE(g_self_test_once_ecc)
 
 void boringssl_ensure_ecc_self_test(void) {
   CRYPTO_once(g_self_test_once_ecc_bss_get(), run_self_test_ecc);
@@ -626,7 +628,7 @@ static void run_self_test_ffdh(void) {
   FIPS_service_indicator_unlock_state();
 }
 
-DEFINE_STATIC_ONCE(g_self_test_once_ffdh);
+DEFINE_STATIC_ONCE(g_self_test_once_ffdh)
 
 void boringssl_ensure_ffdh_self_test(void) {
   CRYPTO_once(g_self_test_once_ffdh_bss_get(), run_self_test_ffdh);
@@ -699,7 +701,10 @@ int boringssl_self_test_hmac_sha256(void) {
 }
 
 static int boringssl_self_test_fast(void) {
-  static const uint8_t kAESKey[16] = "BoringCrypto Key";
+  static const uint8_t kAESKey[16] = {
+      'B', 'o', 'r', 'i', 'n', 'g', 'C', 'r',
+      'y', 'p', 't', 'o', ' ', 'K', 'e', 'y',
+  };
   static const uint8_t kAESIV[16] = {0};
 
   EVP_AEAD_CTX aead_ctx;
@@ -723,7 +728,7 @@ static int boringssl_self_test_fast(void) {
   };
   memcpy(aes_iv, kAESIV, sizeof(kAESIV));
   if (AES_set_encrypt_key(kAESKey, 8 * sizeof(kAESKey), &aes_key) != 0) {
-    fprintf(stderr, "AES_set_encrypt_key failed.\n");
+    fprintf(CRYPTO_get_stderr(), "AES_set_encrypt_key failed.\n");
     goto err;
   }
   AES_cbc_encrypt(kAESCBCEncPlaintext, output, sizeof(kAESCBCEncPlaintext),
@@ -746,7 +751,7 @@ static int boringssl_self_test_fast(void) {
   };
   memcpy(aes_iv, kAESIV, sizeof(kAESIV));
   if (AES_set_decrypt_key(kAESKey, 8 * sizeof(kAESKey), &aes_key) != 0) {
-    fprintf(stderr, "AES_set_decrypt_key failed.\n");
+    fprintf(CRYPTO_get_stderr(), "AES_set_decrypt_key failed.\n");
     goto err;
   }
   AES_cbc_encrypt(kAESCBCDecCiphertext, output, sizeof(kAESCBCDecCiphertext),
@@ -761,7 +766,7 @@ static int boringssl_self_test_fast(void) {
   OPENSSL_memset(nonce, 0, sizeof(nonce));
   if (!EVP_AEAD_CTX_init(&aead_ctx, EVP_aead_aes_128_gcm(), kAESKey,
                          sizeof(kAESKey), 0, NULL)) {
-    fprintf(stderr, "EVP_AEAD_CTX_init for AES-128-GCM failed.\n");
+    fprintf(CRYPTO_get_stderr(), "EVP_AEAD_CTX_init for AES-128-GCM failed.\n");
     goto err;
   }
 
@@ -783,7 +788,7 @@ static int boringssl_self_test_fast(void) {
                          0) ||
       !check_test(kAESGCMCiphertext, output, sizeof(kAESGCMCiphertext),
                   "AES-GCM-encrypt KAT")) {
-    fprintf(stderr, "EVP_AEAD_CTX_seal for AES-128-GCM failed.\n");
+    fprintf(CRYPTO_get_stderr(), "EVP_AEAD_CTX_seal for AES-128-GCM failed.\n");
     goto err;
   }
 
@@ -806,7 +811,7 @@ static int boringssl_self_test_fast(void) {
                          NULL, 0) ||
       !check_test(kAESGCMDecPlaintext, output, sizeof(kAESGCMDecPlaintext),
                   "AES-GCM-decrypt KAT")) {
-    fprintf(stderr,
+    fprintf(CRYPTO_get_stderr(),
             "AES-GCM-decrypt KAT failed because EVP_AEAD_CTX_open failed.\n");
     goto err;
   }
@@ -821,13 +826,11 @@ static int boringssl_self_test_fast(void) {
       0x09, 0x11, 0x6d, 0x1a, 0xfd, 0x0f, 0x1e, 0x11, 0xe3, 0xcb,
   };
   SHA1(kSHA1Input, sizeof(kSHA1Input), output);
-  if (!check_test(kSHA1Digest, output, sizeof(kSHA1Digest),
-                  "SHA-1 KAT")) {
+  if (!check_test(kSHA1Digest, output, sizeof(kSHA1Digest), "SHA-1 KAT")) {
     goto err;
   }
 
-  if (!boringssl_self_test_sha256() ||
-      !boringssl_self_test_sha512() ||
+  if (!boringssl_self_test_sha256() || !boringssl_self_test_sha512() ||
       !boringssl_self_test_hmac_sha256()) {
     goto err;
   }
@@ -839,8 +842,11 @@ static int boringssl_self_test_fast(void) {
       0x3f, 0x17, 0x4c, 0xf4, 0x78, 0x7a, 0x4f, 0x1a, 0x40, 0xc2, 0xb5, 0x0b,
       0xab, 0xe1, 0x4a, 0xae, 0x53, 0x0b, 0xe5, 0x88, 0x6d, 0x91, 0x0a, 0x27,
   };
-  static const uint8_t kDRBGPersonalization[18] = "BCMPersonalization";
-  static const uint8_t kDRBGAD[16] = "BCM DRBG KAT AD ";
+  static const uint8_t kDRBGPersonalization[18] = {
+      'B', 'C', 'M', 'P', 'e', 'r', 's', 'o', 'n',
+      'a', 'l', 'i', 'z', 'a', 't', 'i', 'o', 'n'};
+  static const uint8_t kDRBGAD[16] = {'B', 'C', 'M', ' ', 'D', 'R', 'B', 'G',
+                                      ' ', 'K', 'A', 'T', ' ', 'A', 'D', ' '};
   static const uint8_t kDRBGOutput[64] = {
       0x19, 0x1f, 0x2b, 0x49, 0x76, 0x85, 0xfd, 0x51, 0xb6, 0x56, 0xbc,
       0x1c, 0x7d, 0xd5, 0xdd, 0x44, 0x76, 0xa3, 0x5e, 0x17, 0x9b, 0x8e,
@@ -875,7 +881,7 @@ static int boringssl_self_test_fast(void) {
                          sizeof(kDRBGAD)) ||
       !check_test(kDRBGReseedOutput, output, sizeof(kDRBGReseedOutput),
                   "DRBG-reseed KAT")) {
-    fprintf(stderr, "CTR-DRBG failed.\n");
+    fprintf(CRYPTO_get_stderr(), "CTR-DRBG failed.\n");
     goto err;
   }
   CTR_DRBG_clear(&drbg);
@@ -914,7 +920,7 @@ static int boringssl_self_test_fast(void) {
                        kTLSSeed2, sizeof(kTLSSeed2)) ||
       !check_test(kTLS10Output, tls10_output, sizeof(kTLS10Output),
                   "TLS10-KDF KAT")) {
-    fprintf(stderr, "TLS KDF failed.\n");
+    fprintf(CRYPTO_get_stderr(), "TLS KDF failed.\n");
     goto err;
   }
 
@@ -935,7 +941,7 @@ static int boringssl_self_test_fast(void) {
                        kTLSSeed2, sizeof(kTLSSeed2)) ||
       !check_test(kTLS12Output, tls12_output, sizeof(kTLS12Output),
                   "TLS12-KDF KAT")) {
-    fprintf(stderr, "TLS KDF failed.\n");
+    fprintf(CRYPTO_get_stderr(), "TLS KDF failed.\n");
     goto err;
   }
 
@@ -975,7 +981,7 @@ static int boringssl_self_test_fast(void) {
       !check_test(kTLS13ExpandLabelOutput, tls13_expand_label_output,
                   sizeof(kTLS13ExpandLabelOutput),
                   "CRYPTO_tls13_hkdf_expand_label")) {
-    fprintf(stderr, "TLS13-KDF failed.\n");
+    fprintf(CRYPTO_get_stderr(), "TLS13-KDF failed.\n");
     goto err;
   }
 
@@ -1005,7 +1011,7 @@ static int boringssl_self_test_fast(void) {
             sizeof(kHKDFSecret), kHKDFSalt, sizeof(kHKDFSalt), kHKDFInfo,
             sizeof(kHKDFInfo)) ||
       !check_test(kHKDFOutput, hkdf_output, sizeof(kHKDFOutput), "HKDF")) {
-    fprintf(stderr, "HKDF failed.\n");
+    fprintf(CRYPTO_get_stderr(), "HKDF failed.\n");
     goto err;
   }
 
@@ -1020,8 +1026,8 @@ err:
 int BORINGSSL_self_test(void) {
   if (!boringssl_self_test_fast() ||
       // When requested to run self tests, also run the lazy tests.
-      !boringssl_self_test_rsa() ||
-      !boringssl_self_test_ecc() ||
+      !boringssl_self_test_rsa() ||  //
+      !boringssl_self_test_ecc() ||  //
       !boringssl_self_test_ffdh()) {
     return 0;
   }
@@ -1030,9 +1036,7 @@ int BORINGSSL_self_test(void) {
 }
 
 #if defined(BORINGSSL_FIPS)
-int boringssl_self_test_startup(void) {
-  return boringssl_self_test_fast();
-}
+int boringssl_self_test_startup(void) { return boringssl_self_test_fast(); }
 #endif
 
 #endif  // !_MSC_VER