grpc 1.66.0 → 1.67.0.pre1

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

@@ -18,92 +18,13 @@
 #include <openssl/aes.h>
 #include <openssl/ctrdrbg.h>
 
-#include "../../internal.h"
+#include "../../bcm_support.h"
 #include "../modes/internal.h"
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
-
-#if defined(BORINGSSL_UNSAFE_DETERMINISTIC_MODE)
-#define OPENSSL_RAND_DETERMINISTIC
-#elif defined(OPENSSL_TRUSTY)
-#define OPENSSL_RAND_TRUSTY
-#elif defined(OPENSSL_WINDOWS)
-#define OPENSSL_RAND_WINDOWS
-#elif defined(OPENSSL_LINUX)
-#define OPENSSL_RAND_URANDOM
-#elif defined(OPENSSL_APPLE) && !defined(OPENSSL_MACOS)
-// Unlike macOS, iOS and similar hide away getentropy().
-#define OPENSSL_RAND_IOS
-#else
-// By default if you are integrating BoringSSL we expect you to
-// provide getentropy from the <unistd.h> header file.
-#define OPENSSL_RAND_GETENTROPY
-#endif
-
-// RAND_bytes_with_additional_data samples from the RNG after mixing 32 bytes
-// from |user_additional_data| in.
-void RAND_bytes_with_additional_data(uint8_t *out, size_t out_len,
-                                     const uint8_t user_additional_data[32]);
-
-#if defined(BORINGSSL_FIPS)
-
-// We overread from /dev/urandom or RDRAND by a factor of 10 and XOR to whiten.
-#define BORINGSSL_FIPS_OVERREAD 10
-
-// CRYPTO_get_seed_entropy writes |out_entropy_len| bytes of entropy, suitable
-// for seeding a DRBG, to |out_entropy|. It sets |*out_used_cpu| to one if the
-// entropy came directly from the CPU and zero if it came from the OS. It
-// actively obtains entropy from the CPU/OS and so should not be called from
-// within the FIPS module.
-void CRYPTO_get_seed_entropy(uint8_t *out_entropy, size_t out_entropy_len,
-                             int *out_used_cpu);
-
-// RAND_load_entropy supplies |entropy_len| bytes of entropy to the module. The
-// |want_additional_input| parameter is true iff the entropy was obtained from
-// a source other than the system, e.g. directly from the CPU.
-void RAND_load_entropy(const uint8_t *entropy, size_t entropy_len,
-                       int want_additional_input);
-
-// RAND_need_entropy is implemented outside of the FIPS module and is called
-// when the module has stopped because it has run out of entropy.
-void RAND_need_entropy(size_t bytes_needed);
-
-#endif  // BORINGSSL_FIPS
-
-// CRYPTO_sysrand fills |len| bytes at |buf| with entropy from the operating
-// system.
-void CRYPTO_sysrand(uint8_t *buf, size_t len);
-
-// CRYPTO_sysrand_for_seed fills |len| bytes at |buf| with entropy from the
-// operating system. It may draw from the |GRND_RANDOM| pool on Android,
-// depending on the vendor's configuration.
-void CRYPTO_sysrand_for_seed(uint8_t *buf, size_t len);
-
-#if defined(OPENSSL_RAND_URANDOM) || defined(OPENSSL_RAND_WINDOWS)
-// CRYPTO_init_sysrand initializes long-lived resources needed to draw entropy
-// from the operating system.
-void CRYPTO_init_sysrand(void);
-#else
-OPENSSL_INLINE void CRYPTO_init_sysrand(void) {}
-#endif  // defined(OPENSSL_RAND_URANDOM) || defined(OPENSSL_RAND_WINDOWS)
-
-#if defined(OPENSSL_RAND_URANDOM)
-// CRYPTO_sysrand_if_available fills |len| bytes at |buf| with entropy from the
-// operating system, or early /dev/urandom data, and returns 1, _if_ the entropy
-// pool is initialized or if getrandom() is not available and not in FIPS mode.
-// Otherwise it will not block and will instead fill |buf| with all zeros and
-// return 0.
-int CRYPTO_sysrand_if_available(uint8_t *buf, size_t len);
-#else
-OPENSSL_INLINE int CRYPTO_sysrand_if_available(uint8_t *buf, size_t len) {
-  CRYPTO_sysrand(buf, len);
-  return 1;
-}
-#endif  // defined(OPENSSL_RAND_URANDOM)
-
 // rand_fork_unsafe_buffering_enabled returns whether fork-unsafe buffering has
 // been enabled via |RAND_enable_fork_unsafe_buffering|.
 int rand_fork_unsafe_buffering_enabled(void);

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

