Certificate Transparency: Add STH Fetching capability.

components/certificate_transparency/log_proof_fetcher.cc

+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/certificate_transparency/log_proof_fetcher.h"
+
+#include <iterator>
+
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/stl_util.h"
+#include "base/values.h"
+#include "components/safe_json/safe_json_parser.h"
+#include "net/base/io_buffer.h"
+#include "net/base/load_flags.h"
+#include "net/base/net_errors.h"
+#include "net/base/request_priority.h"
+#include "net/cert/ct_log_response_parser.h"
+#include "net/cert/signed_tree_head.h"
+#include "net/http/http_status_code.h"
+#include "net/url_request/url_request_context.h"
+#include "url/gurl.h"
+
+namespace certificate_transparency {
+
+namespace {
+
+// Shamelessly copied from domain_reliability/util.cc
+int GetNetErrorFromURLRequestStatus(const net::URLRequestStatus& status) {
+  switch (status.status()) {
+    case net::URLRequestStatus::SUCCESS:
+      return net::OK;
+    case net::URLRequestStatus::CANCELED:
+      return net::ERR_ABORTED;
+    case net::URLRequestStatus::FAILED:
+      return status.error();
+    default:
+      NOTREACHED();
+      return net::ERR_FAILED;
+  }
+}
+
+}  // namespace
+
+struct LogProofFetcher::FetchState {
+  FetchState(const std::string& log_id,
+             const SignedTreeHeadFetchedCallback& fetched_callback,
+             const FetchFailedCallback& failed_callback);
+  ~FetchState();
+
+  std::string log_id;
+  SignedTreeHeadFetchedCallback fetched_callback;
+  FetchFailedCallback failed_callback;
+  scoped_refptr<net::IOBufferWithSize> response_buffer;
+  std::string assembled_response;
+};
+
+LogProofFetcher::FetchState::FetchState(
+    const std::string& log_id,
+    const SignedTreeHeadFetchedCallback& fetched_callback,
+    const FetchFailedCallback& failed_callback)
+    : log_id(log_id),
+      fetched_callback(fetched_callback),
+      failed_callback(failed_callback),
+      response_buffer(new net::IOBufferWithSize(kMaxLogResponseSizeInBytes)) {}
+
+LogProofFetcher::FetchState::~FetchState() {}
+
+LogProofFetcher::LogProofFetcher(net::URLRequestContext* request_context)
+    : request_context_(request_context), weak_factory_(this) {
+  DCHECK(request_context);
+}
+
+LogProofFetcher::~LogProofFetcher() {
+  STLDeleteContainerPairPointers(inflight_requests_.begin(),
+                                 inflight_requests_.end());
+}
+
+void LogProofFetcher::FetchSignedTreeHead(
+    const GURL& base_log_url,
+    const std::string& log_id,
+    const SignedTreeHeadFetchedCallback& fetched_callback,
+    const FetchFailedCallback& failed_callback) {
+  DCHECK(base_log_url.SchemeIsHTTPOrHTTPS());
+  GURL fetch_url(base_log_url.Resolve("ct/v1/get-sth"));
+  scoped_ptr<net::URLRequest> request =
+      request_context_->CreateRequest(fetch_url, net::DEFAULT_PRIORITY, this);
+  request->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
+                        net::LOAD_DO_NOT_SAVE_COOKIES |
+                        net::LOAD_DO_NOT_SEND_AUTH_DATA);
+
+  FetchState* fetch_state =
+      new FetchState(log_id, fetched_callback, failed_callback);
+  request->Start();
+  inflight_requests_.insert(std::make_pair(request.release(), fetch_state));
+}
+
+void LogProofFetcher::OnResponseStarted(net::URLRequest* request) {
+  net::URLRequestStatus status(request->status());
+  DCHECK(inflight_requests_.count(request));
+  FetchState* fetch_state = inflight_requests_.find(request)->second;
+
+  if (!status.is_success() || request->GetResponseCode() != net::HTTP_OK) {
+    int net_error = net::OK;
+    int http_response_code = request->GetResponseCode();
+
+    DVLOG(1) << "Fetching STH from " << request->original_url()
+             << " failed. status:" << status.status()
+             << " error:" << status.error()
+             << " http response code: " << http_response_code;
+    if (!status.is_success())
+      net_error = GetNetErrorFromURLRequestStatus(status);
+
+    InvokeFailureCallback(request, net_error, http_response_code);
+    return;
+  }
+
+  StartNextRead(request, fetch_state);
+}
+
+void LogProofFetcher::OnReadCompleted(net::URLRequest* request,
+                                      int bytes_read) {
+  DCHECK(inflight_requests_.count(request));
+  FetchState* fetch_state = inflight_requests_.find(request)->second;
+
+  if (HandleReadResult(request, fetch_state, bytes_read))
+    StartNextRead(request, fetch_state);
+}
+
+bool LogProofFetcher::HandleReadResult(net::URLRequest* request,
+                                       FetchState* fetch_state,
+                                       int bytes_read) {
+  // Start by checking for an error condition.
+  // If there are errors, invoke the failure callback and clean up the
+  // request.
+  if (bytes_read == -1 || !request->status().is_success()) {
+    net::URLRequestStatus status(request->status());
+    DVLOG(1) << "Read error: " << status.status() << " " << status.error();
+    InvokeFailureCallback(request, GetNetErrorFromURLRequestStatus(status),
+                          net::OK);
+
+    return false;
+  }
+
+  // Not an error, but no data available, so wait for OnReadCompleted
+  // callback.
+  if (request->status().is_io_pending())
+    return false;
+
+  // Nothing more to read from the stream - finish handling the response.
+  if (bytes_read == 0) {
+    RequestComplete(request);
+    return false;
+  }
+
+  // We have data, collect it and indicate another read is needed.
+  DVLOG(1) << "Have " << bytes_read << " bytes to assemble.";
+  DCHECK_GE(bytes_read, 0);
+  fetch_state->assembled_response.append(fetch_state->response_buffer->data(),
+                                         bytes_read);
+  if (fetch_state->assembled_response.size() > kMaxLogResponseSizeInBytes) {
+    // Log response is too big, invoke the failure callback.
+    InvokeFailureCallback(request, net::ERR_FILE_TOO_BIG, net::HTTP_OK);
+    return false;
+  }
+
+  return true;
+}
+
+void LogProofFetcher::StartNextRead(net::URLRequest* request,
+                                    FetchState* fetch_state) {
+  bool continue_reading = true;
+  while (continue_reading) {
+    int read_bytes = 0;
+    request->Read(fetch_state->response_buffer.get(),
+                  fetch_state->response_buffer->size(), &read_bytes);
+    continue_reading = HandleReadResult(request, fetch_state, read_bytes);
+  }
+}
+
+void LogProofFetcher::RequestComplete(net::URLRequest* request) {
+  DCHECK(inflight_requests_.count(request));
+
+  FetchState* fetch_state = inflight_requests_.find(request)->second;
+
+  // Get rid of the buffer as it really isn't necessary.
+  fetch_state->response_buffer = nullptr;
+  safe_json::SafeJsonParser::Parse(
+      fetch_state->assembled_response,
+      base::Bind(&LogProofFetcher::OnSTHJsonParseSuccess,
+                 weak_factory_.GetWeakPtr(), request),
+      base::Bind(&LogProofFetcher::OnSTHJsonParseError,
+                 weak_factory_.GetWeakPtr(), request));
+}
+
+void LogProofFetcher::CleanupRequest(net::URLRequest* request) {
+  DVLOG(1) << "Cleaning up request to " << request->original_url();
+  auto it = inflight_requests_.find(request);
+  DCHECK(it != inflight_requests_.end());
+  auto next_it = it;
+  std::advance(next_it, 1);
+
+  // Delete FetchState and URLRequest, then the entry from inflight_requests_.
+  STLDeleteContainerPairPointers(it, next_it);
+  inflight_requests_.erase(it);
+}
+
+void LogProofFetcher::InvokeFailureCallback(net::URLRequest* request,
+                                            int net_error,
+                                            int http_response_code) {
+  DCHECK(inflight_requests_.count(request));
+  auto it = inflight_requests_.find(request);
+  FetchState* fetch_state = it->second;
+
+  fetch_state->failed_callback.Run(fetch_state->log_id, net_error,
+                                   http_response_code);
+  CleanupRequest(request);
+}
+
+void LogProofFetcher::OnSTHJsonParseSuccess(
+    net::URLRequest* request,
+    scoped_ptr<base::Value> parsed_json) {
+  DCHECK(inflight_requests_.count(request));
+
+  FetchState* fetch_state = inflight_requests_.find(request)->second;
+  net::ct::SignedTreeHead signed_tree_head;
+  if (net::ct::FillSignedTreeHead(*parsed_json.get(), &signed_tree_head)) {
+    fetch_state->fetched_callback.Run(fetch_state->log_id, signed_tree_head);
+  } else {
+    fetch_state->failed_callback.Run(fetch_state->log_id,
+                                     net::ERR_CT_STH_INCOMPLETE, net::HTTP_OK);
+  }
+
+  CleanupRequest(request);
+}
+
+void LogProofFetcher::OnSTHJsonParseError(net::URLRequest* request,
+                                          const std::string& error) {
+  InvokeFailureCallback(request, net::ERR_CT_STH_PARSING_FAILED, net::HTTP_OK);
+}
+
+}  // namespace certificate_transparency