Updating D2D protocol to v1 to support separate sequence numbers.

components/cryptauth/device_to_device_responder_operations.h

 // 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.
 
 #ifndef COMPONENTS_CRYPTAUTH_DEVICE_TO_DEVICE_RESPONDER_OPERATIONS_H_
 #define COMPONENTS_CRYPTAUTH_DEVICE_TO_DEVICE_RESPONDER_OPERATIONS_H_
 
 #include <string>
 
 #include "base/callback_forward.h"
 #include "base/macros.h"
 
 namespace cryptauth {
 
 class SecureMessageDelegate;
+class SessionKeys;
 
 // Utility class containing operations in the DeviceToDevice protocol that the
 // initiator needs to perform. For Smart Lock, in which a phone unlocks a
 // laptop, the responder is the phone. Because the responder side of this
 // protocol does not run in Chrome, this class is implemented solely for
 // testing purposes.
 //
 // All operations are asynchronous because we use the SecureMessageDelegate for
 // crypto operations, whose implementation may be asynchronous.
 //
@@ skipping 59 matching lines @@
       const std::string& session_private_key,
       const std::string& persistent_private_key,
       const std::string& persistent_symmetric_key,
       SecureMessageDelegate* secure_message_delegate,
       const MessageCallback& callback);
 
   // Validates that the [Initiator Auth] message, received from the initiator,
   // is properly signed and encrypted.
   // |initiator_auth_message|: The bytes of the [Local Auth] message to
   // validate.
-  // |session_symmetric_key|: The derived symmetric key used just for the
-  //     session.
+  // |session_keys|: The derived symmetric keys used just for the session.
   // |persistent_symmetric_key|: The long-term symmetric key that is shared by
   //     the initiator and responder.
   // |secure_message_delegate|: Delegate for SecureMessage operations. This
   //     instance is not owned, and must live until after |callback| is invoked.
   // |callback|: Invoked upon operation completion with whether
   //     |responder_auth_message| is validated successfully.
   static void ValidateInitiatorAuthMessage(
       const std::string& initiator_auth_message,
-      const std::string& session_symmetric_key,
+      SessionKeys* session_keys,
       const std::string& persistent_symmetric_key,
       const std::string& responder_auth_message,
       SecureMessageDelegate* secure_message_delegate,
       const ValidationCallback& callback);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(DeviceToDeviceResponderOperations);
 };
 
 }  // cryptauth
 
 #endif  // COMPONENTS_CRYPTAUTH_DEVICE_TO_DEVICE_RESPONDER_OPERATIONS_H_