Elide headers in QuicHttp3Logger.

Use ElideSpdyHeaderBlockForNetLog() for SpdyHeaderBlock, fork it as
ElideQuicHeaderListForNetLog() for QuicHeaderList.

Bug: 1122684
Change-Id: I3f6abe810657bc5ae4655fd7d4fec60825eff38e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2380573Reviewed-by: Matt Menke <mmenke@chromium.org>
Commit-Queue: Bence Béky <bnc@chromium.org>
Auto-Submit: Bence Béky <bnc@chromium.org>
Cr-Commit-Position: refs/heads/master@{#802684}

net/quic/quic_http3_logger.cc

@@ -9,10 +9,13 @@
 #include <vector>
 
 #include "base/metrics/histogram_macros.h"
+#include "base/strings/strcat.h"
 #include "base/strings/string_number_conversions.h"
+#include "net/http/http_log_util.h"
 #include "net/log/net_log_capture_mode.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_values.h"
+#include "net/spdy/spdy_log_util.h"
 
 namespace net {
 
@@ -64,20 +67,19 @@ base::Value NetLogThreeIntParams(base::StringPiece name1,
   return dict;
 }
 
-base::Value NetLogHeadersToDict(const quic::QuicHeaderList& headers) {
-  base::Value dict(base::Value::Type::DICTIONARY);
-  for (auto header : headers) {
-    dict.SetStringKey(header.first, header.second);
-  }
-  return dict;
-}
-
-base::Value NetLogHeadersToDict(const spdy::SpdyHeaderBlock& headers) {
-  base::Value dict(base::Value::Type::DICTIONARY);
-  for (auto header : headers) {
-    dict.SetStringKey(header.first, header.second);
+base::ListValue ElideQuicHeaderListForNetLog(
+    const quic::QuicHeaderList& headers,
+    NetLogCaptureMode capture_mode) {
+  base::ListValue headers_list;
+  for (const auto& header : headers) {
+    base::StringPiece key = header.first;
+    base::StringPiece value = header.second;
+    headers_list.Append(NetLogStringValue(
+        base::StrCat({key, ": ",
+                      ElideHeaderValueForNetLog(capture_mode, key.as_string(),
+                                                value.as_string())})));
   }
-  return dict;
+  return headers_list;
 }
 
 }  // namespace
@@ -248,11 +250,13 @@ void QuicHttp3Logger::OnHeadersDecoded(quic::QuicStreamId stream_id,
     return;
   }
   net_log_.AddEvent(
-      NetLogEventType::HTTP3_HEADERS_DECODED, [stream_id, &headers] {
+      NetLogEventType::HTTP3_HEADERS_DECODED,
+      [stream_id, &headers](NetLogCaptureMode capture_mode) {
         base::Value dict(base::Value::Type::DICTIONARY);
         dict.SetKey("stream_id",
                     NetLogNumberValue(static_cast<uint64_t>(stream_id)));
-        dict.SetKey("headers", NetLogHeadersToDict(headers));
+        dict.SetKey("headers",
+                    ElideQuicHeaderListForNetLog(headers, capture_mode));
         return dict;
       });
 }
@@ -279,16 +283,18 @@ void QuicHttp3Logger::OnPushPromiseDecoded(quic::QuicStreamId stream_id,
   if (!net_log_.IsCapturing()) {
     return;
   }
-  net_log_.AddEvent(NetLogEventType::HTTP3_PUSH_PROMISE_DECODED, [stream_id,
-                                                                  push_id,
-                                                                  &headers] {
-    base::Value dict(base::Value::Type::DICTIONARY);
-    dict.SetKey("stream_id",
-                NetLogNumberValue(static_cast<uint64_t>(stream_id)));
-    dict.SetKey("push_id", NetLogNumberValue(static_cast<uint64_t>(push_id)));
-    dict.SetKey("headers", NetLogHeadersToDict(headers));
-    return dict;
-  });
+  net_log_.AddEvent(
+      NetLogEventType::HTTP3_PUSH_PROMISE_DECODED,
+      [stream_id, push_id, &headers](NetLogCaptureMode capture_mode) {
+        base::Value dict(base::Value::Type::DICTIONARY);
+        dict.SetKey("stream_id",
+                    NetLogNumberValue(static_cast<uint64_t>(stream_id)));
+        dict.SetKey("push_id",
+                    NetLogNumberValue(static_cast<uint64_t>(push_id)));
+        dict.SetKey("headers",
+                    ElideQuicHeaderListForNetLog(headers, capture_mode));
+        return dict;
+      });
 }
 
 void QuicHttp3Logger::OnUnknownFrameReceived(
@@ -364,11 +370,13 @@ void QuicHttp3Logger::OnHeadersFrameSent(
     return;
   }
   net_log_.AddEvent(
-      NetLogEventType::HTTP3_HEADERS_SENT, [stream_id, &header_block] {
+      NetLogEventType::HTTP3_HEADERS_SENT,
+      [stream_id, &header_block](NetLogCaptureMode capture_mode) {
         base::Value dict(base::Value::Type::DICTIONARY);
         dict.SetKey("stream_id",
                     NetLogNumberValue(static_cast<uint64_t>(stream_id)));
-        dict.SetKey("headers", NetLogHeadersToDict(header_block));
+        dict.SetKey("headers",
+                    ElideSpdyHeaderBlockForNetLog(header_block, capture_mode));
         return dict;
       });
 }
@@ -380,16 +388,18 @@ void QuicHttp3Logger::OnPushPromiseFrameSent(
   if (!net_log_.IsCapturing()) {
     return;
   }
-  net_log_.AddEvent(NetLogEventType::HTTP3_PUSH_PROMISE_SENT, [stream_id,
-                                                               push_id,
-                                                               &header_block] {
-    base::Value dict(base::Value::Type::DICTIONARY);
-    dict.SetKey("stream_id",
-                NetLogNumberValue(static_cast<uint64_t>(stream_id)));
-    dict.SetKey("push_id", NetLogNumberValue(static_cast<uint64_t>(push_id)));
-    dict.SetKey("headers", NetLogHeadersToDict(header_block));
-    return dict;
-  });
+  net_log_.AddEvent(
+      NetLogEventType::HTTP3_PUSH_PROMISE_SENT,
+      [stream_id, push_id, &header_block](NetLogCaptureMode capture_mode) {
+        base::Value dict(base::Value::Type::DICTIONARY);
+        dict.SetKey("stream_id",
+                    NetLogNumberValue(static_cast<uint64_t>(stream_id)));
+        dict.SetKey("push_id",
+                    NetLogNumberValue(static_cast<uint64_t>(push_id)));
+        dict.SetKey("headers",
+                    ElideSpdyHeaderBlockForNetLog(header_block, capture_mode));
+        return dict;
+      });
 }
 
 }  // namespace net

net/quic/quic_http_stream_test.cc

@@ -940,6 +940,114 @@ TEST_P(QuicHttpStreamTest, GetRequestWithTrailers) {
       NetLogEventPhase::NONE);
 }
 
+TEST_P(QuicHttpStreamTest, ElideHeadersInNetLog) {
+  Initialize();
+
+  // QuicHttp3Logger is only used with HTTP/3.
+  if (!VersionUsesHttp3(version_.transport_version)) {
+    return;
+  }
+
+  net_log_.SetObserverCaptureMode(NetLogCaptureMode::kDefault);
+
+  // Send request.
+  SetRequest("GET", "/", DEFAULT_PRIORITY);
+  request_.method = "GET";
+  request_.url = GURL("https://www.example.org/");
+  headers_.SetHeader(HttpRequestHeaders::kCookie, "secret");
+
+  size_t spdy_request_header_frame_length;
+  int packet_number = 1;
+  AddWrite(ConstructInitialSettingsPacket(packet_number++));
+  AddWrite(InnerConstructRequestHeadersPacket(
+      packet_number++, GetNthClientInitiatedBidirectionalStreamId(0),
+      kIncludeVersion, kFin, DEFAULT_PRIORITY,
+      &spdy_request_header_frame_length));
+
+  EXPECT_THAT(stream_->InitializeStream(&request_, true, DEFAULT_PRIORITY,
+                                        net_log_.bound(), callback_.callback()),
+              IsOk());
+  EXPECT_THAT(stream_->SendRequest(headers_, &response_, callback_.callback()),
+              IsOk());
+  ProcessPacket(ConstructServerAckPacket(1, 1, 1, 1));  // Ack the request.
+
+  // Process response.
+  SetResponse("200 OK", string());
+  response_headers_["set-cookie"] = "secret";
+  size_t spdy_response_header_frame_length;
+  ProcessPacket(ConstructResponseHeadersPacket(
+      2, kFin, &spdy_response_header_frame_length));
+
+  EXPECT_THAT(stream_->ReadResponseHeaders(callback_.callback()), IsOk());
+  EXPECT_TRUE(AtEof());
+
+  ASSERT_TRUE(response_.headers.get());
+  EXPECT_EQ(200, response_.headers->response_code());
+  EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
+  EXPECT_TRUE(response_.headers->HasHeaderValue("set-cookie", "secret"));
+
+  // Find HTTP3_HEADERS_SENT NetLog event.
+  auto events = net_log_.GetEntries();
+  auto event_it = events.begin();
+  while (event_it != events.end()) {
+    if (event_it->type == NetLogEventType::HTTP3_HEADERS_SENT) {
+      break;
+    }
+    ++event_it;
+  }
+  ASSERT_NE(events.end(), event_it) << "No HTTP3_HEADERS_SENT event found.";
+
+  // Extract request headers.
+  const base::Value& request_params = event_it->params;
+  ASSERT_TRUE(request_params.is_dict());
+  const base::Value* headers = request_params.FindKey("headers");
+  ASSERT_TRUE(headers) << "No headers entry found.";
+  ASSERT_TRUE(headers->is_list());
+  auto headerlist = headers->GetList();
+
+  // Check that cookie value has been stripped.
+  auto header_it = headerlist.begin();
+  while (header_it != headerlist.end()) {
+    ASSERT_TRUE(header_it->is_string());
+    if (base::StartsWith(header_it->GetString(), "cookie: ")) {
+      break;
+    }
+    ++header_it;
+  }
+  ASSERT_NE(headerlist.end(), header_it) << "No cookie header found.";
+  EXPECT_EQ("cookie: [6 bytes were stripped]", header_it->GetString());
+
+  // Find HTTP3_HEADERS_DECODED NetLog event.
+  event_it = events.begin();
+  while (event_it != events.end()) {
+    if (event_it->type == NetLogEventType::HTTP3_HEADERS_DECODED) {
+      break;
+    }
+    ++event_it;
+  }
+  ASSERT_NE(events.end(), event_it) << "No HTTP3_HEADERS_DECODED event found.";
+
+  // Extract response headers.
+  const base::Value& response_params = event_it->params;
+  ASSERT_TRUE(response_params.is_dict());
+  headers = response_params.FindKey("headers");
+  ASSERT_TRUE(headers) << "No headers entry found.";
+  ASSERT_TRUE(headers->is_list());
+  headerlist = headers->GetList();
+
+  // Check that set-cookie value has been stripped.
+  header_it = headerlist.begin();
+  while (header_it != headerlist.end()) {
+    ASSERT_TRUE(header_it->is_string());
+    if (base::StartsWith(header_it->GetString(), "set-cookie: ")) {
+      break;
+    }
+    ++header_it;
+  }
+  ASSERT_NE(headerlist.end(), header_it) << "No set-cookie header found.";
+  EXPECT_EQ("set-cookie: [6 bytes were stripped]", header_it->GetString());
+}
+
 // Regression test for http://crbug.com/288128
 TEST_P(QuicHttpStreamTest, GetRequestLargeResponse) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);