grpc 1.70.1 → 1.72.0

data/third_party/boringssl-with-bazel/src/crypto/slhdsa/thash.cc

@@ -1,173 +0,0 @@
-/* Copyright 2024 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
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
-
-#include <openssl/base.h>
-
-#include <assert.h>
-#include <string.h>
-
-#include <openssl/sha.h>
-
-#include "../internal.h"
-#include "./params.h"
-#include "./thash.h"
-
-
-// Internal thash function used by F, H, and T_l (Section 11.2, pages 44-46)
-static void slhdsa_thash(uint8_t output[SLHDSA_SHA2_128S_N],
-                         const uint8_t *input, size_t input_blocks,
-                         const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
-                         uint8_t addr[32]) {
-  SHA256_CTX sha256;
-  SHA256_Init(&sha256);
-
-  // Process pubseed with padding to full block.
-  static const uint8_t kZeros[64 - SLHDSA_SHA2_128S_N] = {0};
-  SHA256_Update(&sha256, pk_seed, SLHDSA_SHA2_128S_N);
-  SHA256_Update(&sha256, kZeros, sizeof(kZeros));
-  SHA256_Update(&sha256, addr, SLHDSA_SHA2_128S_SHA256_ADDR_BYTES);
-  SHA256_Update(&sha256, input, input_blocks * SLHDSA_SHA2_128S_N);
-
-  uint8_t hash[32];
-  SHA256_Final(hash, &sha256);
-  OPENSSL_memcpy(output, hash, SLHDSA_SHA2_128S_N);
-}
-
-// Implements PRF_msg function (Section 4.1, page 11 and Section 11.2, pages
-// 44-46)
-void slhdsa_thash_prfmsg(uint8_t output[SLHDSA_SHA2_128S_N],
-                         const uint8_t sk_prf[SLHDSA_SHA2_128S_N],
-                         const uint8_t entropy[SLHDSA_SHA2_128S_N],
-                         const uint8_t header[SLHDSA_M_PRIME_HEADER_LEN],
-                         const uint8_t *ctx, size_t ctx_len, const uint8_t *msg,
-                         size_t msg_len) {
-  // Compute HMAC-SHA256(sk_prf, entropy || header || ctx || msg). We inline
-  // HMAC to avoid an allocation.
-  uint8_t hmac_key[SHA256_CBLOCK];
-  static_assert(SLHDSA_SHA2_128S_N <= SHA256_CBLOCK,
-                "HMAC key is larger than block size");
-  OPENSSL_memcpy(hmac_key, sk_prf, SLHDSA_SHA2_128S_N);
-  for (size_t i = 0; i < SLHDSA_SHA2_128S_N; i++) {
-    hmac_key[i] ^= 0x36;
-  }
-  OPENSSL_memset(hmac_key + SLHDSA_SHA2_128S_N, 0x36,
-                 sizeof(hmac_key) - SLHDSA_SHA2_128S_N);
-
-  SHA256_CTX sha_ctx;
-  SHA256_Init(&sha_ctx);
-  SHA256_Update(&sha_ctx, hmac_key, sizeof(hmac_key));
-  SHA256_Update(&sha_ctx, entropy, SLHDSA_SHA2_128S_N);
-  if (header) {
-    SHA256_Update(&sha_ctx, header, SLHDSA_M_PRIME_HEADER_LEN);
-  }
-  SHA256_Update(&sha_ctx, ctx, ctx_len);
-  SHA256_Update(&sha_ctx, msg, msg_len);
-  uint8_t hash[SHA256_DIGEST_LENGTH];
-  SHA256_Final(hash, &sha_ctx);
-
-  for (size_t i = 0; i < SLHDSA_SHA2_128S_N; i++) {
-    hmac_key[i] ^= 0x36 ^ 0x5c;
-  }
-  OPENSSL_memset(hmac_key + SLHDSA_SHA2_128S_N, 0x5c,
-                 sizeof(hmac_key) - SLHDSA_SHA2_128S_N);
-
-  SHA256_Init(&sha_ctx);
-  SHA256_Update(&sha_ctx, hmac_key, sizeof(hmac_key));
-  SHA256_Update(&sha_ctx, hash, sizeof(hash));
-  SHA256_Final(hash, &sha_ctx);
-
-  // Truncate to SLHDSA_SHA2_128S_N bytes
-  OPENSSL_memcpy(output, hash, SLHDSA_SHA2_128S_N);
-}
-
-// Implements H_msg function (Section 4.1, page 11 and Section 11.2, pages
-// 44-46)
-void slhdsa_thash_hmsg(uint8_t output[SLHDSA_SHA2_128S_DIGEST_SIZE],
-                       const uint8_t r[SLHDSA_SHA2_128S_N],
-                       const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
-                       const uint8_t pk_root[SLHDSA_SHA2_128S_N],
-                       const uint8_t header[SLHDSA_M_PRIME_HEADER_LEN],
-                       const uint8_t *ctx, size_t ctx_len, const uint8_t *msg,
-                       size_t msg_len) {
-  // MGF1-SHA-256(R || PK.seed || SHA-256(R || PK.seed || PK.root || header ||
-  // ctx || M), m) input_buffer stores R || PK_SEED || SHA256(..) || 4-byte
-  // index
-  uint8_t input_buffer[2 * SLHDSA_SHA2_128S_N + 32 + 4] = {0};
-  OPENSSL_memcpy(input_buffer, r, SLHDSA_SHA2_128S_N);
-  OPENSSL_memcpy(input_buffer + SLHDSA_SHA2_128S_N, pk_seed,
-                 SLHDSA_SHA2_128S_N);
-
-  // Inner hash
-  SHA256_CTX sha_ctx;
-  SHA256_Init(&sha_ctx);
-  SHA256_Update(&sha_ctx, r, SLHDSA_SHA2_128S_N);
-  SHA256_Update(&sha_ctx, pk_seed, SLHDSA_SHA2_128S_N);
-  SHA256_Update(&sha_ctx, pk_root, SLHDSA_SHA2_128S_N);
-  if (header) {
-    SHA256_Update(&sha_ctx, header, SLHDSA_M_PRIME_HEADER_LEN);
-  }
-  SHA256_Update(&sha_ctx, ctx, ctx_len);
-  SHA256_Update(&sha_ctx, msg, msg_len);
-  // Write directly into the input buffer
-  SHA256_Final(input_buffer + 2 * SLHDSA_SHA2_128S_N, &sha_ctx);
-
-  // MGF1-SHA-256
-  uint8_t hash[32];
-  static_assert(SLHDSA_SHA2_128S_DIGEST_SIZE < sizeof(hash),
-                "More MGF1 iterations required");
-  SHA256(input_buffer, sizeof(input_buffer), hash);
-  OPENSSL_memcpy(output, hash, SLHDSA_SHA2_128S_DIGEST_SIZE);
-}
-
-// Implements PRF function (Section 4.1, page 11 and Section 11.2, pages 44-46)
-void slhdsa_thash_prf(uint8_t output[SLHDSA_SHA2_128S_N],
-                      const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
-                      const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
-                      uint8_t addr[32]) {
-  slhdsa_thash(output, sk_seed, 1, pk_seed, addr);
-}
-
-// Implements T_l function for WOTS+ public key compression (Section 4.1, page
-// 11 and Section 11.2, pages 44-46)
-void slhdsa_thash_tl(uint8_t output[SLHDSA_SHA2_128S_N],
-                     const uint8_t input[SLHDSA_SHA2_128S_WOTS_BYTES],
-                     const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
-                     uint8_t addr[32]) {
-  slhdsa_thash(output, input, SLHDSA_SHA2_128S_WOTS_LEN, pk_seed, addr);
-}
-
-// Implements H function (Section 4.1, page 11 and Section 11.2, pages 44-46)
-void slhdsa_thash_h(uint8_t output[SLHDSA_SHA2_128S_N],
-                    const uint8_t input[2 * SLHDSA_SHA2_128S_N],
-                    const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
-                    uint8_t addr[32]) {
-  slhdsa_thash(output, input, 2, pk_seed, addr);
-}
-
-// Implements F function (Section 4.1, page 11 and Section 11.2, pages 44-46)
-void slhdsa_thash_f(uint8_t output[SLHDSA_SHA2_128S_N],
-                    const uint8_t input[SLHDSA_SHA2_128S_N],
-                    const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
-                    uint8_t addr[32]) {
-  slhdsa_thash(output, input, 1, pk_seed, addr);
-}
-
-// Implements T_k function for FORS public key compression (Section 4.1, page 11
-// and Section 11.2, pages 44-46)
-void slhdsa_thash_tk(
-    uint8_t output[SLHDSA_SHA2_128S_N],
-    const uint8_t input[SLHDSA_SHA2_128S_FORS_TREES * SLHDSA_SHA2_128S_N],
-    const uint8_t pk_seed[SLHDSA_SHA2_128S_N], uint8_t addr[32]) {
-  slhdsa_thash(output, input, SLHDSA_SHA2_128S_FORS_TREES, pk_seed, addr);
-}

data/third_party/boringssl-with-bazel/src/crypto/slhdsa/thash.h

@@ -1,85 +0,0 @@
-/* Copyright 2024 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
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
-
-#ifndef OPENSSL_HEADER_CRYPTO_SLHDSA_THASH_H
-#define OPENSSL_HEADER_CRYPTO_SLHDSA_THASH_H
-
-#include "./params.h"
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-
-// Implements PRF_msg: a pseudo-random function that is used to generate the
-// randomizer r for the randomized hashing of the message to be signed.
-// (Section 4.1, page 11)
-void slhdsa_thash_prfmsg(uint8_t output[SLHDSA_SHA2_128S_N],
-                         const uint8_t sk_prf[SLHDSA_SHA2_128S_N],
-                         const uint8_t opt_rand[SLHDSA_SHA2_128S_N],
-                         const uint8_t header[SLHDSA_M_PRIME_HEADER_LEN],
-                         const uint8_t *ctx, size_t ctx_len, const uint8_t *msg,
-                         size_t msg_len);
-
-// Implements H_msg: a hash function used to generate the digest of the message
-// to be signed. (Section 4.1, page 11)
-void slhdsa_thash_hmsg(uint8_t output[SLHDSA_SHA2_128S_DIGEST_SIZE],
-                       const uint8_t r[SLHDSA_SHA2_128S_N],
-                       const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
-                       const uint8_t pk_root[SLHDSA_SHA2_128S_N],
-                       const uint8_t header[SLHDSA_M_PRIME_HEADER_LEN],
-                       const uint8_t *ctx, size_t ctx_len, const uint8_t *msg,
-                       size_t msg_len);
-
-// Implements PRF: a pseudo-random function that is used to generate the secret
-// values in WOTS+ and FORS private keys. (Section 4.1, page 11)
-void slhdsa_thash_prf(uint8_t output[SLHDSA_SHA2_128S_N],
-                      const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
-                      const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
-                      uint8_t addr[32]);
-
-// Implements T_l: a hash function that maps an l*n-byte message to an n-byte
-// message. Used for WOTS+ public key compression. (Section 4.1, page 11)
-void slhdsa_thash_tl(uint8_t output[SLHDSA_SHA2_128S_N],
-                     const uint8_t input[SLHDSA_SHA2_128S_WOTS_BYTES],
-                     const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
-                     uint8_t addr[32]);
-
-// Implements H: a hash function that takes a 2*n-byte message as input and
-// produces an n-byte output. (Section 4.1, page 11)
-void slhdsa_thash_h(uint8_t output[SLHDSA_SHA2_128S_N],
-                    const uint8_t input[2 * SLHDSA_SHA2_128S_N],
-                    const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
-                    uint8_t addr[32]);
-
-// Implements F: a hash function that takes an n-byte message as input and
-// produces an n-byte output. (Section 4.1, page 11)
-void slhdsa_thash_f(uint8_t output[SLHDSA_SHA2_128S_N],
-                    const uint8_t input[SLHDSA_SHA2_128S_N],
-                    const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
-                    uint8_t addr[32]);
-
-// Implements T_k: a hash function that maps a k*n-byte message to an n-byte
-// message. Used for FORS public key compression. (Section 4.1, page 11)
-void slhdsa_thash_tk(
-    uint8_t output[SLHDSA_SHA2_128S_N],
-    const uint8_t input[SLHDSA_SHA2_128S_FORS_TREES * SLHDSA_SHA2_128S_N],
-    const uint8_t pk_seed[SLHDSA_SHA2_128S_N], uint8_t addr[32]);
-
-
-#if defined(__cplusplus)
-}  // extern C
-#endif
-
-#endif  // OPENSSL_HEADER_CRYPTO_SLHDSA_THASH_H

data/third_party/boringssl-with-bazel/src/crypto/slhdsa/wots.h

@@ -1,50 +0,0 @@
-/* Copyright 2024 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
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
-
-#ifndef OPENSSL_HEADER_CRYPTO_SLHDSA_WOTS_H
-#define OPENSSL_HEADER_CRYPTO_SLHDSA_WOTS_H
-
-#include "./params.h"
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-
-// Implements Algorithm 6: wots_pkGen function, page 18
-void slhdsa_wots_pk_gen(uint8_t pk[SLHDSA_SHA2_128S_N],
-                        const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
-                        const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
-                        uint8_t addr[32]);
-
-// Implements Algorithm 7: wots_sign function, page 20
-void slhdsa_wots_sign(uint8_t sig[SLHDSA_SHA2_128S_WOTS_BYTES],
-                      const uint8_t msg[SLHDSA_SHA2_128S_N],
-                      const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
-                      const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
-                      uint8_t addr[32]);
-
-// Implements Algorithm 8: wots_pkFromSig function, page 21
-void slhdsa_wots_pk_from_sig(uint8_t pk[SLHDSA_SHA2_128S_N],
-                             const uint8_t sig[SLHDSA_SHA2_128S_WOTS_BYTES],
-                             const uint8_t msg[SLHDSA_SHA2_128S_N],
-                             const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
-                             uint8_t addr[32]);
-
-
-#if defined(__cplusplus)
-}  // extern C
-#endif
-
-#endif  // OPENSSL_HEADER_CRYPTO_SLHDSA_WOTS_H

data/third_party/upb/upb/message/internal/compare_unknown.c

@@ -1,289 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2023 Google LLC.  All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file or at
-// https://developers.google.com/open-source/licenses/bsd
-
-#include "upb/message/internal/compare_unknown.h"
-
-#include <stdlib.h>
-
-#include "upb/base/string_view.h"
-#include "upb/mem/alloc.h"
-#include "upb/wire/eps_copy_input_stream.h"
-#include "upb/wire/reader.h"
-#include "upb/wire/types.h"
-
-// Must be last.
-#include "upb/port/def.inc"
-
-typedef struct upb_UnknownFields upb_UnknownFields;
-
-typedef struct {
-  uint32_t tag;
-  union {
-    uint64_t varint;
-    uint64_t uint64;
-    uint32_t uint32;
-    upb_StringView delimited;
-    upb_UnknownFields* group;
-  } data;
-} upb_UnknownField;
-
-struct upb_UnknownFields {
-  size_t size;
-  size_t capacity;
-  upb_UnknownField* fields;
-};
-
-typedef struct {
-  upb_EpsCopyInputStream stream;
-  upb_Arena* arena;
-  upb_UnknownField* tmp;
-  size_t tmp_size;
-  int depth;
-  upb_UnknownCompareResult status;
-  jmp_buf err;
-} upb_UnknownField_Context;
-
-UPB_NORETURN static void upb_UnknownFields_OutOfMemory(
-    upb_UnknownField_Context* ctx) {
-  ctx->status = kUpb_UnknownCompareResult_OutOfMemory;
-  UPB_LONGJMP(ctx->err, 1);
-}
-
-static void upb_UnknownFields_Grow(upb_UnknownField_Context* ctx,
-                                   upb_UnknownField** base,
-                                   upb_UnknownField** ptr,
-                                   upb_UnknownField** end) {
-  size_t old = (*ptr - *base);
-  size_t new = UPB_MAX(4, old * 2);
-
-  *base = upb_Arena_Realloc(ctx->arena, *base, old * sizeof(**base),
-                            new * sizeof(**base));
-  if (!*base) upb_UnknownFields_OutOfMemory(ctx);
-
-  *ptr = *base + old;
-  *end = *base + new;
-}
-
-// We have to implement our own sort here, since qsort() is not an in-order
-// sort. Here we use merge sort, the simplest in-order sort.
-static void upb_UnknownFields_Merge(upb_UnknownField* arr, size_t start,
-                                    size_t mid, size_t end,
-                                    upb_UnknownField* tmp) {
-  memcpy(tmp, &arr[start], (end - start) * sizeof(*tmp));
-
-  upb_UnknownField* ptr1 = tmp;
-  upb_UnknownField* end1 = &tmp[mid - start];
-  upb_UnknownField* ptr2 = &tmp[mid - start];
-  upb_UnknownField* end2 = &tmp[end - start];
-  upb_UnknownField* out = &arr[start];
-
-  while (ptr1 < end1 && ptr2 < end2) {
-    if (ptr1->tag <= ptr2->tag) {
-      *out++ = *ptr1++;
-    } else {
-      *out++ = *ptr2++;
-    }
-  }
-
-  if (ptr1 < end1) {
-    memcpy(out, ptr1, (end1 - ptr1) * sizeof(*out));
-  } else if (ptr2 < end2) {
-    memcpy(out, ptr1, (end2 - ptr2) * sizeof(*out));
-  }
-}
-
-static void upb_UnknownFields_SortRecursive(upb_UnknownField* arr, size_t start,
-                                            size_t end, upb_UnknownField* tmp) {
-  if (end - start > 1) {
-    size_t mid = start + ((end - start) / 2);
-    upb_UnknownFields_SortRecursive(arr, start, mid, tmp);
-    upb_UnknownFields_SortRecursive(arr, mid, end, tmp);
-    upb_UnknownFields_Merge(arr, start, mid, end, tmp);
-  }
-}
-
-static void upb_UnknownFields_Sort(upb_UnknownField_Context* ctx,
-                                   upb_UnknownFields* fields) {
-  if (ctx->tmp_size < fields->size) {
-    const int oldsize = ctx->tmp_size * sizeof(*ctx->tmp);
-    ctx->tmp_size = UPB_MAX(8, ctx->tmp_size);
-    while (ctx->tmp_size < fields->size) ctx->tmp_size *= 2;
-    const int newsize = ctx->tmp_size * sizeof(*ctx->tmp);
-    ctx->tmp = upb_grealloc(ctx->tmp, oldsize, newsize);
-  }
-  upb_UnknownFields_SortRecursive(fields->fields, 0, fields->size, ctx->tmp);
-}
-
-static upb_UnknownFields* upb_UnknownFields_DoBuild(
-    upb_UnknownField_Context* ctx, const char** buf) {
-  upb_UnknownField* arr_base = NULL;
-  upb_UnknownField* arr_ptr = NULL;
-  upb_UnknownField* arr_end = NULL;
-  const char* ptr = *buf;
-  uint32_t last_tag = 0;
-  bool sorted = true;
-  while (!upb_EpsCopyInputStream_IsDone(&ctx->stream, &ptr)) {
-    uint32_t tag;
-    ptr = upb_WireReader_ReadTag(ptr, &tag);
-    UPB_ASSERT(tag <= UINT32_MAX);
-    int wire_type = upb_WireReader_GetWireType(tag);
-    if (wire_type == kUpb_WireType_EndGroup) break;
-    if (tag < last_tag) sorted = false;
-    last_tag = tag;
-
-    if (arr_ptr == arr_end) {
-      upb_UnknownFields_Grow(ctx, &arr_base, &arr_ptr, &arr_end);
-    }
-    upb_UnknownField* field = arr_ptr;
-    field->tag = tag;
-    arr_ptr++;
-
-    switch (wire_type) {
-      case kUpb_WireType_Varint:
-        ptr = upb_WireReader_ReadVarint(ptr, &field->data.varint);
-        break;
-      case kUpb_WireType_64Bit:
-        ptr = upb_WireReader_ReadFixed64(ptr, &field->data.uint64);
-        break;
-      case kUpb_WireType_32Bit:
-        ptr = upb_WireReader_ReadFixed32(ptr, &field->data.uint32);
-        break;
-      case kUpb_WireType_Delimited: {
-        int size;
-        ptr = upb_WireReader_ReadSize(ptr, &size);
-        const char* s_ptr = ptr;
-        ptr = upb_EpsCopyInputStream_ReadStringAliased(&ctx->stream, &s_ptr,
-                                                       size);
-        field->data.delimited.data = s_ptr;
-        field->data.delimited.size = size;
-        break;
-      }
-      case kUpb_WireType_StartGroup:
-        if (--ctx->depth == 0) {
-          ctx->status = kUpb_UnknownCompareResult_MaxDepthExceeded;
-          UPB_LONGJMP(ctx->err, 1);
-        }
-        field->data.group = upb_UnknownFields_DoBuild(ctx, &ptr);
-        ctx->depth++;
-        break;
-      default:
-        UPB_UNREACHABLE();
-    }
-  }
-
-  *buf = ptr;
-  upb_UnknownFields* ret = upb_Arena_Malloc(ctx->arena, sizeof(*ret));
-  if (!ret) upb_UnknownFields_OutOfMemory(ctx);
-  ret->fields = arr_base;
-  ret->size = arr_ptr - arr_base;
-  ret->capacity = arr_end - arr_base;
-  if (!sorted) {
-    upb_UnknownFields_Sort(ctx, ret);
-  }
-  return ret;
-}
-
-// Builds a upb_UnknownFields data structure from the binary data in buf.
-static upb_UnknownFields* upb_UnknownFields_Build(upb_UnknownField_Context* ctx,
-                                                  const char* ptr,
-                                                  size_t size) {
-  upb_EpsCopyInputStream_Init(&ctx->stream, &ptr, size, true);
-  upb_UnknownFields* fields = upb_UnknownFields_DoBuild(ctx, &ptr);
-  UPB_ASSERT(upb_EpsCopyInputStream_IsDone(&ctx->stream, &ptr) &&
-             !upb_EpsCopyInputStream_IsError(&ctx->stream));
-  return fields;
-}
-
-// Compares two sorted upb_UnknownFields structures for equality.
-static bool upb_UnknownFields_IsEqual(const upb_UnknownFields* uf1,
-                                      const upb_UnknownFields* uf2) {
-  if (uf1->size != uf2->size) return false;
-  for (size_t i = 0, n = uf1->size; i < n; i++) {
-    upb_UnknownField* f1 = &uf1->fields[i];
-    upb_UnknownField* f2 = &uf2->fields[i];
-    if (f1->tag != f2->tag) return false;
-    int wire_type = f1->tag & 7;
-    switch (wire_type) {
-      case kUpb_WireType_Varint:
-        if (f1->data.varint != f2->data.varint) return false;
-        break;
-      case kUpb_WireType_64Bit:
-        if (f1->data.uint64 != f2->data.uint64) return false;
-        break;
-      case kUpb_WireType_32Bit:
-        if (f1->data.uint32 != f2->data.uint32) return false;
-        break;
-      case kUpb_WireType_Delimited:
-        if (!upb_StringView_IsEqual(f1->data.delimited, f2->data.delimited)) {
-          return false;
-        }
-        break;
-      case kUpb_WireType_StartGroup:
-        if (!upb_UnknownFields_IsEqual(f1->data.group, f2->data.group)) {
-          return false;
-        }
-        break;
-      default:
-        UPB_UNREACHABLE();
-    }
-  }
-  return true;
-}
-
-static upb_UnknownCompareResult upb_UnknownField_DoCompare(
-    upb_UnknownField_Context* ctx, const char* buf1, size_t size1,
-    const char* buf2, size_t size2) {
-  upb_UnknownCompareResult ret;
-  // First build both unknown fields into a sorted data structure (similar
-  // to the UnknownFieldSet in C++).
-  upb_UnknownFields* uf1 = upb_UnknownFields_Build(ctx, buf1, size1);
-  upb_UnknownFields* uf2 = upb_UnknownFields_Build(ctx, buf2, size2);
-
-  // Now perform the equality check on the sorted structures.
-  if (upb_UnknownFields_IsEqual(uf1, uf2)) {
-    ret = kUpb_UnknownCompareResult_Equal;
-  } else {
-    ret = kUpb_UnknownCompareResult_NotEqual;
-  }
-  return ret;
-}
-
-static upb_UnknownCompareResult upb_UnknownField_Compare(
-    upb_UnknownField_Context* const ctx, const char* const buf1,
-    const size_t size1, const char* const buf2, const size_t size2) {
-  upb_UnknownCompareResult ret;
-  if (UPB_SETJMP(ctx->err) == 0) {
-    ret = upb_UnknownField_DoCompare(ctx, buf1, size1, buf2, size2);
-  } else {
-    ret = ctx->status;
-    UPB_ASSERT(ret != kUpb_UnknownCompareResult_Equal);
-  }
-
-  upb_Arena_Free(ctx->arena);
-  upb_gfree(ctx->tmp);
-  return ret;
-}
-
-upb_UnknownCompareResult UPB_PRIVATE(_upb_Message_UnknownFieldsAreEqual)(
-    const char* buf1, size_t size1, const char* buf2, size_t size2,
-    int max_depth) {
-  if (size1 == 0 && size2 == 0) return kUpb_UnknownCompareResult_Equal;
-  if (size1 == 0 || size2 == 0) return kUpb_UnknownCompareResult_NotEqual;
-  if (memcmp(buf1, buf2, size1) == 0) return kUpb_UnknownCompareResult_Equal;
-
-  upb_UnknownField_Context ctx = {
-      .arena = upb_Arena_New(),
-      .depth = max_depth,
-      .tmp = NULL,
-      .tmp_size = 0,
-      .status = kUpb_UnknownCompareResult_Equal,
-  };
-
-  if (!ctx.arena) return kUpb_UnknownCompareResult_OutOfMemory;
-
-  return upb_UnknownField_Compare(&ctx, buf1, size1, buf2, size2);
-}

data/third_party/upb/upb/message/internal/compare_unknown.h

@@ -1,49 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2023 Google LLC.  All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file or at
-// https://developers.google.com/open-source/licenses/bsd
-
-#ifndef UPB_MESSAGE_INTERNAL_COMPARE_UNKNOWN_H_
-#define UPB_MESSAGE_INTERNAL_COMPARE_UNKNOWN_H_
-
-#include <stddef.h>
-
-// Must be last.
-#include "upb/port/def.inc"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Returns true if unknown fields from the two messages are equal when sorted
-// and varints are made canonical.
-//
-// This function is discouraged, as the comparison is inherently lossy without
-// schema data:
-//
-//  1. We don't know whether delimited fields are sub-messages. Unknown
-//     sub-messages will therefore not have their fields sorted and varints
-//     canonicalized.
-//  2. We don't know about oneof/non-repeated fields, which should semantically
-//     discard every value except the last.
-
-typedef enum {
-  kUpb_UnknownCompareResult_Equal = 0,
-  kUpb_UnknownCompareResult_NotEqual = 1,
-  kUpb_UnknownCompareResult_OutOfMemory = 2,
-  kUpb_UnknownCompareResult_MaxDepthExceeded = 3,
-} upb_UnknownCompareResult;
-
-upb_UnknownCompareResult UPB_PRIVATE(_upb_Message_UnknownFieldsAreEqual)(
-    const char* buf1, size_t size1, const char* buf2, size_t size2,
-    int max_depth);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#include "upb/port/undef.inc"
-
-#endif /* UPB_MESSAGE_INTERNAL_COMPARE_UNKNOWN_H_ */