[Cast Channel] Add support for nonce challenge to Cast channel authentication.

extensions/browser/api/cast_channel/cast_socket.cc

 // Copyright 2014 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 "extensions/browser/api/cast_channel/cast_socket.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/format_macros.h"
+#include "base/guid.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_byteorder.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
@@ skipping 41 matching lines @@
 BrowserContextKeyedAPIFactory<
     ApiResourceManager<api::cast_channel::CastSocket>>*
 ApiResourceManager<api::cast_channel::CastSocket>::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 namespace api {
 namespace cast_channel {
 namespace {
 
+long kNonceExpirationTimeInHours = 24;
+
 bool IsTerminalState(proto::ConnectionState state) {
   return state == proto::CONN_STATE_FINISHED ||
          state == proto::CONN_STATE_ERROR || state == proto::CONN_STATE_TIMEOUT;
 }
 
 // Cert verifier which blindly accepts all certificates, regardless of validity.
 class FakeCertVerifier : public net::CertVerifier {
  public:
   FakeCertVerifier() {}
   ~FakeCertVerifier() override {}
 
   int Verify(const RequestParams& params,
              net::CRLSet*,
              net::CertVerifyResult* verify_result,
              const net::CompletionCallback&,
              std::unique_ptr<Request>*,
              const net::NetLogWithSource&) override {
     verify_result->Reset();
     verify_result->verified_cert = params.certificate();
     return net::OK;
   }
 };
 
 }  // namespace
 
+// static
+std::string CastSocketImpl::nonce_ = "";

[mark a. foltz, 2017/03/03 23:25:51]

Static variables must be POD (with a few exceptions).  Use base::Singleton.

https://google.github.io/styleguide/cppguide.html#Static_and_Global_Variables

[ryanchung, 2017/03/06 22:57:46]

Done. Thanks.

+// static
+base::Time CastSocketImpl::nonce_generation_time_ = base::Time();
+
+// static
+void CastSocketImpl::EnsureNonceTimely() {
+  if (nonce_.empty() ||
+      base::Time::Now() >
+          (nonce_generation_time_ +
+           base::TimeDelta::FromHours(kNonceExpirationTimeInHours))) {
+    nonce_ = base::GenerateGUID();

[mark a. foltz, 2017/03/03 23:25:51]

I thought there was a different nonce for each attempt to open the socket? Is
the concern overuse of /dev/urandom?

[ryanchung, 2017/03/06 22:57:46]

Ideally, each connection attempt uses a difference nonce. The concern is on the
overhead of the signing operation on some of the older generations of receivers.
When the same nonce is used, the signature can be cached so the latency for the
Cast operation roughly cuts in half.

+    nonce_generation_time_ = base::Time::Now();
+  }
+}
+
 CastSocket::CastSocket(const std::string& owner_extension_id)
     : ApiResource(owner_extension_id) {
 }
 
 bool CastSocket::IsPersistent() const {
   return true;
 }
 
 CastSocketImpl::CastSocketImpl(const std::string& owner_extension_id,
                                const net::IPEndPoint& ip_endpoint,
@@ skipping 16 matching lines @@
       is_canceled_(false),
       device_capabilities_(device_capabilities),
       audio_only_(false),
       connect_state_(proto::CONN_STATE_START_CONNECT),
       error_state_(CHANNEL_ERROR_NONE),
       ready_state_(READY_STATE_NONE),
       auth_delegate_(nullptr) {
   DCHECK(net_log_);
   net_log_source_.type = net::NetLogSourceType::SOCKET;
   net_log_source_.id = net_log_->NextID();
+  EnsureNonceTimely();
 }
 
 CastSocketImpl::~CastSocketImpl() {
   // Ensure that resources are freed but do not run pending callbacks to avoid
   // any re-entrancy.
   CloseInternal();
 }
 
 ReadyState CastSocketImpl::ready_state() const {
   return ready_state_;
@@ skipping 81 matching lines @@
     logger_->LogSocketEventWithDetails(
         channel_id_, proto::CHANNEL_POLICY_ENFORCED, std::string());
     return false;
   }
   return true;
 }
 
 bool CastSocketImpl::VerifyChallengeReply() {
   DCHECK(peer_cert_);
   AuthResult result =
-      AuthenticateChallengeReply(*challenge_reply_, *peer_cert_);
+      AuthenticateChallengeReply(*challenge_reply_, *peer_cert_, nonce_);
   logger_->LogSocketChallengeReplyEvent(channel_id_, result);
   if (result.success()) {
     VLOG(1) << result.error_message;
     if (!VerifyChannelPolicy(result)) {
       return false;
     }
   }
   return result.success();
 }
 
@@ skipping 194 matching lines @@
     SetErrorState(CHANNEL_ERROR_AUTHENTICATION_ERROR);
   }
   return result;
 }
 
 int CastSocketImpl::DoAuthChallengeSend() {
   VLOG_WITH_CONNECTION(1) << "DoAuthChallengeSend";
   SetConnectState(proto::CONN_STATE_AUTH_CHALLENGE_SEND_COMPLETE);
 
   CastMessage challenge_message;
-  CreateAuthChallengeMessage(&challenge_message);
+  CreateAuthChallengeMessage(&challenge_message, nonce_);
   VLOG_WITH_CONNECTION(1) << "Sending challenge: "
                           << CastMessageToString(challenge_message);
 
   transport_->SendMessage(
       challenge_message,
       base::Bind(&CastSocketImpl::DoConnectLoop, base::Unretained(this)));
 
   // Always return IO_PENDING since the result is always asynchronous.
   return net::ERR_IO_PENDING;
 }
@@ skipping 147 matching lines @@
   }
 }
 
 void CastSocketImpl::SetErrorState(ChannelError error_state) {
   VLOG_WITH_CONNECTION(1) << "SetErrorState " << error_state;
   DCHECK_EQ(CHANNEL_ERROR_NONE, error_state_);
   error_state_ = error_state;
   logger_->LogSocketErrorState(channel_id_, ErrorStateToProto(error_state_));
   delegate_->OnError(error_state_);
 }
+
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions
 #undef VLOG_WITH_CONNECTION