Provide a platform abstraction for RandBytes instead of swapping headers

The `RandBytes` functions were being placed in the `crypto` namespace,
which collides with Chromium's namespace of the same name. Within,
`RandBytes` was defined with almost-the-same API. Then in Chromium
builds, the Chromium header would be used instead (though somewhat
inconsistently).

This creates a lot of pain for Chromium development as there's a
third-party repository directly depending on headers from Chromium's
source tree, and is against the third-party policies for that reason.
There are a number of other headers that mirror Chromium and are
swapped out in the Chromium build that will cause similar pain, such as:
```
include "crypto/aead.h"
include "crypto/ec_private_key.h"
include "crypto/hkdf.h"
```

This CL provides a template for how to get rid of these header swaps and
give a platform abstraction in nearby instead.

We provide a platform abstraction in `platform/crypto.h` (really in
`platform/implementation/crypto.h`) which is implemented in
`platform/implementation/shared/crypto.cc`. However that implementation
is removed by `#ifdef` when in the Chromium build.

Then, in the Chromium repo, we will add (separately) an implementation
of the same abstraction in `//third_party/nearby/platform_impl` with GN
rules to include it in the build. It will replace the implementation
from the nearby repo.

Copybara import of the project:

--
6ca8099 by danakj <danakj@chromium.org>:

Provide a platform abstraction for RandBytes instead of swapping headers

The `RandBytes` functions were being placed in the `crypto` namespace,
which collides with Chromium's namespace of the same name. Within,
`RandBytes` was defined with almost-the-same API. Then in Chromium
builds, the Chromium header would be used instead (though somewhat
inconsistently).

This creates a lot of pain for Chromium development as there's a
third-party repository directly depending on headers from Chromium's
source tree, and is against the third-party policies for that reason.
There are a number of other headers that mirror Chromium and are
swapped out in the Chromium build that will cause similar pain, such as:
```
include "crypto/aead.h"
include "crypto/ec_private_key.h"
include "crypto/hkdf.h"
```

This CL provides a template for how to get rid of these header swaps and
give a platform abstraction in nearby instead.

We provide a platform abstraction in `platform/crypto.h` (really in
`platform/implementation/crypto.h`) which is implemented in
`platform/implementation/shared/crypto.cc`. However that implementation
is removed by `#ifdef` when in the Chromium build.

Then, in the Chromium repo, we will add (separately) an implementation
of the same abstraction in `//third_party/nearby/platform_impl` with GN
rules to include it in the build. It will replace the implementation
from the nearby repo.

--
9c2654b by danakj <danakj@chromium.org>:

Remove CryptoSpan, use absl::Span

The header swapping of Chromium crypto libraries is
problematic, but absl::Span will convert to base::span
so there's no need for the typedef even without
removing the header swapping yet.

--
df1135d by danakj <danakj@chromium.org>:

Add missing files

--
ab18a15 by danakj <danakj@chromium.org>:

Remove the random_unittest.cc from Swift build

The file moved, so the Swift package needs its path
updated.

--
2038f78 by danakj <danakj@chromium.org>:

Combine crypto unittests into crypto_test.cc

--
f7ad176 by danakj <danakj@chromium.org>:

Add stdint and stddef includes for uint8_t and size_t

--
9f04590 by danakj <danakj@chromium.org>:

Mark the shared crypto implementation compatable_with non_prod

--
18eeafd by danakj <danakj@chromium.org>:

Add IWYU pragma for crypto implementation

PiperOrigin-RevId: 632150866

Package.swift

