Certificate Transparency: Fetching consistency proofs.

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/strings/stringprintf.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"
@@ skipping 11 matching lines @@
     case net::URLRequestStatus::CANCELED:
       return net::ERR_ABORTED;
     case net::URLRequestStatus::FAILED:
       return status.error();
     default:
       NOTREACHED();
       return net::ERR_FAILED;
   }
 }
 
+enum LogRequestType { SIGNED_TREE_HEAD, CONSISTENCY_PROOF };
+
+template <typename T>
+size_t InsertCallbackToMap(std::map<size_t, T>* callbacks_map, T callback) {
+  size_t callback_id = callbacks_map->size();
+  while (callbacks_map->find(callback_id) != callbacks_map->end())
+    ++callback_id;
+
+  callbacks_map->insert(std::make_pair(callback_id, callback));
+  return callback_id;
+}
+
+template <typename T>
+T FindCallback(const std::map<size_t, T>& callbacks_map, size_t callback_id) {
+  auto callback_position = callbacks_map.find(callback_id);
+  CHECK(callback_position != callbacks_map.end());
+  return callback_position->second;
+}
+
 }  // namespace
 
 struct LogProofFetcher::FetchState {
   FetchState(const std::string& log_id,
-             const SignedTreeHeadFetchedCallback& fetched_callback,
+             LogRequestType request_type,
+             size_t callback_id,
              const FetchFailedCallback& failed_callback);
   ~FetchState();
 
   std::string log_id;
-  SignedTreeHeadFetchedCallback fetched_callback;
+  LogRequestType request_type;
+  size_t callback_id;
   FetchFailedCallback failed_callback;

[svaldez, 2015/11/12 20:11:03]

Can't you just add:

SignedTreeHeadFetchedCallback sth_fetch_callback;
ConsistencyProofFetchedCallback proof_fetch_callback;

And then remove the fetch_callbacks_ maps and related methods?

The FetchState lifetime seems to be identical to the elements of the callbacks
map

[Eran Messeri, 2015/11/16 13:39:46]

Done - it does simplify the design.

   scoped_refptr<net::IOBufferWithSize> response_buffer;
   std::string assembled_response;
 };
 
 LogProofFetcher::FetchState::FetchState(
     const std::string& log_id,
-    const SignedTreeHeadFetchedCallback& fetched_callback,
+    LogRequestType request_type,
+    size_t callback_id,
     const FetchFailedCallback& failed_callback)
     : log_id(log_id),
-      fetched_callback(fetched_callback),
+      request_type(request_type),
+      callback_id(callback_id),
       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);
+  net::URLRequest* request = CreateRequest(fetch_url);
 
-  FetchState* fetch_state =
-      new FetchState(log_id, fetched_callback, failed_callback);
+  size_t callback_id =
+      InsertCallbackToMap(&sth_fetch_callbacks_, fetched_callback);
+  FetchState* fetch_state = new FetchState(
+      log_id, LogRequestType::SIGNED_TREE_HEAD, callback_id, failed_callback);
   request->Start();
-  inflight_requests_.insert(std::make_pair(request.release(), fetch_state));
+  inflight_requests_.insert(std::make_pair(request, fetch_state));
+}
+
+void LogProofFetcher::FetchConsistencyProof(
+    const GURL& base_log_url,
+    const std::string& log_id,
+    size_t old_tree_size,
+    size_t new_tree_size,
+    const ConsistencyProofFetchedCallback& fetched_callback,
+    const FetchFailedCallback& failed_callback) {
+  DCHECK(base_log_url.SchemeIsHTTPOrHTTPS());
+  std::string query =
+      base::StringPrintf("first=%lu&second=%lu", old_tree_size, new_tree_size);
+  GURL::Replacements replacements;
+  replacements.SetQueryStr(query);
+  GURL fetch_url = base_log_url.Resolve("ct/v1/get-sth-consistency")
+                       .ReplaceComponents(replacements);

[svaldez, 2015/11/12 20:11:03]

Can't you just do:

std::string relative =
StringPrintf("ct/v1/get-sth-consistency?first=%lu&second=%lu", ...)
GURL fetch_url = base_log_url.Resolve(relative);

[Eran Messeri, 2015/11/16 13:39:46]

Done.

+
+  net::URLRequest* request = CreateRequest(fetch_url);
+
+  size_t callback_id =
+      InsertCallbackToMap(&consistency_fetch_callbacks_, fetched_callback);
+  FetchState* fetch_state = new FetchState(
+      log_id, LogRequestType::CONSISTENCY_PROOF, callback_id, failed_callback);
+  request->Start();
+  inflight_requests_.insert(std::make_pair(request, 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();
@@ skipping 72 matching lines @@
   }
 }
 
 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));
