PairingAuthenticator implementation and plumbing.

remoting/protocol/authentication_method.cc

 // Copyright (c) 2012 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 "remoting/protocol/authentication_method.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "crypto/hmac.h"
 #include "remoting/protocol/auth_util.h"
 
 namespace remoting {
 namespace protocol {
 
 // static
 AuthenticationMethod AuthenticationMethod::Invalid() {
   return AuthenticationMethod();
 }
 
 // static
 AuthenticationMethod AuthenticationMethod::Spake2(HashFunction hash_function) {
   return AuthenticationMethod(SPAKE2, hash_function);
 }
 
 // static
+AuthenticationMethod AuthenticationMethod::Spake2Pair() {
+  return AuthenticationMethod(SPAKE2_PAIR, HMAC_SHA256);

[Sergey Ulanov, 2013/05/17 01:57:17]

Do we really need to hash the secret? I think we can use NONE here. It's useful
for pin-based when user reuses the same pin for multiple machines. Since pairing
secret generated randomly hashing it doesn't really add anything.

[rmsousa, 2013/05/17 20:09:03]

There are some cases where this falls back to the PIN. Using HMAC_SHA256 for
everything allows this method to have a consistent hashing algorithm.

[Jamie, 2013/05/21 01:24:33]

I've left it as HMAC_SHA256, for the reason Renato mentions.

+}
+
+// static
 AuthenticationMethod AuthenticationMethod::ThirdParty() {
   return AuthenticationMethod(THIRD_PARTY, NONE);
 }
 
 // static
 AuthenticationMethod AuthenticationMethod::FromString(
     const std::string& value) {
-  if (value == "spake2_plain") {
+  if (value == "spake2_pair") {
+    return Spake2Pair();
+  } else if (value == "spake2_plain") {
     return Spake2(NONE);
   } else if (value == "spake2_hmac") {
     return Spake2(HMAC_SHA256);
   } else if (value == "third_party") {
     return ThirdParty();
   } else {
     return AuthenticationMethod::Invalid();
   }
 }
 
@@ skipping 39 matching lines @@
 }
 
 AuthenticationMethod::HashFunction AuthenticationMethod::hash_function() const {
   DCHECK(is_valid());
   return hash_function_;
 }
 
 const std::string AuthenticationMethod::ToString() const {
   DCHECK(is_valid());
 
-  if (type_ == THIRD_PARTY)
-    return "third_party";
+  switch (type_) {
+    case INVALID:

[Sergey Ulanov, 2013/05/17 01:57:17]

This is not necessary - there is DCHECK on top. Maybe remove DCHECK and add
NOTREACHED() here.

[Jamie, 2013/05/21 01:24:33]

The compiler complains if it's not handled. NOTREACHED is a good suggestion
though. Done.

+      break;
 
-  DCHECK_EQ(type_, SPAKE2);
+    case SPAKE2_PAIR:
+      return "spake2_pair";
 
-  switch (hash_function_) {
-    case NONE:
-      return "spake2_plain";
-    case HMAC_SHA256:
-      return "spake2_hmac";
+    case SPAKE2:
+      switch (hash_function_) {
+        case NONE:
+          return "spake2_plain";
+        case HMAC_SHA256:
+          return "spake2_hmac";
+      }
+      break;
+
+    case THIRD_PARTY:
+      return "third_party";
   }
 
   return "invalid";
 }
 
 bool AuthenticationMethod::operator ==(
     const AuthenticationMethod& other) const {
   return type_ == other.type_ &&
       hash_function_ == other.hash_function_;
 }
@@ skipping 14 matching lines @@
 
   if (!base::Base64Decode(as_string.substr(separator + 1), &value)) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace protocol
 }  // namespace remoting