grpc 1.69.0 → 1.70.1

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

@@ -59,85 +59,35 @@
 #include <assert.h>
 #include <string.h>
 
-#include <openssl/md4.h>
-#include <openssl/md5.h>
 #include <openssl/nid.h>
-#include <openssl/sha.h>
 
-#include "internal.h"
-#include "../delocate.h"
 #include "../../internal.h"
+#include "../bcm_interface.h"
+#include "../delocate.h"
+#include "internal.h"
 
 #if defined(NDEBUG)
-#define CHECK(x) (void) (x)
+#define CHECK(x) (void)(x)
 #else
 #define CHECK(x) assert(x)
 #endif
 
 
-static void md4_init(EVP_MD_CTX *ctx) {
-  CHECK(MD4_Init(ctx->md_data));
-}
-
-static void md4_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
-  CHECK(MD4_Update(ctx->md_data, data, count));
-}
-
-static void md4_final(EVP_MD_CTX *ctx, uint8_t *out) {
-  CHECK(MD4_Final(out, ctx->md_data));
-}
-
-DEFINE_METHOD_FUNCTION(EVP_MD, EVP_md4) {
-  out->type = NID_md4;
-  out->md_size = MD4_DIGEST_LENGTH;
-  out->flags = 0;
-  out->init = md4_init;
-  out->update = md4_update;
-  out->final = md4_final;
-  out->block_size = 64;
-  out->ctx_size = sizeof(MD4_CTX);
-}
-
-
-static void md5_init(EVP_MD_CTX *ctx) {
-  CHECK(MD5_Init(ctx->md_data));
-}
-
-static void md5_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
-  CHECK(MD5_Update(ctx->md_data, data, count));
-}
-
-static void md5_final(EVP_MD_CTX *ctx, uint8_t *out) {
-  CHECK(MD5_Final(out, ctx->md_data));
-}
-
-DEFINE_METHOD_FUNCTION(EVP_MD, EVP_md5) {
-  out->type = NID_md5;
-  out->md_size = MD5_DIGEST_LENGTH;
-  out->flags = 0;
-  out->init = md5_init;
-  out->update = md5_update;
-  out->final = md5_final;
-  out->block_size = 64;
-  out->ctx_size = sizeof(MD5_CTX);
-}
-
-
 static void sha1_init(EVP_MD_CTX *ctx) {
-  CHECK(SHA1_Init(ctx->md_data));
+  BCM_sha1_init(reinterpret_cast<SHA_CTX *>(ctx->md_data));
 }
 
 static void sha1_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