@@ -12,8 +12,6 @@
  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
 
-#include <openssl/rand.h>
-
 #include <assert.h>
 #include <limits.h>
 #include <string.h>
@@ -26,10 +24,10 @@
 #include <openssl/ctrdrbg.h>
 #include <openssl/mem.h>
 
-#include "internal.h"
-#include "fork_detect.h"
-#include "../../internal.h"
+#include "../../bcm_support.h"
+#include "../bcm_interface.h"
 #include "../delocate.h"
+#include "internal.h"
 
 
 // It's assumed that the operating system always has an unfailing source of
@@ -99,7 +97,7 @@ static void rand_thread_state_clear_all(void) {
     CTR_DRBG_clear(&cur->drbg);
   }
   // The locks are deliberately left locked so that any threads that are still
-  // running will hang if they try to call |RAND_bytes|. It also ensures
+  // running will hang if they try to call |BCM_rand_bytes|. It also ensures
   // |rand_thread_state_free| cannot free any thread state while we've taken the
   // lock.
 }
@@ -164,26 +162,24 @@ static int rdrand(uint8_t *buf, const size_t len) {
 
 #else
 
-static int rdrand(uint8_t *buf, size_t len) {
-  return 0;
-}
+static int rdrand(uint8_t *buf, size_t len) { return 0; }
 
 #endif
 
-#if defined(BORINGSSL_FIPS)
-
-void CRYPTO_get_seed_entropy(uint8_t *out_entropy, size_t out_entropy_len,
-                             int *out_want_additional_input) {
-  *out_want_additional_input = 0;
-  if (have_rdrand() && rdrand(out_entropy, out_entropy_len)) {
-    *out_want_additional_input = 1;
-  } else {
-    CRYPTO_sysrand_for_seed(out_entropy, out_entropy_len);
+bcm_status BCM_rand_bytes_hwrng(uint8_t *buf, const size_t len) {
+  if (!have_rdrand()) {
+    return bcm_status_failure;
   }
+  if (rdrand(buf, len)) {
+    return bcm_status_not_approved;
+  }
+  return bcm_status_failure;
 }
 
+#if defined(BORINGSSL_FIPS)
+
 // In passive entropy mode, entropy is supplied from outside of the module via
-// |RAND_load_entropy| and is stored in global instance of the following
+// |BCM_rand_load_entropy| and is stored in global instance of the following
 // structure.
 
 struct entropy_buffer {
@@ -202,8 +198,8 @@ struct entropy_buffer {
 DEFINE_BSS_GET(struct entropy_buffer, entropy_buffer);
 DEFINE_STATIC_MUTEX(entropy_buffer_lock);
 
-void RAND_load_entropy(const uint8_t *entropy, size_t entropy_len,
-                       int want_additional_input) {
+bcm_infallible BCM_rand_load_entropy(const uint8_t *entropy, size_t entropy_len,
+                                     int want_additional_input) {
   struct entropy_buffer *const buffer = entropy_buffer_bss_get();
 
   CRYPTO_MUTEX_lock_write(entropy_buffer_lock_bss_get());
@@ -214,9 +210,9 @@ void RAND_load_entropy(const uint8_t *entropy, size_t entropy_len,
 
   OPENSSL_memcpy(&buffer->bytes[buffer->bytes_valid], entropy, entropy_len);
   buffer->bytes_valid += entropy_len;
-  buffer->want_additional_input |=
-      want_additional_input && (entropy_len != 0);
+  buffer->want_additional_input |= want_additional_input && (entropy_len != 0);
   CRYPTO_MUTEX_unlock_write(entropy_buffer_lock_bss_get());
+  return bcm_infallible_not_approved;
 }
 
 // get_seed_entropy fills |out_entropy_len| bytes of |out_entropy| from the
@@ -330,10 +326,10 @@ static void rand_get_seed(struct rand_thread_state *state,
 
 #endif
 
-void RAND_bytes_with_additional_data(uint8_t *out, size_t out_len,
-                                     const uint8_t user_additional_data[32]) {
+bcm_infallible BCM_rand_bytes_with_additional_data(
+    uint8_t *out, size_t out_len, const uint8_t user_additional_data[32]) {
   if (out_len == 0) {
-    return;
+    return bcm_infallible_approved;
   }
 
   const uint64_t fork_generation = CRYPTO_get_fork_generation();
@@ -473,21 +469,11 @@ void RAND_bytes_with_additional_data(uint8_t *out, size_t out_len,
 #if defined(BORINGSSL_FIPS)
   CRYPTO_MUTEX_unlock_read(&state->clear_drbg_lock);
 #endif
+  return bcm_infallible_approved;
 }
 
-int RAND_bytes(uint8_t *out, size_t out_len) {
+bcm_infallible BCM_rand_bytes(uint8_t *out, size_t out_len) {
   static const uint8_t kZeroAdditionalData[32] = {0};
-  RAND_bytes_with_additional_data(out, out_len, kZeroAdditionalData);
-  return 1;
-}
-
-int RAND_pseudo_bytes(uint8_t *buf, size_t len) {
-  return RAND_bytes(buf, len);
-}
-
-void RAND_get_system_entropy_for_custom_prng(uint8_t *buf, size_t len) {
-  if (len > 256) {
-    abort();
-  }
-  CRYPTO_sysrand_for_seed(buf, len);
+  BCM_rand_bytes_with_additional_data(out, out_len, kZeroAdditionalData);
+  return bcm_infallible_approved;
 }

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

@@ -63,11 +63,11 @@
 #include <openssl/digest.h>
 #include <openssl/err.h>
 #include <openssl/mem.h>
-#include <openssl/rand.h>
 #include <openssl/sha.h>
 
 #include "internal.h"
 #include "../service_indicator/internal.h"
+#include "../bcm_interface.h"
 #include "../../internal.h"
 
 
@@ -369,9 +369,7 @@ int RSA_padding_add_PKCS1_PSS_mgf1(const RSA *rsa, unsigned char *EM,
     if (!salt) {
       goto err;
     }
-    if (!RAND_bytes(salt, sLen)) {
-      goto err;
-    }
+    BCM_rand_bytes(salt, sLen);
   }
   maskedDBLen = emLen - hLen - 1;
   H = EM + maskedDBLen;
@@ -394,7 +392,6 @@ int RSA_padding_add_PKCS1_PSS_mgf1(const RSA *rsa, unsigned char *EM,
   }
 
   p = EM;
-
   // Initial PS XORs with all zeroes which is a NOP so just update
   // pointer. Note from a test above this value is guaranteed to
   // be non-negative.

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

@@ -65,10 +65,10 @@
 #include <openssl/mem.h>
 #include <openssl/thread.h>
 
+#include "../../bcm_support.h"
 #include "../../internal.h"
 #include "../bn/internal.h"
 #include "../delocate.h"
-#include "../rand/fork_detect.h"
 #include "../service_indicator/internal.h"
 #include "internal.h"
 

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

@@ -33,6 +33,7 @@
 #include <openssl/sha.h>
 
 #include "../../internal.h"
+#include "../delocate.h"
 #include "../dh/internal.h"
 #include "../ec/internal.h"
 #include "../ecdsa/internal.h"
@@ -77,28 +78,6 @@ static int set_bignum(BIGNUM **out, const uint8_t *in, size_t len) {
   return *out != NULL;
 }
 
-static int serialize_ecdsa_sig(uint8_t *out, size_t out_len,
-                               const ECDSA_SIG *sig) {
-  if ((out_len & 1) ||  //
-      !BN_bn2bin_padded(out, out_len / 2, sig->r) ||
-      !BN_bn2bin_padded(out + out_len / 2, out_len / 2, sig->s)) {
-    return 0;
-  }
-  return 1;
-}
-
-static ECDSA_SIG *parse_ecdsa_sig(const uint8_t *in, size_t in_len) {
-  ECDSA_SIG *ret = ECDSA_SIG_new();
-  if (!ret || //
-      (in_len & 1) ||
-      BN_bin2bn(in, in_len/2, ret->r) == NULL ||
-      BN_bin2bn(in + in_len/2, in_len/2, ret->s) == NULL) {
-    ECDSA_SIG_free(ret);
-    ret = NULL;
-  }
-  return ret;
-}
-
 static RSA *self_test_rsa_key(void) {
   static const uint8_t kN[] = {
       0xd3, 0x3a, 0x62, 0x9f, 0x07, 0x77, 0xb0, 0x18, 0xf3, 0xff, 0xfe, 0xcc,
@@ -415,7 +394,6 @@ static int boringssl_self_test_ecc(void) {
   EC_POINT *ec_point_in = NULL;
   EC_POINT *ec_point_out = NULL;
   BIGNUM *ec_scalar = NULL;
-  ECDSA_SIG *sig = NULL;
 
   ec_key = self_test_ecdsa_key();
   if (ec_key == NULL) {
@@ -443,13 +421,12 @@ static int boringssl_self_test_ecc(void) {
   uint8_t ecdsa_k[32] = {0};
   ecdsa_k[31] = 42;
 
-  sig = ecdsa_sign_with_nonce_for_known_answer_test(
-      kECDSASignDigest, sizeof(kECDSASignDigest), ec_key, ecdsa_k,
-      sizeof(ecdsa_k));
-
   uint8_t ecdsa_sign_output[64];
-  if (sig == NULL ||
-      !serialize_ecdsa_sig(ecdsa_sign_output, sizeof(ecdsa_sign_output), sig) ||
+  size_t ecdsa_sign_output_len;
+  if (!ecdsa_sign_fixed_with_nonce_for_known_answer_test(
+          kECDSASignDigest, sizeof(kECDSASignDigest), ecdsa_sign_output,
+          &ecdsa_sign_output_len, sizeof(ecdsa_sign_output), ec_key, ecdsa_k,
+          sizeof(ecdsa_k)) ||
       !check_test(kECDSASignSig, ecdsa_sign_output, sizeof(ecdsa_sign_output),
                   "ECDSA-sign signature")) {
     fprintf(stderr, "ECDSA-sign KAT failed.\n");
@@ -470,11 +447,9 @@ static int boringssl_self_test_ecc(void) {
       0x8e, 0x5f, 0x64, 0xc3, 0x7e, 0xa2, 0xcf, 0x05, 0x29,
   };
 
-  ECDSA_SIG_free(sig);
-  sig = parse_ecdsa_sig(kECDSAVerifySig, sizeof(kECDSAVerifySig));
-  if (!sig ||
-      !ecdsa_do_verify_no_self_test(kECDSAVerifyDigest,
-                                    sizeof(kECDSAVerifyDigest), sig, ec_key)) {
+  if (!ecdsa_verify_fixed_no_self_test(
+          kECDSAVerifyDigest, sizeof(kECDSAVerifyDigest), kECDSAVerifySig,
+          sizeof(kECDSAVerifySig), ec_key)) {
     fprintf(stderr, "ECDSA-verify KAT failed.\n");
     goto err;
   }
@@ -532,7 +507,6 @@ err:
   EC_POINT_free(ec_point_in);
   EC_POINT_free(ec_point_out);
   BN_free(ec_scalar);
-  ECDSA_SIG_free(sig);
 
   return ret;
 }

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

@@ -28,8 +28,8 @@ void FIPS_service_indicator_update_state(void);
 // stop |FIPS_service_indicator_update_state| from actually updating the service
 // indicator. This is used when a primitive calls a potentially approved
 // primitive to avoid false positives. For example, just because a key
-// generation calls |RAND_bytes| (and thus the approved DRBG) doesn't mean that
-// the key generation operation itself is approved.
+// generation calls |BCM_rand_bytes| (and thus the approved DRBG) doesn't mean
+// that the key generation operation itself is approved.
 //
 // This lock nests: i.e. locking twice is fine so long as each lock is paired
 // with an unlock. If the (64-bit) counter overflows, the process aborts.

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

@@ -248,7 +248,7 @@ static void evp_md_ctx_verify_service_indicator(const EVP_MD_CTX *ctx,
 }
 
 void EC_KEY_keygen_verify_service_indicator(const EC_KEY *eckey) {
-  if (is_ec_fips_approved(EC_GROUP_get_curve_name(eckey->group))) {
+  if (is_ec_fips_approved(EC_GROUP_get_curve_name(EC_KEY_get0_group(eckey)))) {
     FIPS_service_indicator_update_state();
   }
 }
@@ -287,7 +287,7 @@ void EVP_DigestSign_verify_service_indicator(const EVP_MD_CTX *ctx) {
 }
 
 void HMAC_verify_service_indicator(const EVP_MD *evp_md) {
-  switch (evp_md->type) {
+  switch (EVP_MD_type(evp_md)) {
     case NID_sha1:
     case NID_sha224:
     case NID_sha256: