grpc 1.69.0 → 1.71.0

data/third_party/boringssl-with-bazel/src/crypto/md5/internal.h

@@ -0,0 +1,37 @@
+// Copyright 2018 The BoringSSL Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OPENSSL_HEADER_MD5_INTERNAL_H
+#define OPENSSL_HEADER_MD5_INTERNAL_H
+
+#include <openssl/base.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+#if !defined(OPENSSL_NO_ASM) && \
+    (defined(OPENSSL_X86_64) || defined(OPENSSL_X86))
+#define MD5_ASM
+extern void md5_block_asm_data_order(uint32_t *state, const uint8_t *data,
+                                     size_t num);
+#endif
+
+
+#if defined(__cplusplus)
+}  // extern "C"
+#endif
+
+#endif  // OPENSSL_HEADER_MD5_INTERNAL_H

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

@@ -1,58 +1,16 @@
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- *
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- *
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- *
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.] */
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include <openssl/md5.h>
 
@@ -60,8 +18,8 @@
 
 #include <openssl/mem.h>
 
-#include "../../internal.h"
-#include "../digest/md32_common.h"
+#include "../fipsmodule/digest/md32_common.h"
+#include "../internal.h"
 #include "internal.h"
 
 
@@ -96,7 +54,8 @@ void MD5_Transform(MD5_CTX *c, const uint8_t data[MD5_CBLOCK]) {
 
 int MD5_Update(MD5_CTX *c, const void *data, size_t len) {
   crypto_md32_update(&md5_block_data_order, c->h, c->data, MD5_CBLOCK, &c->num,
-                     &c->Nh, &c->Nl, data, len);
+                     &c->Nh, &c->Nl, reinterpret_cast<const uint8_t *>(data),
+                     len);
   return 1;
 }
 

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

@@ -1,58 +1,16 @@
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- *
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- *
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- *
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.] */
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include <openssl/mem.h>
 
@@ -84,8 +42,10 @@ OPENSSL_MSVC_PRAGMA(warning(pop))
 static_assert(OPENSSL_MALLOC_PREFIX >= sizeof(size_t), "size_t too large");
 
 #if defined(OPENSSL_ASAN)
+extern "C" {
 void __asan_poison_memory_region(const volatile void *addr, size_t size);
 void __asan_unpoison_memory_region(const volatile void *addr, size_t size);
+}
 #else
 static void __asan_poison_memory_region(const void *addr, size_t size) {}
 static void __asan_unpoison_memory_region(const void *addr, size_t size) {}
@@ -100,20 +60,27 @@ static void __asan_unpoison_memory_region(const void *addr, size_t size) {}
 // weak symbols.
 #if !defined(__EDK2_BORINGSSL__) && defined(__ELF__) && defined(__GNUC__)
 #define WEAK_SYMBOL_FUNC(rettype, name, args) \
-  rettype name args __attribute__((weak));
+  extern "C" {                                \
+  rettype name args __attribute__((weak));    \
+  }
 #else
-#define WEAK_SYMBOL_FUNC(rettype, name, args) static rettype(*name) args = NULL;
+#define WEAK_SYMBOL_FUNC(rettype, name, args) \
+  static rettype(*const name) args = NULL;
 #endif
 
+#if defined(BORINGSSL_DETECT_SDALLOCX)
 // sdallocx is a sized |free| function. By passing the size (which we happen to
 // always know in BoringSSL), the malloc implementation can save work. We cannot
 // depend on |sdallocx| being available, however, so it's a weak symbol.
 //
-// This will always be safe, but will only be overridden if the malloc
-// implementation is statically linked with BoringSSL. So, if |sdallocx| is
-// provided in, say, libc.so, we still won't use it because that's dynamically
-// linked. This isn't an ideal result, but its helps in some cases.
-WEAK_SYMBOL_FUNC(void, sdallocx, (void *ptr, size_t size, int flags));
+// This mechanism is kept opt-in because it assumes that, when |sdallocx| is
+// defined, it is part of the same allocator as |malloc|. This is usually true
+// but may break if |malloc| does not implement |sdallocx|, but some other
+// allocator with |sdallocx| is imported which does.
+WEAK_SYMBOL_FUNC(void, sdallocx, (void *ptr, size_t size, int flags))
+#else
+static void (*const sdallocx)(void *ptr, size_t size, int flags) = NULL;
+#endif
 
 // The following three functions can be defined to override default heap
 // allocation and freeing. If defined, it is the responsibility of
@@ -133,9 +100,9 @@ WEAK_SYMBOL_FUNC(void, sdallocx, (void *ptr, size_t size, int flags));
 // primitives used must tolerate every other synchronization primitive linked
 // into the process, including pthreads locks. Failing to meet these constraints
 // may result in deadlocks, crashes, or memory corruption.
