Updating D2D protocol to v1 to support separate sequence numbers.

components/cryptauth/device_to_device_operations_unittest.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 "base/base64url.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "components/cryptauth/device_to_device_initiator_operations.h"
 #include "components/cryptauth/device_to_device_responder_operations.h"
 #include "components/cryptauth/fake_secure_message_delegate.h"
+#include "components/cryptauth/session_keys.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cryptauth {
 
 namespace {
 
 // The initiator's session public key in base64url form. Note that this is
 // actually a serialized proto.
 const char kInitiatorSessionPublicKeyBase64[] =
     "CAESRQogOlH8DgPMQu7eAt-b6yoTXcazG8mAl6SPC5Ds-LTULIcSIQDZDMqsoYRO4tNMej1FB"
@@ skipping 24 matching lines @@
 // ValidateHelloMessage operations, saving both the outcome and the returned
 // key.
 void SaveValidationResultWithKey(bool* out_success,
                                  std::string* out_key,
                                  bool success,
                                  const std::string& key) {
   *out_success = success;
   *out_key = key;
 }
 
+void SaveValidationResultWithSessionKeys(bool* out_success,
+                                         SessionKeys* out_keys,
+                                         bool success,
+                                         const SessionKeys& keys) {
+  *out_success = success;
+  *out_keys = keys;
+}
+
 }  // namespace
 
 class ProximityAuthDeviceToDeviceOperationsTest : public testing::Test {
  protected:
   ProximityAuthDeviceToDeviceOperationsTest() {}
   ~ProximityAuthDeviceToDeviceOperationsTest() override {}
 
   void SetUp() override {
     ASSERT_TRUE(
         base::Base64UrlDecode(kInitiatorSessionPublicKeyBase64,
                               base::Base64UrlDecodePolicy::REQUIRE_PADDING,
                               &local_session_public_key_));
     local_session_private_key_ =
         secure_message_delegate_.GetPrivateKeyForPublicKey(
             local_session_public_key_);
 
     ASSERT_TRUE(
         base::Base64UrlDecode(kResponderSessionPublicKeyBase64,
                               base::Base64UrlDecodePolicy::REQUIRE_PADDING,
                               &remote_session_public_key_));
     remote_session_private_key_ =
         secure_message_delegate_.GetPrivateKeyForPublicKey(
             remote_session_public_key_);
 
     // Note: FakeSecureMessageDelegate functions are synchronous.
     secure_message_delegate_.DeriveKey(
         local_session_private_key_, remote_session_public_key_,
         base::Bind(&SaveMessageResult, &session_symmetric_key_));
+    session_keys_ = SessionKeys(session_symmetric_key_);
 
     persistent_symmetric_key_ = "persistent symmetric key";
   }
 
   // Creates the initator's [Hello] message.
   std::string CreateHelloMessage() {
     std::string hello_message;
     DeviceToDeviceInitiatorOperations::CreateHelloMessage(
         local_session_public_key_, persistent_symmetric_key_,
         &secure_message_delegate_,
@@ skipping 16 matching lines @@
         base::Bind(&SaveMessageResult, &remote_auth_message));
     EXPECT_FALSE(remote_auth_message.empty());
     return remote_auth_message;
   }
 
   // Creates the initiator's [Initiator Auth] message.
   std::string CreateInitiatorAuthMessage(
       const std::string& remote_auth_message) {
     std::string local_auth_message;
     DeviceToDeviceInitiatorOperations::CreateInitiatorAuthMessage(
-        session_symmetric_key_, persistent_symmetric_key_, remote_auth_message,
+        session_keys_, persistent_symmetric_key_, remote_auth_message,
         &secure_message_delegate_,
         base::Bind(&SaveMessageResult, &local_auth_message));
     EXPECT_FALSE(local_auth_message.empty());
     return local_auth_message;
   }
 
   FakeSecureMessageDelegate secure_message_delegate_;
 
   std::string persistent_symmetric_key_;
   std::string local_session_public_key_;
   std::string local_session_private_key_;
   std::string remote_session_public_key_;
   std::string remote_session_private_key_;
   std::string session_symmetric_key_;
+  SessionKeys session_keys_;
 
   DISALLOW_COPY_AND_ASSIGN(ProximityAuthDeviceToDeviceOperationsTest);
 };
 
 TEST_F(ProximityAuthDeviceToDeviceOperationsTest,
        ValidateHelloMessage_Success) {
   bool validation_success = false;
   std::string hello_public_key;
   DeviceToDeviceResponderOperations::ValidateHelloMessage(
       CreateHelloMessage(), persistent_symmetric_key_,
@@ skipping 18 matching lines @@
   EXPECT_FALSE(validation_success);
   EXPECT_TRUE(hello_public_key.empty());
 }
 
 TEST_F(ProximityAuthDeviceToDeviceOperationsTest,
        ValidateResponderAuthMessage_Success) {
   std::string hello_message = CreateHelloMessage();
   std::string remote_auth_message = CreateResponderAuthMessage(hello_message);
 
   bool validation_success = false;
-  std::string session_symmetric_key;
+  SessionKeys session_keys;
   DeviceToDeviceInitiatorOperations::ValidateResponderAuthMessage(
       remote_auth_message, kResponderPersistentPublicKey,
       persistent_symmetric_key_, local_session_private_key_, hello_message,
       &secure_message_delegate_,
-      base::Bind(&SaveValidationResultWithKey, &validation_success,
-                 &session_symmetric_key));
+      base::Bind(&SaveValidationResultWithSessionKeys, &validation_success,
+                 &session_keys));
 
   EXPECT_TRUE(validation_success);
-  EXPECT_EQ(session_symmetric_key_, session_symmetric_key);
+  EXPECT_EQ(session_keys_.initiator_encode_key(),
+            session_keys.initiator_encode_key());
+  EXPECT_EQ(session_keys_.responder_encode_key(),
+            session_keys.responder_encode_key());
 }
 
 TEST_F(ProximityAuthDeviceToDeviceOperationsTest,
        ValidateResponderAuthMessage_InvalidHelloMessage) {
   std::string hello_message = CreateHelloMessage();
   std::string remote_auth_message = CreateResponderAuthMessage(hello_message);
 
   bool validation_success = true;
-  std::string session_symmetric_key = "non empty";
+  SessionKeys session_keys("non empty");
   DeviceToDeviceInitiatorOperations::ValidateResponderAuthMessage(
       remote_auth_message, kResponderPersistentPublicKey,
       persistent_symmetric_key_, local_session_private_key_,
       "invalid hello message", &secure_message_delegate_,
-      base::Bind(&SaveValidationResultWithKey, &validation_success,
-                 &session_symmetric_key));
+      base::Bind(&SaveValidationResultWithSessionKeys, &validation_success,
+                 &session_keys));
 
   EXPECT_FALSE(validation_success);
