grpc 1.69.0 → 1.70.1

data/third_party/boringssl-with-bazel/src/crypto/curve25519/{spake25519.c → spake25519.cc}

@@ -1,4 +1,4 @@
-/* Copyright (c) 2016, Google Inc.
+/* Copyright 2016 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
@@ -31,13 +31,17 @@
 // points used in the SPAKE2 protocol.
 //
 // N:
-//   x: 49918732221787544735331783592030787422991506689877079631459872391322455579424
-//   y: 54629554431565467720832445949441049581317094546788069926228343916274969994000
+//   x:
+//   49918732221787544735331783592030787422991506689877079631459872391322455579424
+//   y:
+//   54629554431565467720832445949441049581317094546788069926228343916274969994000
 //   encoded: 10e3df0ae37d8e7a99b5fe74b44672103dbddcbd06af680d71329a11693bc778
 //
 // M:
-//   x: 31406539342727633121250288103050113562375374900226415211311216773867585644232
-//   y: 21177308356423958466833845032658859666296341766942662650232962324899758529114
+//   x:
+//   31406539342727633121250288103050113562375374900226415211311216773867585644232
+//   y:
+//   21177308356423958466833845032658859666296341766942662650232962324899758529114
 //   encoded: 5ada7e4bf6ddd9adb6626d32131c6b5c51a1e347a3478f53cfcf441b88eed12e
 //
 // These points and their precomputation tables are generated with the
@@ -269,10 +273,11 @@ static const uint8_t kSpakeMSmallPrecomp[15 * 2 * 32] = {
     0xa6, 0x76, 0x81, 0x28, 0xb2, 0x65, 0xe8, 0x47, 0x14, 0xc6, 0x39, 0x06,
 };
 
-SPAKE2_CTX *SPAKE2_CTX_new(enum spake2_role_t my_role,
-                           const uint8_t *my_name, size_t my_name_len,
-                           const uint8_t *their_name, size_t their_name_len) {
-  SPAKE2_CTX *ctx = OPENSSL_zalloc(sizeof(SPAKE2_CTX));
+SPAKE2_CTX *SPAKE2_CTX_new(enum spake2_role_t my_role, const uint8_t *my_name,
+                           size_t my_name_len, const uint8_t *their_name,
+                           size_t their_name_len) {
+  SPAKE2_CTX *ctx =
+      reinterpret_cast<SPAKE2_CTX *>(OPENSSL_zalloc(sizeof(SPAKE2_CTX)));
   if (ctx == NULL) {
     return NULL;
   }
@@ -341,8 +346,8 @@ static void scalar_add(scalar *dest, const scalar *src) {
 }
 
 int SPAKE2_generate_msg(SPAKE2_CTX *ctx, uint8_t *out, size_t *out_len,
-                         size_t max_out_len, const uint8_t *password,
-                         size_t password_len) {
+                        size_t max_out_len, const uint8_t *password,
+                        size_t password_len) {
   if (ctx->state != spake2_state_init) {
     return 0;
   }
@@ -459,8 +464,7 @@ static void update_with_length_prefix(SHA512_CTX *sha, const uint8_t *data,
 int SPAKE2_process_msg(SPAKE2_CTX *ctx, uint8_t *out_key, size_t *out_key_len,
                        size_t max_out_key_len, const uint8_t *their_msg,
                        size_t their_msg_len) {
-  if (ctx->state != spake2_state_msg_generated ||
-      their_msg_len != 32) {
+  if (ctx->state != spake2_state_msg_generated || their_msg_len != 32) {
     return 0;
   }
 
@@ -473,9 +477,9 @@ int SPAKE2_process_msg(SPAKE2_CTX *ctx, uint8_t *out_key, size_t *out_key_len,
   // Unmask peer's value.
   ge_p3 peers_mask;
   x25519_ge_scalarmult_small_precomp(&peers_mask, ctx->password_scalar,
-                                    ctx->my_role == spake2_role_alice
-                                        ? kSpakeNSmallPrecomp
-                                        : kSpakeMSmallPrecomp);
+                                     ctx->my_role == spake2_role_alice
+                                         ? kSpakeNSmallPrecomp
+                                         : kSpakeMSmallPrecomp);
 
   ge_cached peers_mask_cached;
   x25519_ge_p3_to_cached(&peers_mask_cached, &peers_mask);

data/third_party/boringssl-with-bazel/src/crypto/dh_extra/{dh_asn1.c → dh_asn1.cc}

@@ -1,5 +1,5 @@
-/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
- * project 2000.
+/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
+ * 2000.
  */
 /* ====================================================================
  * Copyright (c) 2000-2005 The OpenSSL Project.  All rights reserved.

data/third_party/boringssl-with-bazel/src/crypto/digest_extra/{digest_extra.c → digest_extra.cc}

@@ -60,17 +60,19 @@
 
 #include <openssl/blake2.h>
 #include <openssl/bytestring.h>
-#include <openssl/obj.h>
+#include <openssl/md4.h>
+#include <openssl/md5.h>
 #include <openssl/nid.h>
+#include <openssl/obj.h>
 
 #include "../asn1/internal.h"
-#include "../internal.h"
 #include "../fipsmodule/digest/internal.h"
+#include "../internal.h"
 
 
 struct nid_to_digest {
   int nid;
-  const EVP_MD* (*md_func)(void);
+  const EVP_MD *(*md_func)(void);
   const char *short_name;
   const char *long_name;
 };
@@ -105,7 +107,7 @@ static const struct nid_to_digest nid_to_digest_mapping[] = {
      LN_sha512WithRSAEncryption},
 };
 
-const EVP_MD* EVP_get_digestbynid(int nid) {
+const EVP_MD *EVP_get_digestbynid(int nid) {
   if (nid == NID_undef) {
     // Skip the |NID_undef| entries in |nid_to_digest_mapping|.
     return NULL;
@@ -125,20 +127,20 @@ static const struct {
   uint8_t oid_len;
   int nid;
 } kMDOIDs[] = {
-  // 1.2.840.113549.2.4
-  { {0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x04}, 8, NID_md4 },
-  // 1.2.840.113549.2.5
-  { {0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x05}, 8, NID_md5 },
-  // 1.3.14.3.2.26
-  { {0x2b, 0x0e, 0x03, 0x02, 0x1a}, 5, NID_sha1 },
-  // 2.16.840.1.101.3.4.2.1
-  { {0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01}, 9, NID_sha256 },
-  // 2.16.840.1.101.3.4.2.2
-  { {0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02}, 9, NID_sha384 },
-  // 2.16.840.1.101.3.4.2.3
-  { {0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03}, 9, NID_sha512 },
-  // 2.16.840.1.101.3.4.2.4
-  { {0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x04}, 9, NID_sha224 },
+    // 1.2.840.113549.2.4
+    {{0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x04}, 8, NID_md4},
+    // 1.2.840.113549.2.5
+    {{0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x05}, 8, NID_md5},
+    // 1.3.14.3.2.26
+    {{0x2b, 0x0e, 0x03, 0x02, 0x1a}, 5, NID_sha1},
+    // 2.16.840.1.101.3.4.2.1
+    {{0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01}, 9, NID_sha256},
+    // 2.16.840.1.101.3.4.2.2
+    {{0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02}, 9, NID_sha384},
+    // 2.16.840.1.101.3.4.2.3
+    {{0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03}, 9, NID_sha512},
+    // 2.16.840.1.101.3.4.2.4
+    {{0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x04}, 9, NID_sha224},
 };
 
 static const EVP_MD *cbs_to_md(const CBS *cbs) {
@@ -186,7 +188,7 @@ const EVP_MD *EVP_parse_digest_algorithm(CBS *cbs) {
   if (CBS_len(&algorithm) > 0) {
     CBS param;
     if (!CBS_get_asn1(&algorithm, &param, CBS_ASN1_NULL) ||
-        CBS_len(&param) != 0 ||
+        CBS_len(&param) != 0 ||  //
         CBS_len(&algorithm) != 0) {
       OPENSSL_PUT_ERROR(DIGEST, DIGEST_R_DECODE_ERROR);
       return NULL;
@@ -221,7 +223,7 @@ int EVP_marshal_digest_algorithm(CBB *cbb, const EVP_MD *md) {
   }
 
   // TODO(crbug.com/boringssl/710): Is this correct? See RFC 4055, section 2.1.
-  if (!CBB_add_asn1(&algorithm, &null, CBS_ASN1_NULL) ||
+  if (!CBB_add_asn1(&algorithm, &null, CBS_ASN1_NULL) ||  //
       !CBB_flush(cbb)) {
     return 0;
   }
@@ -242,25 +244,105 @@ const EVP_MD *EVP_get_digestbyname(const char *name) {
   return NULL;
 }
 
-static void blake2b256_init(EVP_MD_CTX *ctx) { BLAKE2B256_Init(ctx->md_data); }
+static void blake2b256_init(EVP_MD_CTX *ctx) {
+  BLAKE2B256_Init(reinterpret_cast<BLAKE2B_CTX *>(ctx->md_data));
+}
 
 static void blake2b256_update(EVP_MD_CTX *ctx, const void *data, size_t len) {
-  BLAKE2B256_Update(ctx->md_data, data, len);
+  BLAKE2B256_Update(reinterpret_cast<BLAKE2B_CTX *>(ctx->md_data), data, len);
 }
 
 static void blake2b256_final(EVP_MD_CTX *ctx, uint8_t *md) {
-  BLAKE2B256_Final(md, ctx->md_data);
+  BLAKE2B256_Final(md, reinterpret_cast<BLAKE2B_CTX *>(ctx->md_data));
 }
 
 static const EVP_MD evp_md_blake2b256 = {
-  NID_undef,
-  BLAKE2B256_DIGEST_LENGTH,
-  0,
-  blake2b256_init,
-  blake2b256_update,
-  blake2b256_final,
-  BLAKE2B_CBLOCK,
-  sizeof(BLAKE2B_CTX),
+    NID_undef,       BLAKE2B256_DIGEST_LENGTH, 0,
+    blake2b256_init, blake2b256_update,        blake2b256_final,
+    BLAKE2B_CBLOCK,  sizeof(BLAKE2B_CTX),
 };
 
 const EVP_MD *EVP_blake2b256(void) { return &evp_md_blake2b256; }
+
+
+static void md4_init(EVP_MD_CTX *ctx) {
+  BSSL_CHECK(MD4_Init(reinterpret_cast<MD4_CTX *>(ctx->md_data)));
+}
+
+static void md4_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
+  BSSL_CHECK(
+      MD4_Update(reinterpret_cast<MD4_CTX *>(ctx->md_data), data, count));
+}
+
+static void md4_final(EVP_MD_CTX *ctx, uint8_t *out) {
+  BSSL_CHECK(MD4_Final(out, reinterpret_cast<MD4_CTX *>(ctx->md_data)));
+}
+
+static const EVP_MD evp_md_md4 = {
+    NID_md4,            //
+    MD4_DIGEST_LENGTH,  //
+    0,
+    md4_init,
+    md4_update,
+    md4_final,
+    64,
+    sizeof(MD4_CTX),
+};
+
+const EVP_MD *EVP_md4(void) { return &evp_md_md4; }
+
+static void md5_init(EVP_MD_CTX *ctx) {
+  BSSL_CHECK(MD5_Init(reinterpret_cast<MD5_CTX *>(ctx->md_data)));
+}
+
+static void md5_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
+  BSSL_CHECK(
+      MD5_Update(reinterpret_cast<MD5_CTX *>(ctx->md_data), data, count));
+}
+
+static void md5_final(EVP_MD_CTX *ctx, uint8_t *out) {
+  BSSL_CHECK(MD5_Final(out, reinterpret_cast<MD5_CTX *>(ctx->md_data)));
+}
+
+static const EVP_MD evp_md_md5 = {
+    NID_md5,    MD5_DIGEST_LENGTH, 0,  md5_init,
+    md5_update, md5_final,         64, sizeof(MD5_CTX),
+};
+
+const EVP_MD *EVP_md5(void) { return &evp_md_md5; }
+
+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 = reinterpret_cast<MD5_SHA1_CTX *>(md_ctx->md_data);
+  BSSL_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 = reinterpret_cast<MD5_SHA1_CTX *>(md_ctx->md_data);
+  BSSL_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 = reinterpret_cast<MD5_SHA1_CTX *>(md_ctx->md_data);
+  BSSL_CHECK(MD5_Final(out, &ctx->md5) &&
+             SHA1_Final(out + MD5_DIGEST_LENGTH, &ctx->sha1));
+}
+
+const EVP_MD evp_md_md5_sha1 = {
+    NID_md5_sha1,
+    MD5_DIGEST_LENGTH + SHA_DIGEST_LENGTH,
+    0,
+    md5_sha1_init,
+    md5_sha1_update,
+    md5_sha1_final,
+    64,
+    sizeof(MD5_SHA1_CTX),
+};
+
+const EVP_MD *EVP_md5_sha1(void) { return &evp_md_md5_sha1; }