-  CHECK(SHA1_Update(ctx->md_data, data, count));
+  BCM_sha1_update(reinterpret_cast<SHA_CTX *>(ctx->md_data), data, count);
 }
 
 static void sha1_final(EVP_MD_CTX *ctx, uint8_t *md) {
-  CHECK(SHA1_Final(md, ctx->md_data));
+  BCM_sha1_final(md, reinterpret_cast<SHA_CTX *>(ctx->md_data));
 }
 
 DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha1) {
   out->type = NID_sha1;
-  out->md_size = SHA_DIGEST_LENGTH;
+  out->md_size = BCM_SHA_DIGEST_LENGTH;
   out->flags = 0;
   out->init = sha1_init;
   out->update = sha1_update;
@@ -148,20 +98,20 @@ DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha1) {
 
 
 static void sha224_init(EVP_MD_CTX *ctx) {
-  CHECK(SHA224_Init(ctx->md_data));
+  BCM_sha224_init(reinterpret_cast<SHA256_CTX *>(ctx->md_data));
 }
 
 static void sha224_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
-  CHECK(SHA224_Update(ctx->md_data, data, count));
+  BCM_sha224_update(reinterpret_cast<SHA256_CTX *>(ctx->md_data), data, count);
 }
 
 static void sha224_final(EVP_MD_CTX *ctx, uint8_t *md) {
-  CHECK(SHA224_Final(md, ctx->md_data));
+  BCM_sha224_final(md, reinterpret_cast<SHA256_CTX *>(ctx->md_data));
 }
 
 DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha224) {
   out->type = NID_sha224;
-  out->md_size = SHA224_DIGEST_LENGTH;
+  out->md_size = BCM_SHA224_DIGEST_LENGTH;
   out->flags = 0;
   out->init = sha224_init;
   out->update = sha224_update;
@@ -172,20 +122,20 @@ DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha224) {
 
 
 static void sha256_init(EVP_MD_CTX *ctx) {
-  CHECK(SHA256_Init(ctx->md_data));
+  BCM_sha256_init(reinterpret_cast<SHA256_CTX *>(ctx->md_data));
 }
 
 static void sha256_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
-  CHECK(SHA256_Update(ctx->md_data, data, count));
+  BCM_sha256_update(reinterpret_cast<SHA256_CTX *>(ctx->md_data), data, count);
 }
 
 static void sha256_final(EVP_MD_CTX *ctx, uint8_t *md) {
-  CHECK(SHA256_Final(md, ctx->md_data));
+  BCM_sha256_final(md, reinterpret_cast<SHA256_CTX *>(ctx->md_data));
 }
 
 DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha256) {
   out->type = NID_sha256;
-  out->md_size = SHA256_DIGEST_LENGTH;
+  out->md_size = BCM_SHA256_DIGEST_LENGTH;
   out->flags = 0;
   out->init = sha256_init;
   out->update = sha256_update;
@@ -196,20 +146,20 @@ DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha256) {
 
 
 static void sha384_init(EVP_MD_CTX *ctx) {
-  CHECK(SHA384_Init(ctx->md_data));
+  BCM_sha384_init(reinterpret_cast<SHA512_CTX *>(ctx->md_data));
 }
 
 static void sha384_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
-  CHECK(SHA384_Update(ctx->md_data, data, count));
+  BCM_sha384_update(reinterpret_cast<SHA512_CTX *>(ctx->md_data), data, count);
 }
 
 static void sha384_final(EVP_MD_CTX *ctx, uint8_t *md) {
-  CHECK(SHA384_Final(md, ctx->md_data));
+  BCM_sha384_final(md, reinterpret_cast<SHA512_CTX *>(ctx->md_data));
 }
 
 DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha384) {
   out->type = NID_sha384;
-  out->md_size = SHA384_DIGEST_LENGTH;
+  out->md_size = BCM_SHA384_DIGEST_LENGTH;
   out->flags = 0;
   out->init = sha384_init;
   out->update = sha384_update;
@@ -220,20 +170,20 @@ DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha384) {
 
 
 static void sha512_init(EVP_MD_CTX *ctx) {
-  CHECK(SHA512_Init(ctx->md_data));
+  BCM_sha512_init(reinterpret_cast<SHA512_CTX *>(ctx->md_data));
 }
 
 static void sha512_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
-  CHECK(SHA512_Update(ctx->md_data, data, count));
+  BCM_sha512_update(reinterpret_cast<SHA512_CTX *>(ctx->md_data), data, count);
 }
 
 static void sha512_final(EVP_MD_CTX *ctx, uint8_t *md) {
-  CHECK(SHA512_Final(md, ctx->md_data));
+  BCM_sha512_final(md, reinterpret_cast<SHA512_CTX *>(ctx->md_data));
 }
 
 DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha512) {
   out->type = NID_sha512;
-  out->md_size = SHA512_DIGEST_LENGTH;
+  out->md_size = BCM_SHA512_DIGEST_LENGTH;
   out->flags = 0;
   out->init = sha512_init;
   out->update = sha512_update;
@@ -244,20 +194,21 @@ DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha512) {
 
 
 static void sha512_256_init(EVP_MD_CTX *ctx) {
-  CHECK(SHA512_256_Init(ctx->md_data));
+  BCM_sha512_256_init(reinterpret_cast<SHA512_CTX *>(ctx->md_data));
 }
 
 static void sha512_256_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
-  CHECK(SHA512_256_Update(ctx->md_data, data, count));
+  BCM_sha512_256_update(reinterpret_cast<SHA512_CTX *>(ctx->md_data), data,
+                        count);
 }
 
 static void sha512_256_final(EVP_MD_CTX *ctx, uint8_t *md) {
-  CHECK(SHA512_256_Final(md, ctx->md_data));
+  BCM_sha512_256_final(md, reinterpret_cast<SHA512_CTX *>(ctx->md_data));
 }
 
 DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha512_256) {
   out->type = NID_sha512_256;
-  out->md_size = SHA512_256_DIGEST_LENGTH;
+  out->md_size = BCM_SHA512_256_DIGEST_LENGTH;
   out->flags = 0;
   out->init = sha512_256_init;
   out->update = sha512_256_update;
@@ -266,39 +217,4 @@ DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha512_256) {
   out->ctx_size = sizeof(SHA512_CTX);
 }
 
