Refactor TLS trust anchors to use TrustAnchorProvider in Rust and C++

Replaces static trust anchor path/DER configuration fields with a
dynamic TrustAnchorProvider interface across both Rust and C++ Oak
Session TLS libraries. This allows dynamic and per-session trust anchor
resolution.

- Added TrustAnchorProvider interface.
- Updated ServerContextConfig and ClientContextConfig to take a
  provider.
- In C++, removed early SSL_CTX_load_verify_locations path loading, and
  instead fetched the trust anchor from the provider per session,
  adding it dynamically via SSL_set1_verify_cert_store.
- Updated test suites to use static or file-based provider
  implementations.
- Refactored example gRPC clients to match the new API.

Change-Id: I3a96418d5da0a3c3e3feb1997e34afa56a6a6964

Author: jblebrun

oak_private_memory/test/tls_client_test.rs

@@ -68,7 +68,7 @@ fn test_server_context() -> OakSessionTlsServerContext {
 
     OakSessionTlsServerContext::create(ServerContextConfig {
         tls_identity_provider: utils::create_static_cert_identity_provider(server_key, server_cert),
-        client_trust_anchor_der: Some(ca_cert),
+        client_trust_anchor_provider: Some(utils::create_static_trust_anchor_provider(ca_cert)),
         custom_cert_verifier: None,
     })
     .expect("failed to create TLS server context")
@@ -80,7 +80,7 @@ fn test_client_context() -> OakSessionTlsClientContext {
     let client_key = load_test_key("oak_session/tls/testing/test_client.key");
 
     OakSessionTlsClientContext::create(ClientContextConfig {
-        server_trust_anchor_der: Some(ca_cert),
+        server_trust_anchor_provider: Some(utils::create_static_trust_anchor_provider(ca_cert)),
         tls_identity_provider: Some(utils::create_static_cert_identity_provider(
             client_key,
             client_cert,

oak_session/tls/example/grpc/client_main.cc

@@ -68,9 +68,15 @@ void RunClient() {
     TlsIdentity current_identity_;
   };
 
+  auto trust_anchor =
+      util::CreateTrustAnchorFromFile(absl::GetFlag(FLAGS_ca_cert));
+  if (!trust_anchor.ok()) {
+    LOG(FATAL) << "Failed to load trust anchor: " << trust_anchor.status();
+  }
+
   absl::StatusOr<std::unique_ptr<OakSessionTlsContext>> tls_context =
       OakSessionTlsContext::Create(ClientContextConfig{
-          .server_trust_anchor_path = absl::GetFlag(FLAGS_ca_cert),
+          .server_trust_anchor_provider = std::move(*trust_anchor),
           .tls_identity_provider = std::make_unique<StaticIdentityProvider>(
               *client_key_asn1, *client_cert_asn1),
       });

oak_session/tls/oak_session_tls.cc

@@ -109,28 +109,21 @@ OakSessionTlsContext::Create(ServerContextConfig config) {
                                      SSL_GROUP_X25519};
   SSL_CTX_set1_group_ids(ctx.get(), kGroups, std::size(kGroups));
 
-  if (config.client_trust_anchor_path.has_value() ||
+  if (config.client_trust_anchor_provider != nullptr ||
       config.custom_cert_verifier.has_value()) {
     SSL_CTX_set_verify(
         ctx.get(), SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, nullptr);
 
     if (config.custom_cert_verifier.has_value()) {
       SSL_CTX_set_cert_verify_callback(ctx.get(), VerifyCallback, nullptr);
     }
-
-    if (config.client_trust_anchor_path.has_value()) {
-      if (SSL_CTX_load_verify_locations(
-              ctx.get(), config.client_trust_anchor_path->c_str(), nullptr) !=
-          1) {
-        return absl::InternalError("Failed to load trust anchor for client");
-      }
-    }
   }
 
   return std::make_unique<OakSessionTlsContext>(
       OakSessionTlsMode::kServer, std::move(ctx),
       std::move(config.tls_identity_provider),
-      std::move(config.custom_cert_verifier));
+      std::move(config.client_trust_anchor_provider),
+      std::move(config.custom_cert_verifier), "");
 }
 
 absl::StatusOr<std::unique_ptr<OakSessionTlsContext>>
@@ -149,17 +142,9 @@ OakSessionTlsContext::Create(ClientContextConfig config) {
                                      SSL_GROUP_X25519};
   SSL_CTX_set1_group_ids(ctx.get(), kGroups, std::size(kGroups));
 
-  if (config.server_trust_anchor_path.has_value()) {
-    if (SSL_CTX_load_verify_locations(ctx.get(),
-                                      config.server_trust_anchor_path->c_str(),
-                                      nullptr) != 1) {
-      return absl::InternalError("Failed to load trust anchor for server");
-    }
-  }
-
   // Enable server certificate verification if either a trust anchor or custom
   // verifier is configured.
-  if (config.server_trust_anchor_path.has_value() ||
+  if (config.server_trust_anchor_provider != nullptr ||
       config.custom_cert_verifier.has_value()) {
     SSL_CTX_set_verify(ctx.get(), SSL_VERIFY_PEER, nullptr);
   }
@@ -174,6 +159,7 @@ OakSessionTlsContext::Create(ClientContextConfig config) {
   return std::make_unique<OakSessionTlsContext>(
       OakSessionTlsMode::kClient, std::move(ctx),
       std::move(config.tls_identity_provider),
+      std::move(config.server_trust_anchor_provider),
       std::move(config.custom_cert_verifier), std::move(expected_server_name));
 }
 
@@ -190,15 +176,26 @@ OakSessionTlsContext::NewSession() {
     identity_ptr = &*identity;
   }
 
+  std::optional<std::string> trust_anchor;
+  const std::string* trust_anchor_ptr = nullptr;
+  if (trust_anchor_provider_ != nullptr) {
+    auto anchor_or = trust_anchor_provider_->GetTrustAnchor();
+    if (!anchor_or.ok()) {
+      return anchor_or.status();
+    }
+    trust_anchor = std::move(*anchor_or);
+    trust_anchor_ptr = &*trust_anchor;
+  }
+
   switch (mode_) {
     case OakSessionTlsMode::kClient:
       return OakSessionTlsInitializer::CreateClient(
-          ssl_ctx_.get(), expected_server_name_, identity_ptr,
+          ssl_ctx_.get(), expected_server_name_, identity_ptr, trust_anchor_ptr,
           custom_cert_verifier_.has_value() ? &*custom_cert_verifier_
                                             : nullptr);
     case OakSessionTlsMode::kServer:
       return OakSessionTlsInitializer::CreateServer(
-          ssl_ctx_.get(), identity_ptr,
+          ssl_ctx_.get(), identity_ptr, trust_anchor_ptr,
           custom_cert_verifier_.has_value() ? &*custom_cert_verifier_
                                             : nullptr);
   }
@@ -265,6 +262,7 @@ absl::StatusOr<InitializedSession> OakSessionTlsContext::NewInitializedSession(
 absl::StatusOr<std::unique_ptr<OakSessionTlsInitializer>>
 OakSessionTlsInitializer::Create(
     SSL_CTX* ssl_ctx, const TlsIdentity* tls_identity,
+    const std::string* trust_anchor,
     const CustomCertVerifier* custom_cert_verifier) {
   auto ssl = bssl::UniquePtr<SSL>(SSL_new(ssl_ctx));
   if (!ssl) {
@@ -279,6 +277,27 @@ OakSessionTlsInitializer::Create(
     }
   }
 
+  if (trust_anchor != nullptr) {
+    const uint8_t* ptr = reinterpret_cast<const uint8_t*>(trust_anchor->data());
+    X509* cert = d2i_X509(nullptr, &ptr, trust_anchor->size());
+    if (cert == nullptr) {
+      return absl::InternalError("failed to parse trust anchor certificate");
+    }
+    X509_STORE* store = X509_STORE_new();
+    if (store == nullptr) {
+      X509_free(cert);
+      return absl::InternalError("failed to create certificate store");
+    }
+    if (X509_STORE_add_cert(store, cert) != 1) {
+      X509_free(cert);
+      X509_STORE_free(store);
+      return absl::InternalError("failed to add certificate to store");
+    }
+    X509_free(cert);
+    SSL_set1_verify_cert_store(ssl.get(), store);
+    X509_STORE_free(store);
+  }
+
   // Enable the BIO API for this SSL instance.
   BIO* rbio = BIO_new(BIO_s_mem());
   if (rbio == nullptr) {
@@ -314,10 +333,10 @@ OakSessionTlsInitializer::Create(
 absl::StatusOr<std::unique_ptr<OakSessionTlsInitializer>>
 OakSessionTlsInitializer::CreateClient(
     SSL_CTX* ssl_ctx, const std::string& expected_server_name,
-    const TlsIdentity* tls_identity,
+    const TlsIdentity* tls_identity, const std::string* trust_anchor,
     const CustomCertVerifier* custom_cert_verifier) {
   absl::StatusOr<std::unique_ptr<OakSessionTlsInitializer>> initializer =
-      OakSessionTlsInitializer::Create(ssl_ctx, tls_identity,
+      OakSessionTlsInitializer::Create(ssl_ctx, tls_identity, trust_anchor,
                                        custom_cert_verifier);
   if (!initializer.ok()) {
     return initializer.status();
@@ -358,9 +377,10 @@ OakSessionTlsInitializer::CreateClient(
 absl::StatusOr<std::unique_ptr<OakSessionTlsInitializer>>
 OakSessionTlsInitializer::CreateServer(
     SSL_CTX* ssl_ctx, const TlsIdentity* tls_identity,
+    const std::string* trust_anchor,
     const CustomCertVerifier* custom_cert_verifier) {
   absl::StatusOr<std::unique_ptr<OakSessionTlsInitializer>> initializer =
-      OakSessionTlsInitializer::Create(ssl_ctx, tls_identity,
+      OakSessionTlsInitializer::Create(ssl_ctx, tls_identity, trust_anchor,
                                        custom_cert_verifier);
   if (!initializer.ok()) {
     return initializer.status();

oak_session/tls/oak_session_tls.h

@@ -92,16 +92,25 @@ class TlsIdentityProvider {
   virtual absl::StatusOr<TlsIdentity> GetIdentity() = 0;
 };
 
+// Provider interface that returns a trust anchor certificate (DER-encoded).
+// Called each time a new session is created on the context.
+class TrustAnchorProvider {
+ public:
+  virtual ~TrustAnchorProvider() = default;
+  virtual absl::StatusOr<std::string> GetTrustAnchor() = 0;
+};
+
+
 // Parameters to configure OakSessionTlsContext for server behavior.
 struct ServerContextConfig {
   // Provider that returns the key and certificate for this server.
   // Called each time a new session is created.
   std::unique_ptr<TlsIdentityProvider> tls_identity_provider;
 
-  // Optional trust anchor path for the client.
+  // Optional trust anchor provider for the client.
   // If set, client verification mode will be enabled, and client verification
   // will be required.
-  std::optional<std::string> client_trust_anchor_path;
+  std::unique_ptr<TrustAnchorProvider> client_trust_anchor_provider;
 
   // Optional custom certificate verifier. If provided, it will be called with
   // the result of standard verification, allowing it to override failures or
@@ -111,10 +120,10 @@ struct ServerContextConfig {
 
 // Parameters to configure OakSessionTlsContext for client behavior.
 struct ClientContextConfig {
-  // Optional path to a trust anchor that can verify the server.
+  // Optional provider for a trust anchor that can verify the server.
   // If not set, standard PKI verification will not be configured and a
   // custom_cert_verifier must be provided to handle certificate validation.
-  std::optional<std::string> server_trust_anchor_path;
+  std::unique_ptr<TrustAnchorProvider> server_trust_anchor_provider;
 
   // If provided, called each time a new session is created to get the
   // client's TLS identity. Enables mTLS mode, allowing the server to
@@ -182,18 +191,21 @@ class OakSessionTlsContext {
   OakSessionTlsContext(
       OakSessionTlsMode mode, bssl::UniquePtr<SSL_CTX> ssl_ctx,
       std::unique_ptr<TlsIdentityProvider> tls_identity_provider,
+      std::unique_ptr<TrustAnchorProvider> trust_anchor_provider,
       std::optional<CustomCertVerifier> custom_cert_verifier,
-      std::string expected_server_name = std::string(kDefaultServerName))
+      std::string expected_server_name = "")
       : mode_(mode),
         ssl_ctx_(std::move(ssl_ctx)),
         tls_identity_provider_(std::move(tls_identity_provider)),
+        trust_anchor_provider_(std::move(trust_anchor_provider)),
         custom_cert_verifier_(std::move(custom_cert_verifier)),
         expected_server_name_(std::move(expected_server_name)) {}
 
  private:
   OakSessionTlsMode mode_;
   bssl::UniquePtr<SSL_CTX> ssl_ctx_;
   std::unique_ptr<TlsIdentityProvider> tls_identity_provider_;
+  std::unique_ptr<TrustAnchorProvider> trust_anchor_provider_;
   std::optional<CustomCertVerifier> custom_cert_verifier_;
   std::string expected_server_name_;
 };
@@ -215,11 +227,13 @@ class OakSessionTlsInitializer {
  public:
   static absl::StatusOr<std::unique_ptr<OakSessionTlsInitializer>> CreateServer(
       SSL_CTX* ssl_ctx, const TlsIdentity* tls_identity = nullptr,
+      const std::string* trust_anchor = nullptr,
       const CustomCertVerifier* custom_cert_verifier = nullptr);
 
   static absl::StatusOr<std::unique_ptr<OakSessionTlsInitializer>> CreateClient(
       SSL_CTX* ssl_ctx, const std::string& expected_server_name,
       const TlsIdentity* tls_identity = nullptr,
+      const std::string* trust_anchor = nullptr,
       const CustomCertVerifier* custom_cert_verifier = nullptr);
 
   // Returns true if the handshake is complete.
@@ -247,6 +261,7 @@ class OakSessionTlsInitializer {
  private:
   static absl::StatusOr<std::unique_ptr<OakSessionTlsInitializer>> Create(
       SSL_CTX* ssl_ctx, const TlsIdentity* tls_identity = nullptr,
+      const std::string* trust_anchor = nullptr,
       const CustomCertVerifier* custom_cert_verifier = nullptr);
   OakSessionTlsInitializer(bssl::UniquePtr<SSL> ssl, BIO* bio_read,
                            BIO* bio_write,