grpc 1.81.1 → 1.85.0

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

@@ -16,27 +16,48 @@
 #define OPENSSL_HEADER_CRYPTO_FIPSMODULE_SERVICE_INDICATOR_INTERNAL_H
 
 #include <openssl/base.h>
-#include <openssl/service_indicator.h>
+
+
+BSSL_NAMESPACE_BEGIN
+
+// FIPS_service_indicator_before_call and `FIPS_service_indicator_after_call`
+// both currently return the same local thread counter which is slowly
+// incremented whenever approved services are called. The
+// `CALL_SERVICE_AND_CHECK_APPROVED` macro is strongly recommended over calling
+// these functions directly.
+//
+// `FIPS_service_indicator_before_call` is intended to be called immediately
+// before an approved service, while `FIPS_service_indicator_after_call` should
+// be called immediately after. If the values returned from these two functions
+// are not equal, this means that the service called in between is deemed to be
+// approved. If the values are still the same, this means the counter has not
+// been incremented, and the service called is not approved for FIPS.
+//
+// In non-FIPS builds, `FIPS_service_indicator_before_call` always returns zero
+// and `FIPS_service_indicator_after_call` always returns one. Thus calls always
+// appear to be approved. This is intended to simplify testing.
+OPENSSL_EXPORT uint64_t FIPS_service_indicator_before_call();
+OPENSSL_EXPORT uint64_t FIPS_service_indicator_after_call();
 
 #if defined(BORINGSSL_FIPS)
 
 // FIPS_service_indicator_update_state records that an approved service has been
 // invoked.
-void FIPS_service_indicator_update_state(void);
+void FIPS_service_indicator_update_state();
 
-// FIPS_service_indicator_lock_state and |FIPS_service_indicator_unlock_state|
-// stop |FIPS_service_indicator_update_state| from actually updating the service
+// FIPS_service_indicator_lock_state and `FIPS_service_indicator_unlock_state`
+// 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 |BCM_rand_bytes| (and thus the approved DRBG) doesn't mean
+// 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.
-void FIPS_service_indicator_lock_state(void);
-void FIPS_service_indicator_unlock_state(void);
+void FIPS_service_indicator_lock_state();
+void FIPS_service_indicator_unlock_state();
 
-// The following functions may call |FIPS_service_indicator_update_state| if
+// The following functions may call `FIPS_service_indicator_update_state` if
 // their parameter specifies an approved operation.
 
 void AEAD_GCM_verify_service_indicator(const EVP_AEAD_CTX *ctx);
@@ -53,9 +74,9 @@ void TLSKDF_verify_service_indicator(const EVP_MD *dgst);
 
 // Service indicator functions are no-ops in non-FIPS builds.
 
-inline void FIPS_service_indicator_update_state(void) {}
-inline void FIPS_service_indicator_lock_state(void) {}
-inline void FIPS_service_indicator_unlock_state(void) {}
+inline void FIPS_service_indicator_update_state() {}
+inline void FIPS_service_indicator_lock_state() {}
+inline void FIPS_service_indicator_unlock_state() {}
 
 inline void AEAD_GCM_verify_service_indicator(
     [[maybe_unused]] const EVP_AEAD_CTX *ctx) {}
