commit d1fc5910f5dbb3f4680057a29afc522c25fee0ec
author danzh <danzh@google.com> Fri May 01 15:29:04 2020 -0700
committer Copybara-Service <copybara-worker@google.com> Fri May 01 15:29:28 2020 -0700
tree b7ef58292d61876b85781bfc121709cf958a89b5
parent 778e6477bcde6611d4fc3e0467903bfe258124a0

gfe-relnote: add client address into Quic proof source/verifier interface. No behavior change as the client address remains unused in GFE. Not protected.

This is needed for Envoy as client address is need to retrieve certs in Envoy.

PiperOrigin-RevId: 309485174
Change-Id: I3962c648bf33e853205541689f6e14a0fec7fe2b

quic/test_tools/fake_proof_source.cc

diff --git a/quic/test_tools/fake_proof_source.cc b/quic/test_tools/fake_proof_source.cc
index 35c81d5..9619fad 100644
--- a/quic/test_tools/fake_proof_source.cc
+++ b/quic/test_tools/fake_proof_source.cc
@@ -22,6 +22,7 @@
 
 FakeProofSource::GetProofOp::GetProofOp(
     const QuicSocketAddress& server_addr,
+    const QuicSocketAddress& client_address,
     std::string hostname,
     std::string server_config,
     QuicTransportVersion transport_version,
@@ -29,6 +30,7 @@
     std::unique_ptr<ProofSource::Callback> callback,
     ProofSource* delegate)
     : server_address_(server_addr),
+      client_address_(client_address),
       hostname_(std::move(hostname)),
       server_config_(std::move(server_config)),
       transport_version_(transport_version),
@@ -40,18 +42,21 @@
 
 void FakeProofSource::GetProofOp::Run() {
   // Note: relies on the callback being invoked synchronously
-  delegate_->GetProof(server_address_, hostname_, server_config_,
-                      transport_version_, chlo_hash_, std::move(callback_));
+  delegate_->GetProof(server_address_, client_address_, hostname_,
+                      server_config_, transport_version_, chlo_hash_,
+                      std::move(callback_));
 }
 
 FakeProofSource::ComputeSignatureOp::ComputeSignatureOp(
     const QuicSocketAddress& server_address,
+    const QuicSocketAddress& client_address,
     std::string hostname,
     uint16_t sig_alg,
     quiche::QuicheStringPiece in,
     std::unique_ptr<ProofSource::SignatureCallback> callback,
     ProofSource* delegate)
     : server_address_(server_address),
+      client_address_(client_address),
       hostname_(std::move(hostname)),
       sig_alg_(sig_alg),
       in_(in),
@@ -61,8 +66,8 @@
 FakeProofSource::ComputeSignatureOp::~ComputeSignatureOp() = default;
 
 void FakeProofSource::ComputeSignatureOp::Run() {
-  delegate_->ComputeTlsSignature(server_address_, hostname_, sig_alg_, in_,
-                                 std::move(callback_));
+  delegate_->ComputeTlsSignature(server_address_, client_address_, hostname_,
+                                 sig_alg_, in_, std::move(callback_));
 }
 
 void FakeProofSource::Activate() {
@@ -71,30 +76,34 @@
 
 void FakeProofSource::GetProof(
     const QuicSocketAddress& server_address,
+    const QuicSocketAddress& client_address,
     const std::string& hostname,
     const std::string& server_config,
     QuicTransportVersion transport_version,
     quiche::QuicheStringPiece chlo_hash,
     std::unique_ptr<ProofSource::Callback> callback) {
   if (!active_) {
-    delegate_->GetProof(server_address, hostname, server_config,
+    delegate_->GetProof(server_address, client_address, hostname, server_config,
                         transport_version, chlo_hash, std::move(callback));
     return;
   }
 
   pending_ops_.push_back(std::make_unique<GetProofOp>(
-      server_address, hostname, server_config, transport_version,
-      std::string(chlo_hash), std::move(callback), delegate_.get()));
+      server_address, client_address, hostname, server_config,
+      transport_version, std::string(chlo_hash), std::move(callback),
+      delegate_.get()));
 }
 
 QuicReferenceCountedPointer<ProofSource::Chain> FakeProofSource::GetCertChain(
     const QuicSocketAddress& server_address,
+    const QuicSocketAddress& client_address,
     const std::string& hostname) {
-  return delegate_->GetCertChain(server_address, hostname);
+  return delegate_->GetCertChain(server_address, client_address, hostname);
 }
 
 void FakeProofSource::ComputeTlsSignature(
     const QuicSocketAddress& server_address,
+    const QuicSocketAddress& client_address,
     const std::string& hostname,
     uint16_t signature_algorithm,
     quiche::QuicheStringPiece in,
@@ -102,15 +111,16 @@
   QUIC_LOG(INFO) << "FakeProofSource::ComputeTlsSignature";
   if (!active_) {
     QUIC_LOG(INFO) << "Not active - directly calling delegate";
-    delegate_->ComputeTlsSignature(
-        server_address, hostname, signature_algorithm, in, std::move(callback));
+    delegate_->ComputeTlsSignature(server_address, client_address, hostname,
+                                   signature_algorithm, in,
+                                   std::move(callback));
     return;
   }
 
   QUIC_LOG(INFO) << "Adding pending op";
   pending_ops_.push_back(std::make_unique<ComputeSignatureOp>(
-      server_address, hostname, signature_algorithm, in, std::move(callback),
-      delegate_.get()));
+      server_address, client_address, hostname, signature_algorithm, in,
+      std::move(callback), delegate_.get()));
 }
 
 ProofSource::TicketCrypter* FakeProofSource::GetTicketCrypter() {