request_sender.cc 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228
  1. // Copyright 2014 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/update_client/request_sender.h"
  5. #include <utility>
  6. #include "base/base64.h"
  7. #include "base/bind.h"
  8. #include "base/callback_helpers.h"
  9. #include "base/location.h"
  10. #include "base/logging.h"
  11. #include "base/numerics/safe_conversions.h"
  12. #include "base/strings/stringprintf.h"
  13. #include "base/threading/thread_task_runner_handle.h"
  14. #include "components/client_update_protocol/ecdsa.h"
  15. #include "components/update_client/configurator.h"
  16. #include "components/update_client/network.h"
  17. #include "components/update_client/update_client_errors.h"
  18. #include "components/update_client/utils.h"
  19. namespace update_client {
  20. namespace {
  21. // This is an ECDSA prime256v1 named-curve key.
  22. constexpr int kKeyVersion = 12;
  23. constexpr char kKeyPubBytesBase64[] =
  24. "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAETGhzuDJHRFx7//YqqdaNTY3dZ8X9"
  25. "XhUC0o7fmZtOFe9cjPML9KVHPa2M5hxhJThIbRQMElksHy4llZoWg6KTZw==";
  26. // The content type for all protocol requests.
  27. constexpr char kContentType[] = "application/json";
  28. // Returns the value of |response_cup_server_proof| or the value of
  29. // |response_etag|, if the former value is empty.
  30. const std::string& SelectCupServerProof(
  31. const std::string& response_cup_server_proof,
  32. const std::string& response_etag) {
  33. if (response_cup_server_proof.empty()) {
  34. DVLOG(3) << "Using etag as cup server proof.";
  35. return response_etag;
  36. }
  37. return response_cup_server_proof;
  38. }
  39. } // namespace
  40. RequestSender::RequestSender(scoped_refptr<Configurator> config)
  41. : config_(config) {}
  42. RequestSender::~RequestSender() {
  43. DCHECK(thread_checker_.CalledOnValidThread());
  44. }
  45. void RequestSender::Send(
  46. const std::vector<GURL>& urls,
  47. const base::flat_map<std::string, std::string>& request_extra_headers,
  48. const std::string& request_body,
  49. bool use_signing,
  50. RequestSenderCallback request_sender_callback) {
  51. DCHECK(thread_checker_.CalledOnValidThread());
  52. urls_ = urls;
  53. request_extra_headers_ = request_extra_headers;
  54. request_body_ = request_body;
  55. use_signing_ = use_signing;
  56. request_sender_callback_ = std::move(request_sender_callback);
  57. if (urls_.empty()) {
  58. return HandleSendError(static_cast<int>(ProtocolError::MISSING_URLS), 0);
  59. }
  60. cur_url_ = urls_.begin();
  61. if (use_signing_) {
  62. public_key_ = GetKey(kKeyPubBytesBase64);
  63. if (public_key_.empty())
  64. return HandleSendError(
  65. static_cast<int>(ProtocolError::MISSING_PUBLIC_KEY), 0);
  66. }
  67. SendInternal();
  68. }
  69. void RequestSender::SendInternal() {
  70. DCHECK(cur_url_ != urls_.end());
  71. DCHECK(cur_url_->is_valid());
  72. DCHECK(thread_checker_.CalledOnValidThread());
  73. GURL url(*cur_url_);
  74. if (use_signing_) {
  75. DCHECK(!public_key_.empty());
  76. signer_ = client_update_protocol::Ecdsa::Create(kKeyVersion, public_key_);
  77. std::string request_query_string;
  78. signer_->SignRequest(request_body_, &request_query_string);
  79. url = BuildUpdateUrl(url, request_query_string);
  80. }
  81. VLOG(2) << "Sending Omaha request: " << request_body_;
  82. network_fetcher_ = config_->GetNetworkFetcherFactory()->Create();
  83. if (!network_fetcher_) {
  84. base::ThreadTaskRunnerHandle::Get()->PostTask(
  85. FROM_HERE,
  86. base::BindOnce(&RequestSender::SendInternalComplete,
  87. base::Unretained(this),
  88. static_cast<int>(ProtocolError::URL_FETCHER_FAILED),
  89. std::string(), std::string(), std::string(), 0));
  90. }
  91. network_fetcher_->PostRequest(
  92. url, request_body_, kContentType, request_extra_headers_,
  93. base::BindOnce(&RequestSender::OnResponseStarted, base::Unretained(this)),
  94. base::DoNothing(),
  95. base::BindOnce(&RequestSender::OnNetworkFetcherComplete,
  96. base::Unretained(this), url));
  97. }
  98. void RequestSender::SendInternalComplete(
  99. int error,
  100. const std::string& response_body,
  101. const std::string& response_etag,
  102. const std::string& response_cup_server_proof,
  103. int retry_after_sec) {
  104. VLOG(2) << "Omaha response received: " << response_body;
  105. if (!error) {
  106. if (!use_signing_) {
  107. base::ThreadTaskRunnerHandle::Get()->PostTask(
  108. FROM_HERE, base::BindOnce(std::move(request_sender_callback_), 0,
  109. response_body, retry_after_sec));
  110. return;
  111. }
  112. DCHECK(use_signing_);
  113. DCHECK(signer_);
  114. if (signer_->ValidateResponse(
  115. response_body,
  116. SelectCupServerProof(response_cup_server_proof, response_etag))) {
  117. base::ThreadTaskRunnerHandle::Get()->PostTask(
  118. FROM_HERE, base::BindOnce(std::move(request_sender_callback_), 0,
  119. response_body, retry_after_sec));
  120. return;
  121. }
  122. error = static_cast<int>(ProtocolError::RESPONSE_NOT_TRUSTED);
  123. }
  124. DCHECK(error);
  125. // A positive |retry_after_sec| is a hint from the server that the client
  126. // should not send further request until the cooldown has expired.
  127. if (retry_after_sec <= 0 && ++cur_url_ != urls_.end() &&
  128. base::ThreadTaskRunnerHandle::Get()->PostTask(
  129. FROM_HERE, base::BindOnce(&RequestSender::SendInternal,
  130. base::Unretained(this)))) {
  131. return;
  132. }
  133. VLOG(2) << "Omaha send error: " << response_body;
  134. HandleSendError(error, retry_after_sec);
  135. }
  136. void RequestSender::OnResponseStarted(int response_code,
  137. int64_t content_length) {
  138. response_code_ = response_code;
  139. }
  140. void RequestSender::OnNetworkFetcherComplete(
  141. const GURL& original_url,
  142. std::unique_ptr<std::string> response_body,
  143. int net_error,
  144. const std::string& header_etag,
  145. const std::string& xheader_cup_server_proof,
  146. int64_t xheader_retry_after_sec) {
  147. DCHECK(thread_checker_.CalledOnValidThread());
  148. VLOG(1) << "Request completed from url: " << original_url.spec();
  149. int error = -1;
  150. if (!net_error && response_code_ == 200)
  151. error = 0;
  152. else if (response_code_ != -1)
  153. error = response_code_;
  154. else
  155. error = net_error;
  156. int retry_after_sec = -1;
  157. if (original_url.SchemeIsCryptographic() && error > 0)
  158. retry_after_sec = base::saturated_cast<int>(xheader_retry_after_sec);
  159. base::ThreadTaskRunnerHandle::Get()->PostTask(
  160. FROM_HERE,
  161. base::BindOnce(&RequestSender::SendInternalComplete,
  162. base::Unretained(this), error,
  163. response_body ? *response_body : std::string(),
  164. header_etag, xheader_cup_server_proof, retry_after_sec));
  165. }
  166. void RequestSender::HandleSendError(int error, int retry_after_sec) {
  167. base::ThreadTaskRunnerHandle::Get()->PostTask(
  168. FROM_HERE, base::BindOnce(std::move(request_sender_callback_), error,
  169. std::string(), retry_after_sec));
  170. }
  171. std::string RequestSender::GetKey(const char* key_bytes_base64) {
  172. std::string result;
  173. return base::Base64Decode(std::string(key_bytes_base64), &result)
  174. ? result
  175. : std::string();
  176. }
  177. GURL RequestSender::BuildUpdateUrl(const GURL& url,
  178. const std::string& query_params) {
  179. const std::string query_string(
  180. url.has_query() ? base::StringPrintf("%s&%s", url.query().c_str(),
  181. query_params.c_str())
  182. : query_params);
  183. GURL::Replacements replacements;
  184. replacements.SetQueryStr(query_string);
  185. return url.ReplaceComponents(replacements);
  186. }
  187. } // namespace update_client