@@ -86,4 +107,6 @@ inline void TLSKDF_verify_service_indicator(
 
 #endif  // BORINGSSL_FIPS
 
+BSSL_NAMESPACE_END
+
 #endif  // OPENSSL_HEADER_CRYPTO_FIPSMODULE_SERVICE_INDICATOR_INTERNAL_H

data/third_party/boringssl-with-bazel/crypto/fipsmodule/service_indicator/service_indicator.cc.inc

@@ -17,12 +17,15 @@
 #include <openssl/ec_key.h>
 #include <openssl/err.h>
 #include <openssl/evp.h>
-#include <openssl/service_indicator.h>
 
 #include "../../evp/internal.h"
 #include "../../internal.h"
+#include "../../mem_internal.h"
 #include "internal.h"
 
+
+using namespace bssl;
+
 #if defined(BORINGSSL_FIPS)
 
 #define STATE_UNLOCKED 0
@@ -31,29 +34,28 @@
 // state of the FIPS service indicator.
 struct fips_service_indicator_state {
   // lock_state records the number of times the indicator has been locked.
-  // When it is zero (i.e. |STATE_UNLOCKED|) then the indicator can be updated.
+  // When it is zero (i.e. `STATE_UNLOCKED`) then the indicator can be updated.
   uint64_t lock_state;
   // counter is the indicator state. It is incremented when an approved service
   // completes.
   uint64_t counter;
 };
 
-// service_indicator_get returns a pointer to the |fips_service_indicator_state|
-// for the current thread. It returns NULL on error.
+// service_indicator_get returns a pointer to the `fips_service_indicator_state`
+// for the current thread. It returns nullptr on error.
 //
 // FIPS 140-3 requires that the module should provide the service indicator
 // for approved services irrespective of whether the user queries it or not.
 // Hence, it is lazily initialized in any call to an approved service.
-static struct fips_service_indicator_state *service_indicator_get(void) {
+static struct fips_service_indicator_state *service_indicator_get() {
   struct fips_service_indicator_state *indicator =
       reinterpret_cast<fips_service_indicator_state *>(CRYPTO_get_thread_local(
           OPENSSL_THREAD_LOCAL_FIPS_SERVICE_INDICATOR_STATE));
 
-  if (indicator == NULL) {
-    indicator = reinterpret_cast<fips_service_indicator_state *>(
-        OPENSSL_malloc(sizeof(struct fips_service_indicator_state)));
-    if (indicator == NULL) {
-      return NULL;
+  if (indicator == nullptr) {
+    indicator = New<struct fips_service_indicator_state>();
+    if (indicator == nullptr) {
+      return nullptr;
     }
 
     indicator->lock_state = STATE_UNLOCKED;
@@ -63,60 +65,60 @@ static struct fips_service_indicator_state *service_indicator_get(void) {
             OPENSSL_THREAD_LOCAL_FIPS_SERVICE_INDICATOR_STATE, indicator,
             OPENSSL_free)) {
       OPENSSL_PUT_ERROR(CRYPTO, ERR_R_INTERNAL_ERROR);
-      return NULL;
+      return nullptr;
     }
   }
 
   return indicator;
 }
 
-static uint64_t service_indicator_get_counter(void) {
+static uint64_t service_indicator_get_counter() {
   struct fips_service_indicator_state *indicator = service_indicator_get();
-  if (indicator == NULL) {
+  if (indicator == nullptr) {
     return 0;
   }
   return indicator->counter;
 }
 
-uint64_t FIPS_service_indicator_before_call(void) {
+uint64_t bssl::FIPS_service_indicator_before_call() {
   return service_indicator_get_counter();
 }
 
-uint64_t FIPS_service_indicator_after_call(void) {
+uint64_t bssl::FIPS_service_indicator_after_call() {
   return service_indicator_get_counter();
 }
 
-void FIPS_service_indicator_update_state(void) {
+void bssl::FIPS_service_indicator_update_state() {
   struct fips_service_indicator_state *indicator = service_indicator_get();
   if (indicator && indicator->lock_state == STATE_UNLOCKED) {
     indicator->counter++;
   }
 }
 
-void FIPS_service_indicator_lock_state(void) {
+void bssl::FIPS_service_indicator_lock_state() {
   struct fips_service_indicator_state *indicator = service_indicator_get();
-  if (indicator == NULL) {
+  if (indicator == nullptr) {
     return;
   }
 
-  // |FIPS_service_indicator_lock_state| and
-  // |FIPS_service_indicator_unlock_state| should not under/overflow in normal
+  // `FIPS_service_indicator_lock_state` and
+  // `FIPS_service_indicator_unlock_state` should not under/overflow in normal
   // operation. They are still checked and errors added to facilitate testing in
   // service_indicator_test.cc. This should only happen if lock/unlock are
   // called in an incorrect order or multiple times in the same function.
   const uint64_t new_state = indicator->lock_state + 1;
   if (new_state < indicator->lock_state) {
     // Overflow. This would imply that our call stack length has exceeded a
-    // |uint64_t| which impossible on a 64-bit system.
+    // `uint64_t` which impossible on a 64-bit system.
     abort();
   }
 
   indicator->lock_state = new_state;
 }
 
-void FIPS_service_indicator_unlock_state(void) {
+void bssl::FIPS_service_indicator_unlock_state() {
   struct fips_service_indicator_state *indicator = service_indicator_get();
-  if (indicator == NULL) {
+  if (indicator == nullptr) {
     return;
   }
 
@@ -127,14 +129,14 @@ void FIPS_service_indicator_unlock_state(void) {
   indicator->lock_state--;
 }
 
-void AEAD_GCM_verify_service_indicator(const EVP_AEAD_CTX *ctx) {
+void bssl::AEAD_GCM_verify_service_indicator(const EVP_AEAD_CTX *ctx) {
   const size_t key_len = EVP_AEAD_key_length(ctx->aead);
   if (key_len == 16 || key_len == 32) {
     FIPS_service_indicator_update_state();
   }
 }
 
-void AEAD_CCM_verify_service_indicator(const EVP_AEAD_CTX *ctx) {
+void bssl::AEAD_CCM_verify_service_indicator(const EVP_AEAD_CTX *ctx) {
   if (EVP_AEAD_key_length(ctx->aead) == 16 && ctx->tag_len == 4) {
     FIPS_service_indicator_update_state();
   }
@@ -186,7 +188,7 @@ static int is_md_fips_approved_for_verifying(int md_type) {
 
 static void evp_md_ctx_verify_service_indicator(const EVP_MD_CTX *ctx,
                                                 int (*md_ok)(int md_type)) {
-  if (EVP_MD_CTX_get0_md(ctx) == NULL) {
+  if (EVP_MD_CTX_get0_md(ctx) == nullptr) {
     // Signature schemes without a prehash are currently never FIPS approved.
     return;
   }
@@ -199,8 +201,8 @@ static void evp_md_ctx_verify_service_indicator(const EVP_MD_CTX *ctx,
   // EVP_PKEY_RSA_PSS SPKIs aren't supported.
   if (pkey_type == EVP_PKEY_RSA) {
     // Message digest used in the private key should be of the same type
-    // as the given one, so we extract the MD type from the |EVP_PKEY|
-    // and compare it with the type in |ctx|.
+    // as the given one, so we extract the MD type from the `EVP_PKEY`
+    // and compare it with the type in `ctx`.
     const EVP_MD *pctx_md;
     if (!EVP_PKEY_CTX_get_signature_md(pctx, &pctx_md)) {
       goto err;
@@ -218,7 +220,8 @@ static void evp_md_ctx_verify_service_indicator(const EVP_MD_CTX *ctx,
       const EVP_MD *mgf1_md;
       if (!EVP_PKEY_CTX_get_rsa_pss_saltlen(pctx, &salt_len) ||
           !EVP_PKEY_CTX_get_rsa_mgf1_md(pctx, &mgf1_md) ||
-          (salt_len != -1 && salt_len != (int)EVP_MD_size(pctx_md)) ||
+          (salt_len != RSA_PSS_SALTLEN_DIGEST &&
+           salt_len != (int)EVP_MD_size(pctx_md)) ||
           EVP_MD_type(mgf1_md) != md_type) {
         // Only PSS where saltLen == hashLen is tested with ACVP. Cases with
         // non-standard padding functions are also excluded.
@@ -227,8 +230,8 @@ static void evp_md_ctx_verify_service_indicator(const EVP_MD_CTX *ctx,
     }
 
     // The approved RSA key sizes for signing are 2048, 3072 and 4096 bits.
-    // Note: |EVP_PKEY_size| returns the size in bytes.
-    size_t pkey_size = EVP_PKEY_size(ctx->pctx->pkey);
+    // Note: `EVP_PKEY_size` returns the size in bytes.
+    size_t pkey_size = EVP_PKEY_size(FromOpaque(ctx->pctx)->pkey.get());
 
     // Check if the MD type and the RSA key size are approved.
     if (md_ok(md_type) &&
@@ -238,8 +241,8 @@ static void evp_md_ctx_verify_service_indicator(const EVP_MD_CTX *ctx,
   } else if (pkey_type == EVP_PKEY_EC) {
     // Check if the MD type and the elliptic curve are approved.
     if (md_ok(md_type) &&
-        is_ec_fips_approved(EC_GROUP_get_curve_name(
-            EC_KEY_get0_group(EVP_PKEY_get0_EC_KEY(ctx->pctx->pkey))))) {
+        is_ec_fips_approved(EC_GROUP_get_curve_name(EC_KEY_get0_group(
+            EVP_PKEY_get0_EC_KEY(FromOpaque(ctx->pctx)->pkey.get()))))) {
       FIPS_service_indicator_update_state();
     }
   }
@@ -249,19 +252,19 @@ err:
   ERR_clear_error();
 }
 
-void EC_KEY_keygen_verify_service_indicator(const EC_KEY *eckey) {
+void bssl::EC_KEY_keygen_verify_service_indicator(const EC_KEY *eckey) {
   if (is_ec_fips_approved(EC_GROUP_get_curve_name(EC_KEY_get0_group(eckey)))) {
     FIPS_service_indicator_update_state();
   }
 }
 
-void ECDH_verify_service_indicator(const EC_KEY *ec_key) {
+void bssl::ECDH_verify_service_indicator(const EC_KEY *ec_key) {
   if (is_ec_fips_approved(EC_GROUP_get_curve_name(EC_KEY_get0_group(ec_key)))) {
     FIPS_service_indicator_update_state();
   }
 }
 
-void EVP_Cipher_verify_service_indicator(const EVP_CIPHER_CTX *ctx) {
+void bssl::EVP_Cipher_verify_service_indicator(const EVP_CIPHER_CTX *ctx) {
   switch (EVP_CIPHER_CTX_nid(ctx)) {
     case NID_aes_128_ecb:
     case NID_aes_192_ecb:
@@ -278,17 +281,17 @@ void EVP_Cipher_verify_service_indicator(const EVP_CIPHER_CTX *ctx) {
   }
 }
 
-void EVP_DigestVerify_verify_service_indicator(const EVP_MD_CTX *ctx) {
+void bssl::EVP_DigestVerify_verify_service_indicator(const EVP_MD_CTX *ctx) {
   return evp_md_ctx_verify_service_indicator(ctx,
                                              is_md_fips_approved_for_verifying);
 }
 
-void EVP_DigestSign_verify_service_indicator(const EVP_MD_CTX *ctx) {
+void bssl::EVP_DigestSign_verify_service_indicator(const EVP_MD_CTX *ctx) {
   return evp_md_ctx_verify_service_indicator(ctx,
                                              is_md_fips_approved_for_signing);
 }
 
-void HMAC_verify_service_indicator(const EVP_MD *evp_md) {
+void bssl::HMAC_verify_service_indicator(const EVP_MD *evp_md) {
   switch (EVP_MD_type(evp_md)) {
     case NID_sha1:
     case NID_sha224:
@@ -301,7 +304,7 @@ void HMAC_verify_service_indicator(const EVP_MD *evp_md) {
   }
 }
 
-void TLSKDF_verify_service_indicator(const EVP_MD *md) {
+void bssl::TLSKDF_verify_service_indicator(const EVP_MD *md) {
   // HMAC-SHA{256, 384, 512} are approved for use in the KDF in TLS 1.2. These
   // Key Derivation functions are to be used in the context of the TLS protocol.
   switch (EVP_MD_type(md)) {
@@ -315,11 +318,11 @@ void TLSKDF_verify_service_indicator(const EVP_MD *md) {
 
 #else
 
-uint64_t FIPS_service_indicator_before_call(void) { return 0; }
+uint64_t bssl::FIPS_service_indicator_before_call() { return 0; }
 
-uint64_t FIPS_service_indicator_after_call(void) {
+uint64_t bssl::FIPS_service_indicator_after_call() {
   // One is returned so that the return value is always greater than zero, the
-  // return value of |FIPS_service_indicator_before_call|. This makes everything
+  // return value of `FIPS_service_indicator_before_call`. This makes everything
   // report as "approved" in non-FIPS builds.
   return 1;
 }

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

@@ -19,9 +19,8 @@
 
 #include "../../internal.h"
 
-#if defined(__cplusplus)
-extern "C" {
-#endif
+
+BSSL_NAMESPACE_BEGIN
 
 // Define SHA{n}[_{variant}]_ASM if sha{n}_block_data_order[_{variant}] is
 // defined in assembly.
@@ -33,23 +32,23 @@ extern "C" {
 #define SHA512_ASM_NOHW
 
 #define SHA1_ASM_HW
-inline int sha1_hw_capable(void) { return CRYPTO_is_ARMv8_SHA1_capable(); }
+inline int sha1_hw_capable() { return CRYPTO_is_ARMv8_SHA1_capable(); }
 
 #define SHA1_ASM_NEON
-void sha1_block_data_order_neon(uint32_t state[5], const uint8_t *data,
-                                size_t num);
+extern "C" void sha1_block_data_order_neon(uint32_t state[5],
+                                           const uint8_t *data, size_t num);
 
 #define SHA256_ASM_HW
-inline int sha256_hw_capable(void) { return CRYPTO_is_ARMv8_SHA256_capable(); }
+inline int sha256_hw_capable() { return CRYPTO_is_ARMv8_SHA256_capable(); }
 
 #define SHA256_ASM_NEON
-void sha256_block_data_order_neon(uint32_t state[8], const uint8_t *data,
-                                  size_t num);
+extern "C" void sha256_block_data_order_neon(uint32_t state[8],
+                                             const uint8_t *data, size_t num);
 
 // Armv8.2 SHA-512 instructions are not available in 32-bit.
 #define SHA512_ASM_NEON
-void sha512_block_data_order_neon(uint64_t state[8], const uint8_t *data,
-                                  size_t num);
+extern "C" void sha512_block_data_order_neon(uint64_t state[8],
+                                             const uint8_t *data, size_t num);
 
 #elif !defined(OPENSSL_NO_ASM) && defined(OPENSSL_AARCH64)
 
@@ -58,13 +57,13 @@ void sha512_block_data_order_neon(uint64_t state[8], const uint8_t *data,
 #define SHA512_ASM_NOHW
 
 #define SHA1_ASM_HW
-inline int sha1_hw_capable(void) { return CRYPTO_is_ARMv8_SHA1_capable(); }
+inline int sha1_hw_capable() { return CRYPTO_is_ARMv8_SHA1_capable(); }
 
 #define SHA256_ASM_HW
-inline int sha256_hw_capable(void) { return CRYPTO_is_ARMv8_SHA256_capable(); }
+inline int sha256_hw_capable() { return CRYPTO_is_ARMv8_SHA256_capable(); }
 
 #define SHA512_ASM_HW
-inline int sha512_hw_capable(void) { return CRYPTO_is_ARMv8_SHA512_capable(); }
+inline int sha512_hw_capable() { return CRYPTO_is_ARMv8_SHA512_capable(); }
 
 #elif !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86)
 
@@ -73,45 +72,39 @@ inline int sha512_hw_capable(void) { return CRYPTO_is_ARMv8_SHA512_capable(); }
 #define SHA512_ASM_NOHW
 
 #define SHA1_ASM_SSSE3
-inline int sha1_ssse3_capable(void) {
-  return CRYPTO_is_SSSE3_capable();
-}
-void sha1_block_data_order_ssse3(uint32_t state[5], const uint8_t *data,
-                                 size_t num);
+inline int sha1_ssse3_capable() { return CRYPTO_is_SSSE3_capable(); }
+extern "C" void sha1_block_data_order_ssse3(uint32_t state[5],
+                                            const uint8_t *data, size_t num);
 
 #define SHA1_ASM_AVX
-inline int sha1_avx_capable(void) {
+inline int sha1_avx_capable() {
   // AMD CPUs have slow SHLD/SHRD. See also the discussion in sha1-586.pl.
   //
   // TODO(crbug.com/42290564): Should we enable SHAEXT on 32-bit x86?
   return CRYPTO_is_AVX_capable() && CRYPTO_is_intel_cpu();
 }
-void sha1_block_data_order_avx(uint32_t state[5], const uint8_t *data,
-                               size_t num);
+extern "C" void sha1_block_data_order_avx(uint32_t state[5],
+                                          const uint8_t *data, size_t num);
 
 #define SHA256_ASM_SSSE3
-inline int sha256_ssse3_capable(void) {
-  return CRYPTO_is_SSSE3_capable();
-}
-void sha256_block_data_order_ssse3(uint32_t state[8], const uint8_t *data,
-                                   size_t num);
+inline int sha256_ssse3_capable() { return CRYPTO_is_SSSE3_capable(); }
+extern "C" void sha256_block_data_order_ssse3(uint32_t state[8],
+                                              const uint8_t *data, size_t num);
 
 #define SHA256_ASM_AVX
-inline int sha256_avx_capable(void) {
+inline int sha256_avx_capable() {
   // AMD CPUs have slow SHLD/SHRD. See also the discussion in sha1-586.pl.
   //
   // TODO(crbug.com/42290564): Should we enable SHAEXT on 32-bit x86?
   return CRYPTO_is_AVX_capable() && CRYPTO_is_intel_cpu();
 }
-void sha256_block_data_order_avx(uint32_t state[8], const uint8_t *data,
-                                 size_t num);
+extern "C" void sha256_block_data_order_avx(uint32_t state[8],
+                                            const uint8_t *data, size_t num);
 
 #define SHA512_ASM_SSSE3
-inline int sha512_ssse3_capable(void) {
-  return CRYPTO_is_SSSE3_capable();
-}
-void sha512_block_data_order_ssse3(uint64_t state[8], const uint8_t *data,
-                                   size_t num);
+inline int sha512_ssse3_capable() { return CRYPTO_is_SSSE3_capable(); }
+extern "C" void sha512_block_data_order_ssse3(uint64_t state[8],
+                                              const uint8_t *data, size_t num);
 
 #elif !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86_64)
 
@@ -120,95 +113,93 @@ void sha512_block_data_order_ssse3(uint64_t state[8], const uint8_t *data,
 #define SHA512_ASM_NOHW
 
 #define SHA1_ASM_HW
-inline int sha1_hw_capable(void) {
+inline int sha1_hw_capable() {
   return CRYPTO_is_x86_SHA_capable() && CRYPTO_is_SSSE3_capable();
 }
 
 #define SHA1_ASM_AVX2
-inline int sha1_avx2_capable(void) {
+inline int sha1_avx2_capable() {
   return CRYPTO_is_AVX2_capable() && CRYPTO_is_BMI2_capable() &&
          CRYPTO_is_BMI1_capable();
 }
-void sha1_block_data_order_avx2(uint32_t state[5], const uint8_t *data,
-                                size_t num);
+extern "C" void sha1_block_data_order_avx2(uint32_t state[5],
+                                           const uint8_t *data, size_t num);
 
 #define SHA1_ASM_AVX
-inline int sha1_avx_capable(void) {
+inline int sha1_avx_capable() {
   // AMD CPUs have slow SHLD/SHRD. See also the discussion in sha1-586.pl. Zen
   // added the SHA extension, so this is moot on newer AMD CPUs.
   return CRYPTO_is_AVX_capable() && CRYPTO_is_intel_cpu();
 }
-void sha1_block_data_order_avx(uint32_t state[5], const uint8_t *data,
-                               size_t num);
+extern "C" void sha1_block_data_order_avx(uint32_t state[5],
+                                          const uint8_t *data, size_t num);
 
 #define SHA1_ASM_SSSE3
-inline int sha1_ssse3_capable(void) { return CRYPTO_is_SSSE3_capable(); }
-void sha1_block_data_order_ssse3(uint32_t state[5], const uint8_t *data,
-                                 size_t num);
+inline int sha1_ssse3_capable() { return CRYPTO_is_SSSE3_capable(); }
+extern "C" void sha1_block_data_order_ssse3(uint32_t state[5],
+                                            const uint8_t *data, size_t num);
 
 #define SHA256_ASM_HW
-inline int sha256_hw_capable(void) {
+inline int sha256_hw_capable() {
   // Note that the original assembly did not check SSSE3.
   return CRYPTO_is_x86_SHA_capable() && CRYPTO_is_SSSE3_capable();
 }
 
 #define SHA256_ASM_AVX
-inline int sha256_avx_capable(void) {
+inline int sha256_avx_capable() {
   // AMD CPUs have slow SHLD/SHRD. See also the discussion in sha1-586.pl. Zen
   // added the SHA extension, so this is moot on newer AMD CPUs.
   return CRYPTO_is_AVX_capable() && CRYPTO_is_intel_cpu();
 }
-void sha256_block_data_order_avx(uint32_t state[8], const uint8_t *data,
-                                 size_t num);
+extern "C" void sha256_block_data_order_avx(uint32_t state[8],
+                                            const uint8_t *data, size_t num);
 
 #define SHA256_ASM_SSSE3
-inline int sha256_ssse3_capable(void) { return CRYPTO_is_SSSE3_capable(); }
-void sha256_block_data_order_ssse3(uint32_t state[8], const uint8_t *data,
-                                   size_t num);
+inline int sha256_ssse3_capable() { return CRYPTO_is_SSSE3_capable(); }
+extern "C" void sha256_block_data_order_ssse3(uint32_t state[8],
+                                              const uint8_t *data, size_t num);
 
 #define SHA512_ASM_AVX
-inline int sha512_avx_capable(void) {
+inline int sha512_avx_capable() {
   // AMD CPUs have slow SHLD/SHRD. See also the discussion in sha1-586.pl.
   //
   // TODO(crbug.com/42290564): Fixing and enabling the AVX2 implementation would
   // mitigate this on newer AMD CPUs.
   return CRYPTO_is_AVX_capable() && CRYPTO_is_intel_cpu();
 }
-void sha512_block_data_order_avx(uint64_t state[8], const uint8_t *data,
-                                 size_t num);
+extern "C" void sha512_block_data_order_avx(uint64_t state[8],
+                                            const uint8_t *data, size_t num);
 
 #endif
 
 #if defined(SHA1_ASM_HW)
-void sha1_block_data_order_hw(uint32_t state[5], const uint8_t *data,
-                              size_t num);
+extern "C" void sha1_block_data_order_hw(uint32_t state[5], const uint8_t *data,
+                                         size_t num);
 #endif
 #if defined(SHA1_ASM_NOHW)
-void sha1_block_data_order_nohw(uint32_t state[5], const uint8_t *data,
-                                size_t num);
+extern "C" void sha1_block_data_order_nohw(uint32_t state[5],
+                                           const uint8_t *data, size_t num);
 #endif
 
 #if defined(SHA256_ASM_HW)
-void sha256_block_data_order_hw(uint32_t state[8], const uint8_t *data,
-                                size_t num);
+extern "C" void sha256_block_data_order_hw(uint32_t state[8],
+                                           const uint8_t *data, size_t num);
 #endif
 #if defined(SHA256_ASM_NOHW)
-void sha256_block_data_order_nohw(uint32_t state[8], const uint8_t *data,
-                                  size_t num);
+extern "C" void sha256_block_data_order_nohw(uint32_t state[8],
+                                             const uint8_t *data, size_t num);
 #endif
 
 #if defined(SHA512_ASM_HW)
-void sha512_block_data_order_hw(uint64_t state[8], const uint8_t *data,
-                                size_t num);
+extern "C" void sha512_block_data_order_hw(uint64_t state[8],
+                                           const uint8_t *data, size_t num);
 #endif
 
 #if defined(SHA512_ASM_NOHW)
-void sha512_block_data_order_nohw(uint64_t state[8], const uint8_t *data,
-                                  size_t num);
+extern "C" void sha512_block_data_order_nohw(uint64_t state[8],
+                                             const uint8_t *data, size_t num);
 #endif
 
-#if defined(__cplusplus)
-}  // extern "C"
-#endif
+BSSL_NAMESPACE_END
 
 #endif  // OPENSSL_HEADER_CRYPTO_FIPSMODULE_SHA_INTERNAL_H