-
-typedef struct {
-  MD5_CTX md5;
-  SHA_CTX sha1;
-} MD5_SHA1_CTX;
-
-static void md5_sha1_init(EVP_MD_CTX *md_ctx) {
-  MD5_SHA1_CTX *ctx = md_ctx->md_data;
-  CHECK(MD5_Init(&ctx->md5) && SHA1_Init(&ctx->sha1));
-}
-
-static void md5_sha1_update(EVP_MD_CTX *md_ctx, const void *data,
-                            size_t count) {
-  MD5_SHA1_CTX *ctx = md_ctx->md_data;
-  CHECK(MD5_Update(&ctx->md5, data, count) &&
-        SHA1_Update(&ctx->sha1, data, count));
-}
-
-static void md5_sha1_final(EVP_MD_CTX *md_ctx, uint8_t *out) {
-  MD5_SHA1_CTX *ctx = md_ctx->md_data;
-  CHECK(MD5_Final(out, &ctx->md5) &&
-        SHA1_Final(out + MD5_DIGEST_LENGTH, &ctx->sha1));
-}
-
-DEFINE_METHOD_FUNCTION(EVP_MD, EVP_md5_sha1) {
-  out->type = NID_md5_sha1;
-  out->md_size = MD5_DIGEST_LENGTH + SHA_DIGEST_LENGTH;
-  out->flags = 0;
-  out->init = md5_sha1_init;
-  out->update = md5_sha1_update;
-  out->final = md5_sha1_final;
-  out->block_size = 64;
-  out->ctx_size = sizeof(MD5_SHA1_CTX);
-}
-
 #undef CHECK

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