@@ -187,7 +187,9 @@ let package = Package(
       dependencies: [
         "protobuf",
         .product(name: "AbseilCXX17", package: "abseil-cpp-SwiftPM"),
-        .product(name: "openssl_grpc", package: "boringssl-SwiftPM", moduleAliases: ["NearbySSL": "openssl_grpc"]),
+        .product(
+          name: "openssl_grpc", package: "boringssl-SwiftPM",
+          moduleAliases: ["NearbySSL": "openssl_grpc"]),
       ],
       path: "third_party/ukey2",
       exclude: [
@@ -495,7 +497,6 @@ let package = Package(
         "internal/crypto_cros/ec_signature_creator_unittest.cc",
         "internal/crypto_cros/encryptor_unittest.cc",
         "internal/crypto_cros/hmac_unittest.cc",
-        "internal/crypto_cros/random_unittest.cc",
         "internal/crypto_cros/rsa_private_key_unittest.cc",
         "internal/crypto_cros/secure_hash_unittest.cc",
         "internal/crypto_cros/sha2_unittest.cc",

connections/v3/BUILD

@@ -35,10 +35,10 @@ cc_library(
     deps = [
         "//connections:core_types",
         "//connections/implementation/proto:offline_wire_formats_cc_proto",
-        "//internal/crypto_cros",
         "//internal/interop:authentication_status",
         "//internal/interop:device",
         "//internal/platform:connection_info",
+        "//internal/platform:types",
         "//proto:connections_enums_cc_proto",
         "@com_google_absl//absl/functional:any_invocable",
         "@com_google_absl//absl/strings",

connections/v3/connections_device.h

@@ -18,9 +18,9 @@
 #include <string>
 #include <vector>
 
-#include "internal/crypto_cros/random.h"
 #include "internal/interop/device.h"
 #include "internal/platform/connection_info.h"
+#include "internal/platform/crypto.h"
 
 namespace nearby {
 namespace connections {
@@ -59,8 +59,8 @@ class ConnectionsDevice : public nearby::NearbyDevice {
  private:
   std::string GenerateRandomEndpointId() {
     std::string result(kEndpointIdLength, 0);
-    crypto::RandBytes(const_cast<std::string::value_type*>(result.data()),
-                      result.size());
+    RandBytes(const_cast<std::string::value_type*>(result.data()),
+              result.size());
     return result;
   }
 

fastpair/common/account_key.h

@@ -22,7 +22,7 @@
 #include "absl/strings/escaping.h"
 #include "absl/strings/string_view.h"
 #include "fastpair/common/constant.h"
-#include "internal/crypto_cros/random.h"
+#include "internal/platform/crypto.h"
 
 namespace nearby {
 namespace fastpair {
@@ -37,7 +37,7 @@ class AccountKey {
 
   static AccountKey CreateRandomKey() {
     std::string key(kAccountKeySize, 0);
-    ::crypto::RandBytes(key.data(), kAccountKeySize);
+    RandBytes(key.data(), kAccountKeySize);
     return AccountKey(key);
   }
 

internal/crypto/BUILD

@@ -29,6 +29,7 @@ cc_library(
     ],
     deps = [
         "//internal/crypto_cros",
+        "//internal/platform:types",
         "@boringssl//:crypto",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
@@ -49,6 +50,7 @@ cc_test(
     ],
     deps = [
         ":crypto",
+        "//internal/platform/implementation/g3",  # fixdeps: keep
         "@com_github_protobuf_matchers//protobuf-matchers",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/types:span",

internal/crypto/ed25519.cc

@@ -22,7 +22,7 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
-#include "internal/crypto_cros/random.h"
+#include "internal/platform/crypto.h"
 #include <openssl/base.h>
 #include <openssl/evp.h>
 
@@ -98,7 +98,7 @@ absl::StatusOr<Ed25519KeyPair> Ed25519Signer::CreateNewKeyPair(
 
 absl::StatusOr<Ed25519KeyPair> Ed25519Signer::CreateNewKeyPair() {
   uint8_t key_seed[kEd25519KeySeedSize] = {0};
-  RandBytes(key_seed, kEd25519KeySeedSize);
+  nearby::RandBytes(key_seed, kEd25519KeySeedSize);
   return CreateNewKeyPair(
       std::string(reinterpret_cast<char *>(key_seed), kEd25519KeySeedSize));
 }

internal/crypto_cros/BUILD

@@ -39,7 +39,6 @@ cc_library(
         "hmac.cc",
         "nearby_base.cc",
         "openssl_util.cc",
-        "random.cc",
         "rsa_private_key.cc",
         "secure_hash.cc",
         "secure_util.cc",
@@ -58,7 +57,6 @@ cc_library(
         "hmac.h",
         "nearby_base.h",
         "openssl_util.h",
-        "random.h",
         "rsa_private_key.h",
         "secure_hash.h",
         "secure_util.h",
@@ -93,7 +91,6 @@ cc_test(
         "ec_signature_creator_unittest.cc",
         "encryptor_unittest.cc",
         "hmac_unittest.cc",
-        "random_unittest.cc",
         "rsa_private_key_unittest.cc",
         "secure_hash_unittest.cc",
         "sha2_unittest.cc",

internal/crypto_cros/random.h

@@ -1,42 +0,0 @@
-// Copyright 2020 Google LLC
-//
-// 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.
-
-//*** WARNING!!! Do not add more functions and Data types to this file. ***
-// This file needs to be in sync with:
-// https://source.chromium.org/chromium/chromium/src/+/main:crypto/random.h
-
-#ifndef THIRD_PARTY_NEARBY_INTERNAL_CRYPTO_RANDOM_H_
-#define THIRD_PARTY_NEARBY_INTERNAL_CRYPTO_RANDOM_H_
-
-#include <stddef.h>
-
-#include <cstdint>
-#include <string>
-
-#include "absl/types/span.h"
-#include "internal/crypto_cros/crypto_export.h"
-
-namespace crypto {
-
-// Fills the given buffer with |length| random bytes of cryptographically
-// secure random numbers.
-// |length| must be positive.
-CRYPTO_EXPORT void RandBytes(void *bytes, size_t length);
-
-// Fills |bytes| with cryptographically-secure random bits.
-CRYPTO_EXPORT void RandBytes(absl::Span<uint8_t> bytes);
-
-}  // namespace crypto
-
-#endif  // THIRD_PARTY_NEARBY_INTERNAL_CRYPTO_RANDOM_H_

internal/crypto_cros/random_unittest.cc

@@ -1,68 +0,0 @@
-// Copyright 2020 Google LLC
-//
-// 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 "internal/crypto_cros/random.h"
-
-#include <stddef.h>
-
-#include <string>
-
-#include "gtest/gtest.h"
-#include "internal/crypto_cros/nearby_base.h"
-#include "internal/platform/implementation/crypto.h"
-
-// Basic functionality tests. Does NOT test the security of the random data.
-
-namespace crypto {
-namespace {
-
-// Ensures we don't have all trivial data, i.e. that the data is indeed random.
-// Currently, that means the bytes cannot be all the same (e.g. all zeros).
-bool IsTrivial(const std::string& bytes) {
-  for (size_t i = 0; i < bytes.size(); i++) {
-    if (bytes[i] != bytes[0]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-TEST(RandBytes, RandBytes) {
-  std::string bytes(16, '\0');
-  RandBytes(nearbybase::WriteInto(&bytes, bytes.size()), bytes.size());
-  EXPECT_TRUE(!IsTrivial(bytes));
-}
-
-TEST(RandBytes, RandomString) {
-  constexpr size_t kSize = 30;
-
-  std::string bytes(kSize, 0);
-  RandBytes(const_cast<std::string::value_type*>(bytes.data()), bytes.size());
-
-  EXPECT_EQ(bytes.size(), kSize);
-  EXPECT_TRUE(!IsTrivial(bytes));
-}
-
-TEST(RandBytes, RandData) {
-  uint64_t x = nearby::RandData<uint64_t>();
-  uint64_t y = nearby::RandData<uint64_t>();
-
-  // Once in a billion years, consecutively generated random numbers will be
-  // the same and the test will fail.
-  EXPECT_NE(x, y);
-  EXPECT_NE(x >> 32, x & 0xFFFFFFFF);
-}
-
-}  // namespace
-}  // namespace crypto

internal/platform/BUILD

@@ -328,6 +328,7 @@ cc_library(
         "//internal/auth:__subpackages__",
         "//internal/auth/credential_store:__subpackages__",
         "//internal/base:__subpackages__",
+        "//internal/crypto:__subpackages__",
         "//internal/data:__subpackages__",
         "//internal/flags:__subpackages__",
         "//internal/interop:__pkg__",
@@ -360,6 +361,7 @@ cc_library(
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/synchronization",
         "@com_google_absl//absl/time",
+        "@com_google_absl//absl/types:span",
     ],
 )
 
@@ -467,6 +469,7 @@ cc_test(
         ":test_util",
         ":types",
         ":uuid",
+        "//internal/crypto_cros",
         "//internal/platform/implementation:comm",
         "//internal/platform/implementation/g3",  # build_cleaner: keep
         "//internal/proto:credential_cc_proto",

internal/platform/crypto.h

@@ -15,6 +15,6 @@
 #ifndef PLATFORM_PUBLIC_CRYPTO_H_
 #define PLATFORM_PUBLIC_CRYPTO_H_
 
-#include "internal/platform/implementation/crypto.h"
+#include "internal/platform/implementation/crypto.h"  // IWYU pragma: export
 
 #endif  // PLATFORM_PUBLIC_CRYPTO_H_

internal/platform/crypto_test.cc

@@ -14,12 +14,29 @@
 
 #include "internal/platform/crypto.h"
 
+#include <stddef.h>
+
+#include <cstdint>
+#include <string>
+
 #include "gmock/gmock.h"
 #include "protobuf-matchers/protocol-buffer-matchers.h"
 #include "gtest/gtest.h"
+#include "internal/crypto_cros/nearby_base.h"
 #include "internal/platform/byte_array.h"
 
 namespace nearby {
+namespace {
+// Ensures we don't have all trivial data, i.e. that the data is indeed random.
+// Currently, that means the bytes cannot be all the same (e.g. all zeros).
+bool IsTrivial(const std::string& bytes) {
+  for (size_t i = 0; i < bytes.size(); i++) {
+    if (bytes[i] != bytes[0]) {
+      return false;
+    }
+  }
+  return true;
+}
 
 TEST(CryptoTest, Md5GeneratesHash) {
   const ByteArray expected_md5(
@@ -44,4 +61,33 @@ TEST(CryptoTest, Sha256ReturnsEmptyOnError) {
   EXPECT_EQ(Crypto::Sha256(""), ByteArray{});
 }
 
+// Basic functionality tests. Does NOT test the security of the random data.
+
+TEST(CryptoTest, RandBytes) {
+  std::string bytes(16, '\0');
+  RandBytes(nearbybase::WriteInto(&bytes, bytes.size()), bytes.size());
+  EXPECT_TRUE(!IsTrivial(bytes));
+}
+
+TEST(CryptoTest, RandomString) {
+  constexpr size_t kSize = 30;
+
+  std::string bytes(kSize, 0);
+  RandBytes(const_cast<std::string::value_type*>(bytes.data()), bytes.size());
+
+  EXPECT_EQ(bytes.size(), kSize);
+  EXPECT_TRUE(!IsTrivial(bytes));
+}
+
+TEST(CryptoTest, RandData) {
+  uint64_t x = nearby::RandData<uint64_t>();
+  uint64_t y = nearby::RandData<uint64_t>();
+
+  // Once in a billion years, consecutively generated random numbers will be
+  // the same and the test will fail.
+  EXPECT_NE(x, y);
+  EXPECT_NE(x >> 32, x & 0xFFFFFFFF);
+}
+
+}  // namespace
 }  // namespace nearby

internal/platform/implementation/BUILD

@@ -75,6 +75,7 @@ cc_library(
     deps = [
         "//internal/crypto_cros",
         "//internal/platform:base",
+        "//internal/platform/implementation/shared:crypto",  # Non-chromium impl
         "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/functional:any_invocable",
         "@com_google_absl//absl/strings",

internal/platform/implementation/crypto.h

@@ -15,12 +15,11 @@
 #ifndef PLATFORM_API_CRYPTO_H_
 #define PLATFORM_API_CRYPTO_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "absl/strings/string_view.h"
-#ifdef NEARBY_CHROMIUM
-#include "crypto/random.h"
-#else
-#include "internal/crypto_cros/random.h"
-#endif
+#include "absl/types/span.h"
 #include "internal/platform/byte_array.h"
 
 namespace nearby {
@@ -36,12 +35,23 @@ class Crypto {
   static ByteArray Sha256(absl::string_view input);
 };
 
+// Fills the given buffer with |length| random bytes of cryptographically
+// secure random numbers.
+// |length| must be positive.
+//
+// TODO(crbug.com/40284755): Convert all callers in Nearby to use spans
+// and remove this RandBytes overload.
+void RandBytes(void *bytes, size_t length);
+
+// Fills |bytes| with cryptographically-secure random bits.
+void RandBytes(absl::Span<uint8_t> bytes);
+
 // Creates an object of type T initialized with random data.
 // This template should be used for simple data types: int, char, etc.
 template <typename T>
 T RandData() {
   T data;
-  ::crypto::RandBytes(&data, sizeof(data));
+  RandBytes(&data, sizeof(data));
   return data;
 }
 

internal/platform/implementation/g3/BUILD

@@ -141,6 +141,7 @@ cc_library(
         "//fastpair:__subpackages__",
         "//internal/account:__subpackages__",
         "//internal/auth:__subpackages__",
+        "//internal/crypto:__subpackages__",
         "//internal/data:__subpackages__",
         "//internal/flags:__subpackages__",
         "//internal/interop:__subpackages__",

internal/platform/implementation/shared/BUILD

@@ -13,6 +13,18 @@
 # limitations under the License.
 licenses(["notice"])
 
+cc_library(
+    name = "crypto",
+    srcs = [
+        "crypto.cc",
+    ],
+    visibility = ["//internal/platform/implementation:__subpackages__"],
+    deps = [
+        "@boringssl//:crypto",
+        "@com_google_absl//absl/types:span",
+    ],
+)
+
 cc_library(
     name = "posix_mutex",
     srcs = [

internal/platform/implementation/shared/crypto.cc

@@ -1,4 +1,4 @@
-// Copyright 2020 Google LLC
+// Copyright 2024 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,22 +12,20 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "internal/crypto_cros/random.h"
-
 #include <stddef.h>
+#include <stdint.h>
 
-#include <string>
-
+#include "absl/types/span.h"
 #include <openssl/rand.h>
 
-namespace crypto {
+namespace nearby {
 
-void RandBytes(void *bytes, size_t length) {
-  RAND_bytes(reinterpret_cast<uint8_t *>(bytes), length);
+void RandBytes(void* bytes, size_t length) {
+  RAND_bytes(reinterpret_cast<uint8_t*>(bytes), length);
 }
 
 void RandBytes(absl::Span<uint8_t> bytes) {
-  RandBytes(bytes.data(), bytes.size());
+  RAND_bytes(bytes.data(), bytes.size());
 }
 
-}  // namespace crypto
+}  // namespace nearby

presence/data_types.h

@@ -59,15 +59,6 @@ struct BroadcastCallback {
   };
 };
 
-// Chromium uses its own crypto library instead of nearby/internal/crypto,
-// in which base::span is used instead of absl::Span. See b/276368162.
-#ifdef NEARBY_CHROMIUM
-template <typename T>
-using CryptoSpan = base::span<T>;
-#else
-template <typename T>
-using CryptoSpan = absl::Span<T>;
-#endif
 }  // namespace presence
 }  // namespace nearby
 

presence/implementation/BUILD

@@ -14,11 +14,10 @@
 
 licenses(["notice"])
 
-cc_library(
-    name = "internal",
+filegroup(
+    name = "presence_internal_common_srcs",
     srcs = [
         "action_factory.cc",
-        "advertisement_decoder_rust_impl.cc",
         "advertisement_factory.cc",
         "advertisement_filter.cc",
         "base_broadcast_request.cc",
@@ -29,10 +28,14 @@ cc_library(
         "scan_manager.cc",
         "service_controller_impl.cc",
     ],
-    hdrs = [
+)
+
+filegroup(
+    name = "presence_internal_common_hdrs",
+    srcs = [
         "action_factory.h",
         "advertisement_decoder.h",
-        "advertisement_decoder_rust_impl.h",
+        "advertisement_decoder_impl.h",
         "advertisement_factory.h",
         "advertisement_filter.h",
         "base_broadcast_request.h",
@@ -46,6 +49,18 @@ cc_library(
         "service_controller.h",
         "service_controller_impl.h",
     ],
+)
+
+cc_library(
+    name = "internal",
+    srcs = [
+        "advertisement_decoder_rust_impl.cc",
+        ":presence_internal_common_srcs",
+    ],
+    hdrs = [
+        "advertisement_decoder_rust_impl.h",
+        ":presence_internal_common_hdrs",
+    ],
     defines = ["USE_RUST_DECODER=1"],
     visibility = [
         "//presence:__subpackages__",
@@ -82,6 +97,7 @@ cc_library(
         "@com_google_absl//absl/synchronization",
         "@com_google_absl//absl/time",
         "@com_google_absl//absl/types:optional",
+        "@com_google_absl//absl/types:span",
         "@com_google_absl//absl/types:variant",
     ],
 )
@@ -89,34 +105,12 @@ cc_library(
 cc_library(
     name = "internal_deprecated",
     srcs = [
-        "action_factory.cc",
         "advertisement_decoder_impl.cc",
-        "advertisement_factory.cc",
-        "advertisement_filter.cc",
-        "base_broadcast_request.cc",
-        "broadcast_manager.cc",
-        "connection_authenticator_impl.cc",
-        "credential_manager_impl.cc",
-        "ldt.cc",
-        "scan_manager.cc",
-        "service_controller_impl.cc",
+        ":presence_internal_common_srcs",
     ],
     hdrs = [
-        "action_factory.h",
-        "advertisement_decoder.h",
         "advertisement_decoder_impl.h",
-        "advertisement_factory.h",
-        "advertisement_filter.h",
-        "base_broadcast_request.h",
-        "broadcast_manager.h",
-        "connection_authenticator.h",
-        "connection_authenticator_impl.h",
-        "credential_manager.h",
-        "credential_manager_impl.h",
-        "ldt.h",
-        "scan_manager.h",
-        "service_controller.h",
-        "service_controller_impl.h",
+        ":presence_internal_common_hdrs",
     ],
     visibility = [
         "//presence:__subpackages__",
@@ -152,6 +146,7 @@ cc_library(
         "@com_google_absl//absl/synchronization",
         "@com_google_absl//absl/time",
         "@com_google_absl//absl/types:optional",
+        "@com_google_absl//absl/types:span",
         "@com_google_absl//absl/types:variant",
     ],
 )

presence/implementation/base_broadcast_request.cc

@@ -74,8 +74,7 @@ BasePresenceRequestBuilder::operator BaseBroadcastRequest() const {
       .action = action_};
 
   std::string bytes(kSaltSize, 0);
-  crypto::RandBytes(const_cast<std::string::value_type*>(bytes.data()),
-                    bytes.size());
+  RandBytes(const_cast<std::string::value_type*>(bytes.data()), bytes.size());
 
   BaseBroadcastRequest broadcast_request{
       .variant = presence,

presence/implementation/credential_manager_impl.cc

@@ -27,6 +27,7 @@
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
+#include "absl/types/span.h"
 #include "absl/types/variant.h"
 #include "internal/platform/byte_array.h"
 #include "internal/platform/count_down_latch.h"
@@ -34,14 +35,13 @@
 #include "crypto/aead.h"
 #include "crypto/ec_private_key.h"
 #include "crypto/hkdf.h"
-#include "crypto/random.h"
 #else
 #include "internal/crypto_cros/aead.h"
 #include "internal/crypto_cros/ec_private_key.h"
 #include "internal/crypto_cros/hkdf.h"
-#include "internal/crypto_cros/random.h"
 #endif
 #include "internal/platform/base64_utils.h"
+#include "internal/platform/crypto.h"
 #include "internal/platform/future.h"
 #include "internal/platform/implementation/credential_callbacks.h"
 #include "internal/platform/implementation/crypto.h"
@@ -214,8 +214,8 @@ CredentialManagerImpl::CreateLocalCredential(
 
   // Creates an AES key to encrypt the whole broadcast.
   std::string secret_key(kAuthenticityKeyByteSize, 0);
-  crypto::RandBytes(const_cast<std::string::value_type*>(secret_key.data()),
-                    secret_key.size());
+  RandBytes(const_cast<std::string::value_type*>(secret_key.data()),
+            secret_key.size());
   private_credential.set_key_seed(secret_key);
 
   // Uses SHA-256 algorithm to generate the credential ID from the
@@ -238,8 +238,8 @@ CredentialManagerImpl::CreateLocalCredential(
       std::string(private_key.begin(), private_key.end()));
   // Create an AES key to encrypt the device identity metadata.
   std::string metadata_key(kBaseMetadataSize, 0);
-  crypto::RandBytes(const_cast<std::string::value_type*>(metadata_key.data()),
-                    metadata_key.size());
+  RandBytes(const_cast<std::string::value_type*>(metadata_key.data()),
+            metadata_key.size());
   private_credential.set_metadata_encryption_key_v0(metadata_key);
 
   // Generate the public credential
@@ -315,7 +315,7 @@ std::string CredentialManagerImpl::DecryptDeviceIdentityMetaData(
   auto result = aead.Open(encrypted_metadata_bytes,
                           /*nonce=*/
                           iv_bytes,
-                          /*additional_data=*/CryptoSpan<uint8_t>());
+                          /*additional_data=*/absl::Span<uint8_t>());
 
   return std::string(result.value().begin(), result.value().end());
 }
@@ -340,7 +340,7 @@ std::string CredentialManagerImpl::EncryptDeviceIdentityMetaData(
   auto encrypted = aead.Seal(metadata_bytes,
                              /*nonce=*/
                              iv_bytes,
-                             /*additional_data=*/CryptoSpan<uint8_t>());
+                             /*additional_data=*/absl::Span<uint8_t>());
 
   return std::string(encrypted.begin(), encrypted.end());
 }
@@ -350,8 +350,8 @@ std::vector<uint8_t> CredentialManagerImpl::ExtendMetadataEncryptionKey(
   return crypto::HkdfSha256(
       std::vector<uint8_t>(metadata_encryption_key.begin(),
                            metadata_encryption_key.end()),
-      /*salt=*/CryptoSpan<uint8_t>(),
-      /*info=*/CryptoSpan<uint8_t>(), kNearbyPresenceNumBytesAesGcmKeySize);
+      /*salt=*/absl::Span<uint8_t>(),
+      /*info=*/absl::Span<uint8_t>(), kNearbyPresenceNumBytesAesGcmKeySize);
 }
 
 void CredentialManagerImpl::GetLocalCredentials(

sharing/BUILD

@@ -21,6 +21,7 @@ cc_library(
         "//internal/base:files",
         "//internal/crypto_cros",
         "//internal/interop:authentication_status",
+        "//internal/platform:types",
         "//sharing/common:compatible_u8_string",
         "@com_google_absl//absl/strings:string_view",
         "@com_google_absl//absl/time",
@@ -59,6 +60,7 @@ cc_library(
         ":connection_types",
         "//internal/crypto_cros",
         "//internal/network:url",
+        "//internal/platform:types",
         "//sharing/common:compatible_u8_string",
         "//sharing/common:enum",
         "//sharing/internal/base",
@@ -255,7 +257,14 @@ cc_test(
         ":connection_types",
         "@com_github_protobuf_matchers//protobuf-matchers",
         "@com_google_googletest//:gtest_main",
-    ],
+    ] + select({
+        "@platforms//os:windows": [
+            "//internal/platform/implementation/windows",
+        ],
+        "//conditions:default": [
+            "//internal/platform/implementation/g3",
+        ],
+    }),
 )
 
 cc_test(

sharing/attachment.cc

@@ -16,7 +16,7 @@
 
 #include <stdint.h>
 
-#include "internal/crypto_cros/random.h"
+#include "internal/platform/crypto.h"
 
 namespace nearby {
 namespace sharing {
@@ -24,7 +24,7 @@ namespace {
 
 int64_t CreateRandomId() {
   int64_t id;
-  crypto::RandBytes(&id, sizeof(id));
+  RandBytes(&id, sizeof(id));
   return id;
 }
 

sharing/certificates/common.cc

@@ -27,8 +27,8 @@
 #include "absl/types/span.h"
 #include "internal/crypto_cros/encryptor.h"
 #include "internal/crypto_cros/hkdf.h"
-#include "internal/crypto_cros/random.h"
 #include "internal/crypto_cros/symmetric_key.h"
+#include "internal/platform/crypto.h"
 #include "sharing/certificates/constants.h"
 #include "sharing/internal/public/logging.h"
 
@@ -77,7 +77,7 @@ std::vector<uint8_t> ComputeAuthenticationTokenHash(
 
 std::vector<uint8_t> GenerateRandomBytes(size_t num_bytes) {
   std::vector<uint8_t> bytes(num_bytes);
-  crypto::RandBytes(absl::Span<uint8_t>(bytes));
+  RandBytes(absl::Span<uint8_t>(bytes));
   return bytes;
 }
 

sharing/nearby_connections_types.h

@@ -27,8 +27,8 @@
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
 #include "internal/base/files.h"
-#include "internal/crypto_cros/random.h"
 #include "internal/interop/authentication_status.h"
+#include "internal/platform/crypto.h"
 #include "sharing/common/compatible_u8_string.h"
 
 namespace nearby {
@@ -472,7 +472,7 @@ struct Payload {
 
   int64_t GenerateId() {
     int64_t id;
-    crypto::RandBytes(&id, sizeof(id));
+    RandBytes(&id, sizeof(id));
     return id;
   }
 };