-WEAK_SYMBOL_FUNC(void *, OPENSSL_memory_alloc, (size_t size));
-WEAK_SYMBOL_FUNC(void, OPENSSL_memory_free, (void *ptr));
-WEAK_SYMBOL_FUNC(size_t, OPENSSL_memory_get_size, (void *ptr));
+WEAK_SYMBOL_FUNC(void *, OPENSSL_memory_alloc, (size_t size))
+WEAK_SYMBOL_FUNC(void, OPENSSL_memory_free, (void *ptr))
+WEAK_SYMBOL_FUNC(size_t, OPENSSL_memory_get_size, (void *ptr))
 
 #if defined(BORINGSSL_MALLOC_FAILURE_TESTING)
 static CRYPTO_MUTEX malloc_failure_lock = CRYPTO_MUTEX_INIT;
@@ -218,6 +185,7 @@ static int should_fail_allocation(void) { return 0; }
 #endif
 
 void *OPENSSL_malloc(size_t size) {
+  void *ptr = nullptr;
   if (should_fail_allocation()) {
     goto err;
   }
@@ -225,18 +193,18 @@ void *OPENSSL_malloc(size_t size) {
   if (OPENSSL_memory_alloc != NULL) {
     assert(OPENSSL_memory_free != NULL);
     assert(OPENSSL_memory_get_size != NULL);
-    void *ptr = OPENSSL_memory_alloc(size);
-    if (ptr == NULL && size != 0) {
+    void *ptr2 = OPENSSL_memory_alloc(size);
+    if (ptr2 == NULL && size != 0) {
       goto err;
     }
-    return ptr;
+    return ptr2;
   }
 
   if (size + OPENSSL_MALLOC_PREFIX < size) {
     goto err;
   }
 
-  void *ptr = malloc(size + OPENSSL_MALLOC_PREFIX);
+  ptr = malloc(size + OPENSSL_MALLOC_PREFIX);
   if (ptr == NULL) {
     goto err;
   }
@@ -359,8 +327,8 @@ void OPENSSL_secure_clear_free(void *ptr, size_t len) {
 }
 
 int CRYPTO_memcmp(const void *in_a, const void *in_b, size_t len) {
-  const uint8_t *a = in_a;
-  const uint8_t *b = in_b;
+  const uint8_t *a = reinterpret_cast<const uint8_t *>(in_a);
+  const uint8_t *b = reinterpret_cast<const uint8_t *>(in_b);
   uint8_t x = 0;
 
   for (size_t i = 0; i < len; i++) {
@@ -375,7 +343,7 @@ uint32_t OPENSSL_hash32(const void *ptr, size_t len) {
   static const uint32_t kPrime = 16777619u;
   static const uint32_t kOffsetBasis = 2166136261u;
 
-  const uint8_t *in = ptr;
+  const uint8_t *in = reinterpret_cast<const uint8_t *>(ptr);
   uint32_t h = kOffsetBasis;
 
   for (size_t i = 0; i < len; i++) {
@@ -403,7 +371,7 @@ char *OPENSSL_strdup(const char *s) {
     return NULL;
   }
   // Copy the NUL terminator.
-  return OPENSSL_memdup(s, strlen(s) + 1);
+  return reinterpret_cast<char *>(OPENSSL_memdup(s, strlen(s) + 1));
 }
 
 int OPENSSL_isalpha(int c) {
@@ -498,13 +466,14 @@ int OPENSSL_vasprintf_internal(char **str, const char *format, va_list args,
       system_malloc ? realloc : OPENSSL_realloc;
   char *candidate = NULL;
   size_t candidate_len = 64;  // TODO(bbe) what's the best initial size?
+  int ret;
 
-  if ((candidate = allocate(candidate_len)) == NULL) {
+  if ((candidate = reinterpret_cast<char *>(allocate(candidate_len))) == NULL) {
     goto err;
   }
   va_list args_copy;
   va_copy(args_copy, args);
-  int ret = vsnprintf(candidate, candidate_len, format, args_copy);
+  ret = vsnprintf(candidate, candidate_len, format, args_copy);
   va_end(args_copy);
   if (ret < 0) {
     goto err;
@@ -514,7 +483,8 @@ int OPENSSL_vasprintf_internal(char **str, const char *format, va_list args,
     char *tmp;
 
     candidate_len = (size_t)ret + 1;
-    if ((tmp = reallocate(candidate, candidate_len)) == NULL) {
+    if ((tmp = reinterpret_cast<char *>(
+             reallocate(candidate, candidate_len))) == NULL) {
       goto err;
     }
     candidate = tmp;
@@ -555,7 +525,7 @@ char *OPENSSL_strndup(const char *str, size_t size) {
     OPENSSL_PUT_ERROR(CRYPTO, ERR_R_MALLOC_FAILURE);
     return NULL;
   }
-  char *ret = OPENSSL_malloc(alloc_size);
+  char *ret = reinterpret_cast<char *>(OPENSSL_malloc(alloc_size));
   if (ret == NULL) {
     return NULL;
   }

data/third_party/boringssl-with-bazel/src/crypto/mldsa/mldsa.cc

@@ -0,0 +1,90 @@
+// Copyright 2024 The BoringSSL Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <openssl/mldsa.h>
+
+#include "../fipsmodule/bcm_interface.h"
+
+static_assert(sizeof(BCM_mldsa65_private_key) == sizeof(MLDSA65_private_key),
+              "");
+static_assert(alignof(BCM_mldsa65_private_key) == alignof(MLDSA65_private_key),
+              "");
+static_assert(sizeof(BCM_mldsa65_public_key) == sizeof(MLDSA65_public_key), "");
+static_assert(alignof(BCM_mldsa65_public_key) == alignof(MLDSA65_public_key),
+              "");
+static_assert(MLDSA_SEED_BYTES == BCM_MLDSA_SEED_BYTES, "");
+static_assert(MLDSA65_PRIVATE_KEY_BYTES == BCM_MLDSA65_PRIVATE_KEY_BYTES, "");
+static_assert(MLDSA65_PUBLIC_KEY_BYTES == BCM_MLDSA65_PUBLIC_KEY_BYTES, "");
+static_assert(MLDSA65_SIGNATURE_BYTES == BCM_MLDSA65_SIGNATURE_BYTES, "");
+
+int MLDSA65_generate_key(
+    uint8_t out_encoded_public_key[MLDSA65_PUBLIC_KEY_BYTES],
+    uint8_t out_seed[MLDSA_SEED_BYTES],
+    struct MLDSA65_private_key *out_private_key) {
+  return bcm_success(BCM_mldsa65_generate_key(
+      out_encoded_public_key, out_seed,
+      reinterpret_cast<BCM_mldsa65_private_key *>(out_private_key)));
+}
+
+int MLDSA65_private_key_from_seed(struct MLDSA65_private_key *out_private_key,
+                                  const uint8_t *seed, size_t seed_len) {
+  if (seed_len != BCM_MLDSA_SEED_BYTES) {
+    return 0;
+  }
+  return bcm_success(BCM_mldsa65_private_key_from_seed(
+      reinterpret_cast<BCM_mldsa65_private_key *>(out_private_key), seed));
+}
+
+int MLDSA65_public_from_private(struct MLDSA65_public_key *out_public_key,
+                                const struct MLDSA65_private_key *private_key) {
+  return bcm_success(BCM_mldsa65_public_from_private(
+      reinterpret_cast<BCM_mldsa65_public_key *>(out_public_key),
+      reinterpret_cast<const BCM_mldsa65_private_key *>(private_key)));
+}
+
+int MLDSA65_sign(uint8_t out_encoded_signature[MLDSA65_SIGNATURE_BYTES],
+                 const struct MLDSA65_private_key *private_key,
+                 const uint8_t *msg, size_t msg_len, const uint8_t *context,
+                 size_t context_len) {
+  if (context_len > 255) {
+    return 0;
+  }
+  return bcm_success(BCM_mldsa65_sign(
+      out_encoded_signature,
+      reinterpret_cast<const BCM_mldsa65_private_key *>(private_key), msg,
+      msg_len, context, context_len));
+}
+
+int MLDSA65_verify(const struct MLDSA65_public_key *public_key,
+                   const uint8_t *signature, size_t signature_len,
+                   const uint8_t *msg, size_t msg_len, const uint8_t *context,
+                   size_t context_len) {
+  if (context_len > 255 || signature_len != BCM_MLDSA65_SIGNATURE_BYTES) {
+    return 0;
+  }
+  return bcm_success(BCM_mldsa65_verify(
+      reinterpret_cast<const BCM_mldsa65_public_key *>(public_key), signature,
+      msg, msg_len, context, context_len));
+}
+
+int MLDSA65_marshal_public_key(CBB *out,
+                               const struct MLDSA65_public_key *public_key) {
+  return bcm_success(BCM_mldsa65_marshal_public_key(
+      out, reinterpret_cast<const BCM_mldsa65_public_key *>(public_key)));
+}
+
+int MLDSA65_parse_public_key(struct MLDSA65_public_key *public_key, CBS *in) {
+  return bcm_success(BCM_mldsa65_parse_public_key(
+      reinterpret_cast<BCM_mldsa65_public_key *>(public_key), in));
+}