+  if (fetch_state->request_type == LogRequestType::SIGNED_TREE_HEAD) {
+    safe_json::SafeJsonParser::Parse(
+        fetch_state->assembled_response,
+        base::Bind(&LogProofFetcher::OnSTHJsonParseSuccess,
+                   weak_factory_.GetWeakPtr(), request),
+        base::Bind(&LogProofFetcher::OnSTHJsonParseError,
+                   weak_factory_.GetWeakPtr(), request));
+  } else if (fetch_state->request_type == LogRequestType::CONSISTENCY_PROOF) {
+    safe_json::SafeJsonParser::Parse(
+        fetch_state->assembled_response,
+        base::Bind(&LogProofFetcher::OnConsistencyProofJsonParseSuccess,
+                   weak_factory_.GetWeakPtr(), request),
+        base::Bind(&LogProofFetcher::OnConsistencyProofJsonParseError,
+                   weak_factory_.GetWeakPtr(), request));
+  } else {
+    NOTREACHED();
+  }
 }
 
 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());
+
+  LogRequestType request_type = it->second->request_type;
+  size_t callback_id = it->second->callback_id;
+  if (request_type == SIGNED_TREE_HEAD) {
+    sth_fetch_callbacks_.erase(callback_id);
+  } else if (request_type == CONSISTENCY_PROOF) {
+    consistency_fetch_callbacks_.erase(callback_id);
+  }
   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);
+    SignedTreeHeadFetchedCallback fetched_callback =
+        FindCallback(sth_fetch_callbacks_, fetch_state->callback_id);
+    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);
 }
 
+void LogProofFetcher::OnConsistencyProofJsonParseSuccess(
+    net::URLRequest* request,
+    scoped_ptr<base::Value> parsed_json) {
+  DCHECK(inflight_requests_.count(request));
+  FetchState* fetch_state = inflight_requests_.find(request)->second;
+  std::vector<std::string> consistency_proof;
+  if (net::ct::FillConsistencyProof(*parsed_json.get(), &consistency_proof)) {
+    ConsistencyProofFetchedCallback fetched_callback =
+        FindCallback(consistency_fetch_callbacks_, fetch_state->callback_id);
+    fetched_callback.Run(fetch_state->log_id, consistency_proof);
+  } else {
+    fetch_state->failed_callback.Run(
+        fetch_state->log_id, net::ERR_CT_CONSISTENCY_PROOF_PARSING_FAILED,
+        net::HTTP_OK);
+  }
+
+  CleanupRequest(request);
+}
+
+void LogProofFetcher::OnConsistencyProofJsonParseError(
+    net::URLRequest* request,
+    const std::string& error) {
+  InvokeFailureCallback(request, net::ERR_CT_CONSISTENCY_PROOF_PARSING_FAILED,
+                        net::HTTP_OK);
+}
+
+net::URLRequest* LogProofFetcher::CreateRequest(const GURL& url) {
+  scoped_ptr<net::URLRequest> request =
+      request_context_->CreateRequest(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);
+  return request.release();
+}
+
 }  // namespace certificate_transparency