@@ -1,5 +1,5 @@
-/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
- * project 2006.
+/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
+ * 2006.
  */
 /* ====================================================================
  * Copyright (c) 2006,2007 The OpenSSL Project.  All rights reserved.
@@ -71,7 +71,7 @@ enum evp_sign_verify_t {
 DEFINE_LOCAL_DATA(struct evp_md_pctx_ops, md_pctx_ops) {
   out->free = EVP_PKEY_CTX_free;
   out->dup = EVP_PKEY_CTX_dup;
-};
+}
 
 static int uses_prehash(EVP_MD_CTX *ctx, enum evp_sign_verify_t op) {
   return (op == evp_sign) ? (ctx->pctx->pmeth->sign != NULL)

data/third_party/boringssl-with-bazel/src/crypto/fipsmodule/ec/builtin_curves.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2023, Google Inc.
+/* Copyright 2023 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

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

@@ -75,10 +75,10 @@
 #include <openssl/mem.h>
 #include <openssl/nid.h>
 
-#include "internal.h"
 #include "../../internal.h"
 #include "../bn/internal.h"
 #include "../delocate.h"
+#include "internal.h"
 
 #include "builtin_curves.h"
 
@@ -245,12 +245,11 @@ EC_GROUP *EC_GROUP_new_curve_GFp(const BIGNUM *p, const BIGNUM *a,
   BIGNUM *a_reduced = BN_CTX_get(ctx);
   BIGNUM *b_reduced = BN_CTX_get(ctx);
   if (a_reduced == NULL || b_reduced == NULL ||
-      !BN_nnmod(a_reduced, a, p, ctx) ||
-      !BN_nnmod(b_reduced, b, p, ctx)) {
+      !BN_nnmod(a_reduced, a, p, ctx) || !BN_nnmod(b_reduced, b, p, ctx)) {
     goto err;
   }
 
-  ret = OPENSSL_zalloc(sizeof(EC_GROUP));
+  ret = reinterpret_cast<EC_GROUP *>(OPENSSL_zalloc(sizeof(EC_GROUP)));
   if (ret == NULL) {
     return NULL;
   }
@@ -301,8 +300,7 @@ int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator,
   // the ECDSA implementation.
   int ret = 0;
   BIGNUM *tmp = BN_new();
-  if (tmp == NULL ||
-      !BN_lshift1(tmp, order)) {
+  if (tmp == NULL || !BN_lshift1(tmp, order)) {
     goto err;
   }
   if (BN_cmp(tmp, &group->field.N) <= 0) {
@@ -470,7 +468,7 @@ EC_POINT *EC_POINT_new(const EC_GROUP *group) {
     return NULL;
   }
 
-  EC_POINT *ret = OPENSSL_malloc(sizeof *ret);
+  EC_POINT *ret = reinterpret_cast<EC_POINT *>(OPENSSL_malloc(sizeof *ret));
   if (ret == NULL) {
     return NULL;
   }
@@ -514,8 +512,7 @@ EC_POINT *EC_POINT_dup(const EC_POINT *a, const EC_GROUP *group) {
   }
 
   EC_POINT *ret = EC_POINT_new(group);
-  if (ret == NULL ||
-      !EC_POINT_copy(ret, a)) {
+  if (ret == NULL || !EC_POINT_copy(ret, a)) {
     EC_POINT_free(ret);
     return NULL;
   }
@@ -720,8 +717,7 @@ static int arbitrary_bignum_to_scalar(const EC_GROUP *group, EC_SCALAR *out,
   // This is an unusual input, so we do not guarantee constant-time processing.
   BN_CTX_start(ctx);
   BIGNUM *tmp = BN_CTX_get(ctx);
-  int ok = tmp != NULL &&
-           BN_nnmod(tmp, in, EC_GROUP_get0_order(group), ctx) &&
+  int ok = tmp != NULL && BN_nnmod(tmp, in, EC_GROUP_get0_order(group), ctx) &&
            ec_bignum_to_scalar(group, out, tmp);
   BN_CTX_end(ctx);
   return ok;
@@ -734,7 +730,7 @@ int ec_point_mul_no_self_test(const EC_GROUP *group, EC_POINT *r,
   // nothing to multiply. But, nobody should be calling this function with
   // nothing to multiply in the first place.
   if ((g_scalar == NULL && p_scalar == NULL) ||
-      (p == NULL) != (p_scalar == NULL))  {
+      (p == NULL) != (p_scalar == NULL)) {
     OPENSSL_PUT_ERROR(EC, ERR_R_PASSED_NULL_PARAMETER);
     return 0;
   }
@@ -874,8 +870,7 @@ int ec_point_mul_scalar_base(const EC_GROUP *group, EC_JACOBIAN *r,
 int ec_point_mul_scalar_batch(const EC_GROUP *group, EC_JACOBIAN *r,
                               const EC_JACOBIAN *p0, const EC_SCALAR *scalar0,
                               const EC_JACOBIAN *p1, const EC_SCALAR *scalar1,
-                              const EC_JACOBIAN *p2,
-                              const EC_SCALAR *scalar2) {
+                              const EC_JACOBIAN *p2, const EC_SCALAR *scalar2) {
   if (group->meth->mul_batch == NULL) {
     OPENSSL_PUT_ERROR(EC, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
     return 0;
@@ -926,7 +921,7 @@ int ec_point_mul_scalar_precomp(const EC_GROUP *group, EC_JACOBIAN *r,
 }
 
 void ec_point_select(const EC_GROUP *group, EC_JACOBIAN *out, BN_ULONG mask,
-                      const EC_JACOBIAN *a, const EC_JACOBIAN *b) {
+                     const EC_JACOBIAN *a, const EC_JACOBIAN *b) {
   ec_felem_select(group, &out->X, mask, &a->X, &b->X);
   ec_felem_select(group, &out->Y, mask, &a->Y, &b->Y);
   ec_felem_select(group, &out->Z, mask, &a->Z, &b->Z);

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

@@ -75,20 +75,21 @@
 #include <openssl/err.h>
 #include <openssl/ex_data.h>
 #include <openssl/mem.h>
-#include <openssl/sha.h>
 #include <openssl/thread.h>
 
-#include "internal.h"
+#include "../../internal.h"
+#include "../bcm_interface.h"
 #include "../delocate.h"
 #include "../ecdsa/internal.h"
 #include "../service_indicator/internal.h"
-#include "../../internal.h"
+#include "internal.h"
 
 
 DEFINE_STATIC_EX_DATA_CLASS(g_ec_ex_data_class)
 
 static EC_WRAPPED_SCALAR *ec_wrapped_scalar_new(const EC_GROUP *group) {
-  EC_WRAPPED_SCALAR *wrapped = OPENSSL_zalloc(sizeof(EC_WRAPPED_SCALAR));
+  EC_WRAPPED_SCALAR *wrapped = reinterpret_cast<EC_WRAPPED_SCALAR *>(
+      OPENSSL_zalloc(sizeof(EC_WRAPPED_SCALAR)));
   if (wrapped == NULL) {
     return NULL;
   }
@@ -107,7 +108,7 @@ static void ec_wrapped_scalar_free(EC_WRAPPED_SCALAR *scalar) {
 EC_KEY *EC_KEY_new(void) { return EC_KEY_new_method(NULL); }
 
 EC_KEY *EC_KEY_new_method(const ENGINE *engine) {
-  EC_KEY *ret = OPENSSL_zalloc(sizeof(EC_KEY));
+  EC_KEY *ret = reinterpret_cast<EC_KEY *>(OPENSSL_zalloc(sizeof(EC_KEY)));
   if (ret == NULL) {
     return NULL;
   }
@@ -185,10 +186,8 @@ EC_KEY *EC_KEY_dup(const EC_KEY *src) {
     return NULL;
   }
 
-  if ((src->group != NULL &&
-       !EC_KEY_set_group(ret, src->group)) ||
-      (src->pub_key != NULL &&
-       !EC_KEY_set_public_key(ret, src->pub_key)) ||
+  if ((src->group != NULL && !EC_KEY_set_group(ret, src->group)) ||
+      (src->pub_key != NULL && !EC_KEY_set_public_key(ret, src->pub_key)) ||
       (src->priv_key != NULL &&
        !EC_KEY_set_private_key(ret, EC_KEY_get0_private_key(src)))) {
     EC_KEY_free(ret);
@@ -346,7 +345,7 @@ int EC_KEY_check_fips(const EC_KEY *key) {
   }
 
   if (key->priv_key) {
-    uint8_t digest[SHA256_DIGEST_LENGTH] = {0};
+    uint8_t digest[BCM_SHA256_DIGEST_LENGTH] = {0};
     uint8_t sig[ECDSA_MAX_FIXED_LEN];
     size_t sig_len;
     if (!ecdsa_sign_fixed(digest, sizeof(digest), sig, &sig_len, sizeof(sig),
@@ -386,8 +385,7 @@ int EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, const BIGNUM *x,
   point = EC_POINT_new(key->group);
   if (point == NULL ||
       !EC_POINT_set_affine_coordinates_GFp(key->group, point, x, y, NULL) ||
-      !EC_KEY_set_public_key(key, point) ||
-      !EC_KEY_check_key(key)) {
+      !EC_KEY_set_public_key(key, point) || !EC_KEY_check_key(key)) {
     goto err;
   }
 
@@ -469,7 +467,7 @@ size_t EC_KEY_priv2buf(const EC_KEY *key, uint8_t **out_buf) {
     return 0;
   }
 
-  uint8_t *buf = OPENSSL_malloc(len);
+  uint8_t *buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(len));
   if (buf == NULL) {
     return 0;
   }
@@ -547,7 +545,7 @@ int EC_KEY_get_ex_new_index(long argl, void *argp, CRYPTO_EX_unused *unused,
                             CRYPTO_EX_dup *dup_unused,
                             CRYPTO_EX_free *free_func) {
   return CRYPTO_get_ex_new_index_ex(g_ec_ex_data_class_bss_get(), argl, argp,
-                                 free_func);
+                                    free_func);
 }
 
 int EC_KEY_set_ex_data(EC_KEY *d, int idx, void *arg) {

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, Google Inc.
+/* Copyright 2018 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

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

@@ -141,8 +141,8 @@ static int ec_GFp_simple_oct2point(const EC_GROUP *group, EC_POINT *point,
     return 0;
   }
 
-  point_conversion_form_t form = buf[0];
-  if (form == POINT_CONVERSION_UNCOMPRESSED) {
+  uint8_t form = buf[0];
+  if (form == static_cast<uint8_t>(POINT_CONVERSION_UNCOMPRESSED)) {
     EC_AFFINE affine;
     if (!ec_point_from_uncompressed(group, &affine, buf, len)) {
       // In the event of an error, defend against the caller not checking the
@@ -157,7 +157,7 @@ static int ec_GFp_simple_oct2point(const EC_GROUP *group, EC_POINT *point,
   const int y_bit = form & 1;
   const size_t field_len = BN_num_bytes(&group->field.N);
   form = form & ~1u;
-  if (form != POINT_CONVERSION_COMPRESSED ||
+  if (form != static_cast<uint8_t>(POINT_CONVERSION_COMPRESSED) ||
       len != 1 /* type byte */ + field_len) {
     OPENSSL_PUT_ERROR(EC, EC_R_INVALID_ENCODING);
     return 0;
@@ -239,7 +239,7 @@ size_t EC_POINT_point2buf(const EC_GROUP *group, const EC_POINT *point,
   if (len == 0) {
     return 0;
   }
-  uint8_t *buf = OPENSSL_malloc(len);
+  uint8_t *buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(len));
   if (buf == NULL) {
     return 0;
   }
@@ -286,8 +286,7 @@ int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group,
   BIGNUM *a = BN_CTX_get(ctx);
   BIGNUM *b = BN_CTX_get(ctx);
   BIGNUM *y = BN_CTX_get(ctx);
-  if (y == NULL ||
-      !EC_GROUP_get_curve_GFp(group, NULL, a, b, ctx)) {
+  if (y == NULL || !EC_GROUP_get_curve_GFp(group, NULL, a, b, ctx)) {
     goto err;
   }
 

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2015, Google Inc.
+/* Copyright 2015 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

data/third_party/boringssl-with-bazel/src/crypto/fipsmodule/ec/p256-nistz-table.h

@@ -22,7 +22,7 @@
 
 // This file is generated by make_tables.go.
 
-static const alignas(4096) PRECOMP256_ROW ecp_nistz256_precomputed[37] = {
+static const PRECOMP256_ROW ecp_nistz256_precomputed alignas(4096)[37] = {
     {{{TOBN(0x79e730d4, 0x18a9143c), TOBN(0x75ba95fc, 0x5fedb601),
        TOBN(0x79fb732b, 0x77622510), TOBN(0x18905f76, 0xa53755c6)},
       {TOBN(0xddf25357, 0xce95560a), TOBN(0x8b4ab8e4, 0xba19e45c),

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

@@ -26,22 +26,24 @@
 #include <openssl/crypto.h>
 #include <openssl/err.h>
 
+#include "../../internal.h"
 #include "../bn/internal.h"
 #include "../delocate.h"
-#include "../../internal.h"
 #include "internal.h"
 #include "p256-nistz.h"
 
-#if !defined(OPENSSL_NO_ASM) &&  \
-    (defined(OPENSSL_X86_64) || defined(OPENSSL_AARCH64)) &&    \
+#if !defined(OPENSSL_NO_ASM) &&                              \
+    (defined(OPENSSL_X86_64) || defined(OPENSSL_AARCH64)) && \
     !defined(OPENSSL_SMALL)
 
 typedef P256_POINT_AFFINE PRECOMP256_ROW[64];
 
 // One converted into the Montgomery domain
 static const BN_ULONG ONE_MONT[P256_LIMBS] = {
-    TOBN(0x00000000, 0x00000001), TOBN(0xffffffff, 0x00000000),
-    TOBN(0xffffffff, 0xffffffff), TOBN(0x00000000, 0xfffffffe),
+    TOBN(0x00000000, 0x00000001),
+    TOBN(0xffffffff, 0x00000000),
+    TOBN(0xffffffff, 0xffffffff),
+    TOBN(0x00000000, 0xfffffffe),
 };
 
 // Precomputed tables for the default generator
@@ -104,11 +106,11 @@ static void copy_conditional(BN_ULONG dst[P256_LIMBS],
 //
 // (declare-fun x () (_ BitVec 64))
 //
-// (assert (and (= x #x0000000000000000) (= (is_not_zero x) #x0000000000000001)))
-// (check-sat)
+// (assert (and (= x #x0000000000000000) (= (is_not_zero x)
+// #x0000000000000001))) (check-sat)
 //
-// (assert (and (not (= x #x0000000000000000)) (= (is_not_zero x) #x0000000000000000)))
-// (check-sat)
+// (assert (and (not (= x #x0000000000000000)) (= (is_not_zero x)
+// #x0000000000000000))) (check-sat)
 //
 static BN_ULONG is_not_zero(BN_ULONG in) {
   in |= (0 - in);
@@ -651,8 +653,8 @@ static void ecp_nistz256_inv0_mod_ord(const EC_GROUP *group, EC_SCALAR *out,
 }
 
 static int ecp_nistz256_scalar_to_montgomery_inv_vartime(const EC_GROUP *group,
-                                                 EC_SCALAR *out,
-                                                 const EC_SCALAR *in) {
+                                                         EC_SCALAR *out,
+                                                         const EC_SCALAR *in) {
 #if defined(OPENSSL_X86_64)
   if (!CRYPTO_is_AVX_capable()) {
     // No AVX support; fallback to generic code.
@@ -729,6 +731,6 @@ DEFINE_METHOD_FUNCTION(EC_METHOD, EC_GFp_nistz256_method) {
   out->cmp_x_coordinate = ecp_nistz256_cmp_x_coordinate;
 }
 
-#endif /* !defined(OPENSSL_NO_ASM) && \
-          (defined(OPENSSL_X86_64) || defined(OPENSSL_AARCH64)) &&  \
+#endif /* !defined(OPENSSL_NO_ASM) &&                              \
+          (defined(OPENSSL_X86_64) || defined(OPENSSL_AARCH64)) && \
           !defined(OPENSSL_SMALL) */

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2020, Google Inc.
+/* Copyright 2020 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

data/third_party/boringssl-with-bazel/src/crypto/fipsmodule/ec/p256_table.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2020, Google Inc.
+/* Copyright 2020 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

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, Google Inc.
+/* Copyright 2018 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

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, Google Inc.
+/* Copyright 2018 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

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2015, Google Inc.
+/* Copyright 2015 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