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"
@@ skipping 136 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) {
+    const 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_ = session_keys;
 
   // Create the [Initiator Auth] message to send to the remote device.
   DeviceToDeviceInitiatorOperations::CreateInitiatorAuthMessage(
-      session_symmetric_key,
-      connection_->remote_device().persistent_symmetric_key,
+      session_keys_, 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()) {
     Fail("Failed to create [Initiator Auth]");
@@ skipping 15 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_.initiator_encode_key().empty());
+  DCHECK(!session_keys_.responder_encode_key().empty());
   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_), 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