Updating D2D protocol to v1 to support separate sequence numbers.

components/cryptauth/device_to_device_responder_operations.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_responder_operations.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "components/cryptauth/proto/cryptauth_api.pb.h"
 #include "components/cryptauth/proto/securemessage.pb.h"
 #include "components/cryptauth/secure_message_delegate.h"
+#include "components/cryptauth/session_keys.h"
 #include "components/proximity_auth/logging/logging.h"
 
 namespace cryptauth {
 
 namespace {
 
 // TODO(tengs): Due to a bug with the ChromeOS secure message daemon, we cannot
 // create SecureMessages with empty payloads. To workaround this bug, this value
 // is put into the payload if it would otherwise be empty.
 // See crbug.com/512894.
 const char kPayloadFiller[] = "\xae";
 
 // The version to put in the GcmMetadata field.
 const int kGcmMetadataVersion = 1;
 
+// The D2D protocol version.
+const int kD2DProtocolVersion = 1;
+
 // Callback for DeviceToDeviceResponderOperations::ValidateHelloMessage(),
 // after the [Hello] message is unwrapped.
 void OnHelloMessageUnwrapped(
     const DeviceToDeviceResponderOperations::ValidateHelloCallback& callback,
     bool verified,
     const std::string& payload,
     const securemessage::Header& header) {
   securemessage::InitiatorHello initiator_hello;
-  if (!verified || !initiator_hello.ParseFromString(header.public_metadata())) {
+  if (!verified || !initiator_hello.ParseFromString(header.public_metadata()) ||
+      initiator_hello.protocol_version() != kD2DProtocolVersion) {
     callback.Run(false, std::string());
     return;
   }
 
   callback.Run(true, initiator_hello.public_dh_key().SerializeAsString());
 }
 
 // Helper struct containing all the context needed to create the [Responder
 // Auth] message.
 struct CreateResponderAuthMessageContext {
@@ skipping 108 matching lines @@
 
   // Store the responder's session public key in plaintext in the header.
   securemessage::ResponderHello responder_hello;
   if (!responder_hello.mutable_public_dh_key()->ParseFromString(
           context.session_public_key)) {
     PA_LOG(ERROR) << "Error parsing public key while creating [Responder Auth]";
     PA_LOG(ERROR) << context.session_public_key;
     context.callback.Run(std::string());
     return;
   }
+  responder_hello.set_protocol_version(kD2DProtocolVersion);
 
   // Create the outer most message, wrapping the other messages created
   // previously.
   securemessage::DeviceToDeviceMessage device_to_device_message;
   device_to_device_message.set_message(context.middle_message);
   device_to_device_message.set_sequence_number(1);
 
   SecureMessageDelegate::CreateOptions create_options;
   create_options.encryption_scheme = securemessage::AES_256_CBC;
   create_options.signature_scheme = securemessage::HMAC_SHA256;
   create_options.public_metadata = gcm_metadata.SerializeAsString();
   responder_hello.SerializeToString(&create_options.decryption_key_id);
 
   context.secure_message_delegate->CreateSecureMessage(
-      device_to_device_message.SerializeAsString(), session_symmetric_key,
-      create_options, context.callback);
+      device_to_device_message.SerializeAsString(),
+      SessionKeys(session_symmetric_key).responder_encode_key(), create_options,
+      context.callback);
 }
 
 // Helper struct containing all the context needed to validate the [Initiator
 // Auth] message.
 struct ValidateInitiatorAuthMessageContext {
   std::string persistent_symmetric_key;
   std::string responder_auth_message;
   SecureMessageDelegate* secure_message_delegate;
   DeviceToDeviceResponderOperations::ValidationCallback callback;
 };
@@ skipping 17 matching lines @@
     const securemessage::Header& header) {
   if (!verified) {
     PA_LOG(INFO) << "Failed to verify outer [Initiator Auth] message";
     context.callback.Run(false);
     return;
   }
 
   // Parse the decrypted payload.
   securemessage::DeviceToDeviceMessage device_to_device_message;
   if (!device_to_device_message.ParseFromString(payload) ||
-      device_to_device_message.sequence_number() != 2) {
+      device_to_device_message.sequence_number() != 1) {
     PA_LOG(INFO) << "Failed to validate DeviceToDeviceMessage payload.";
     context.callback.Run(false);
     return;
   }
 
   // Unwrap the inner message of [Initiator Auth].
   SecureMessageDelegate::UnwrapOptions unwrap_options;
   unwrap_options.encryption_scheme = securemessage::AES_256_CBC;
   unwrap_options.signature_scheme = securemessage::HMAC_SHA256;
   unwrap_options.associated_data = context.responder_auth_message;
@@ skipping 62 matching lines @@
   // To create the [Responder Auth] message, we need to first parse the
   // initiator's [Hello] message and extract the initiator's session public key.
   DeviceToDeviceResponderOperations::ValidateHelloMessage(
       hello_message, persistent_symmetric_key, secure_message_delegate,
       base::Bind(&OnHelloMessageValidatedForResponderAuth, context));
 }
 
 // static
 void DeviceToDeviceResponderOperations::ValidateInitiatorAuthMessage(
     const std::string& initiator_auth_message,
-    const std::string& session_symmetric_key,
+    SessionKeys* session_keys,

[Tim Song, 2017/05/22 23:18:24]

You should be able to use "const SessionKey&" instead.

[sacomoto, 2017/05/23 09:50:14]

Done.

     const std::string& persistent_symmetric_key,
     const std::string& responder_auth_message,
     SecureMessageDelegate* secure_message_delegate,
     const ValidationCallback& callback) {
   // The [Initiator Auth] message has the structure:
   // {
   //   header: Sig(payload1, session_symmetric_key)
   //   payload1: Enc({
   //     sequence_number: 2,
   //     body: {
   //       header: Sig(payload2 + responder_auth_message,
   //       persistent_symmetric_key)
   //       payload2: ""
   //     }
   //   }, session_symmetric_key)
   // }
   ValidateInitiatorAuthMessageContext context = {
       persistent_symmetric_key, responder_auth_message, secure_message_delegate,
       callback};
 
   SecureMessageDelegate::UnwrapOptions unwrap_options;
   unwrap_options.encryption_scheme = securemessage::AES_256_CBC;
   unwrap_options.signature_scheme = securemessage::HMAC_SHA256;
   secure_message_delegate->UnwrapSecureMessage(
-      initiator_auth_message, session_symmetric_key, unwrap_options,
+      initiator_auth_message, session_keys->initiator_encode_key(),
+      unwrap_options,
       base::Bind(&OnOuterMessageUnwrappedForInitiatorAuth, context));
 }
 
 }  // cryptauth