Updating D2D protocol to v1 to support separate sequence numbers.

components/cryptauth/device_to_device_authenticator.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/cryptauth/device_to_device_authenticator.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "components/cryptauth/authenticator.h"
 #include "components/cryptauth/connection.h"
 #include "components/cryptauth/device_to_device_initiator_operations.h"
 #include "components/cryptauth/device_to_device_secure_context.h"
 #include "components/cryptauth/secure_context.h"
 #include "components/cryptauth/secure_message_delegate.h"
+#include "components/cryptauth/session_keys.h"
 #include "components/cryptauth/wire_message.h"
 #include "components/proximity_auth/logging/logging.h"
 
 namespace cryptauth {
 
 namespace {
 
 // The time to wait in seconds for the remote device to send its
 // [Responder Auth] message. If we do not get the message in this time, then
 // authentication will fail.
@@ skipping 119 matching lines @@
       hello_message_, std::string(Authenticator::kAuthenticationFeature)));
 }
 
 void DeviceToDeviceAuthenticator::OnResponderAuthTimedOut() {
   DCHECK(state_ == State::SENT_HELLO);
   Fail("Timed out waiting for [Responder Auth]");
 }
 
 void DeviceToDeviceAuthenticator::OnResponderAuthValidated(
     bool validated,
-    const std::string& session_symmetric_key) {
+    std::unique_ptr<SessionKeys> session_keys) {
   if (!validated) {
     Fail("Unable to validated [Responder Auth]");
     return;
   }
 
   PA_LOG(INFO) << "Successfully validated [Responder Auth]! "
                << "Sending [Initiator Auth]...";
   state_ = State::VALIDATED_RESPONDER_AUTH;
-  session_symmetric_key_ = session_symmetric_key;
+  session_keys_ = std::move(session_keys);
 
   // Create the [Initiator Auth] message to send to the remote device.
   DeviceToDeviceInitiatorOperations::CreateInitiatorAuthMessage(
-      session_symmetric_key,
+      session_keys_.get(),
       connection_->remote_device().persistent_symmetric_key,
       responder_auth_message_, secure_message_delegate_.get(),
       base::Bind(&DeviceToDeviceAuthenticator::OnInitiatorAuthCreated,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void DeviceToDeviceAuthenticator::OnInitiatorAuthCreated(
     const std::string& message) {
   DCHECK(state_ == State::VALIDATED_RESPONDER_AUTH);
   if (message.empty()) {
@@ skipping 16 matching lines @@
   PA_LOG(WARNING) << "Authentication failed: " << error_message;
   state_ = State::AUTHENTICATION_FAILURE;
   weak_ptr_factory_.InvalidateWeakPtrs();
   connection_->RemoveObserver(this);
   timer_.reset();
   callback_.Run(result, nullptr);
 }
 
 void DeviceToDeviceAuthenticator::Succeed() {
   DCHECK(state_ == State::SENT_INITIATOR_AUTH);
-  DCHECK(!session_symmetric_key_.empty());
+  DCHECK(session_keys_);
   PA_LOG(INFO) << "Authentication succeeded!";
 
   state_ = State::AUTHENTICATION_SUCCESS;
   connection_->RemoveObserver(this);
   callback_.Run(
       Result::SUCCESS,
       base::MakeUnique<DeviceToDeviceSecureContext>(
-          std::move(secure_message_delegate_), session_symmetric_key_,
+          std::move(secure_message_delegate_), std::move(session_keys_),
           responder_auth_message_, SecureContext::PROTOCOL_VERSION_THREE_ONE));
 }
 
 void DeviceToDeviceAuthenticator::OnConnectionStatusChanged(
     Connection* connection,
     Connection::Status old_status,
     Connection::Status new_status) {
   // We do not expect the connection to drop during authentication.
   if (new_status == Connection::DISCONNECTED) {
     Fail("Disconnected while authentication is in progress",
@@ skipping 36 matching lines @@
       Succeed();
     else
       Fail("Failed to send [Initiator Auth]");
   } else if (!success && state_ == State::SENT_HELLO) {
     DCHECK(message.payload() == hello_message_);
     Fail("Failed to send [Hello]");
   }
 }
 
 }  // namespace cryptauth