-  EXPECT_TRUE(session_symmetric_key.empty());
+  EXPECT_TRUE(session_keys.initiator_encode_key().empty());
+  EXPECT_TRUE(session_keys.responder_encode_key().empty());
 }
 
 TEST_F(ProximityAuthDeviceToDeviceOperationsTest,
        ValidateResponderAuthMessage_InvalidPSK) {
   std::string hello_message = CreateHelloMessage();
   std::string remote_auth_message = CreateResponderAuthMessage(hello_message);
 
   bool validation_success = true;
-  std::string session_symmetric_key = "non empty";
+  SessionKeys session_keys("non empty");
   DeviceToDeviceInitiatorOperations::ValidateResponderAuthMessage(
       remote_auth_message, kResponderPersistentPublicKey,
       "invalid persistent symmetric key", local_session_private_key_,
       hello_message, &secure_message_delegate_,
-      base::Bind(&SaveValidationResultWithKey, &validation_success,
-                 &session_symmetric_key));
+      base::Bind(&SaveValidationResultWithSessionKeys, &validation_success,
+                 &session_keys));
 
   EXPECT_FALSE(validation_success);
-  EXPECT_TRUE(session_symmetric_key.empty());
+  EXPECT_TRUE(session_keys.initiator_encode_key().empty());
+  EXPECT_TRUE(session_keys.responder_encode_key().empty());
 }
 
 TEST_F(ProximityAuthDeviceToDeviceOperationsTest,
        ValidateInitiatorAuthMessage_Success) {
   std::string hello_message = CreateHelloMessage();
   std::string remote_auth_message = CreateResponderAuthMessage(hello_message);
   std::string local_auth_message =
       CreateInitiatorAuthMessage(remote_auth_message);
 
   bool validation_success = false;
   DeviceToDeviceResponderOperations::ValidateInitiatorAuthMessage(
-      local_auth_message, session_symmetric_key_, persistent_symmetric_key_,
+      local_auth_message, session_keys_, persistent_symmetric_key_,
       remote_auth_message, &secure_message_delegate_,
       base::Bind(&SaveValidationResult, &validation_success));
 
   EXPECT_TRUE(validation_success);
 }
 
 TEST_F(ProximityAuthDeviceToDeviceOperationsTest,
        ValidateInitiatorAuthMessage_InvalidRemoteAuth) {
   std::string hello_message = CreateHelloMessage();
   std::string remote_auth_message = CreateResponderAuthMessage(hello_message);
   std::string local_auth_message =
       CreateInitiatorAuthMessage(remote_auth_message);
 
   bool validation_success = true;
   DeviceToDeviceResponderOperations::ValidateInitiatorAuthMessage(
-      local_auth_message, session_symmetric_key_, persistent_symmetric_key_,
+      local_auth_message, session_keys_, persistent_symmetric_key_,
       "invalid remote auth", &secure_message_delegate_,
       base::Bind(&SaveValidationResult, &validation_success));
 
   EXPECT_FALSE(validation_success);
 }
 
 TEST_F(ProximityAuthDeviceToDeviceOperationsTest,
        ValidateInitiatorAuthMessage_InvalidPSK) {
   std::string hello_message = CreateHelloMessage();
   std::string remote_auth_message = CreateResponderAuthMessage(hello_message);
   std::string local_auth_message =
       CreateInitiatorAuthMessage(remote_auth_message);
 
   bool validation_success = true;
   DeviceToDeviceResponderOperations::ValidateInitiatorAuthMessage(
-      local_auth_message, session_symmetric_key_,
-      "invalid persistent symmetric key", remote_auth_message,
-      &secure_message_delegate_,
+      local_auth_message, session_keys_, "invalid persistent symmetric key",
+      remote_auth_message, &secure_message_delegate_,
       base::Bind(&SaveValidationResult, &validation_success));
 
   EXPECT_FALSE(validation_success);
 }
 
 }  // namespace cryptauth