Third Party authentication protocol.

remoting/protocol/authentication_method.h

 // 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.
 
 // AuthenticationMethod represents an authentication algorithm and its
 // configuration. It knows how to parse and format authentication
 // method names.
 // Currently the following methods are supported:
 //   spake2_plain - SPAKE2 without hashing applied to the password.
 //   spake2_hmac - SPAKE2 with HMAC hashing of the password.
 
 #ifndef REMOTING_PROTOCOL_AUTHENTICATION_METHOD_H_
 #define REMOTING_PROTOCOL_AUTHENTICATION_METHOD_H_
 
 #include <string>
 
 namespace remoting {
 namespace protocol {
 
 class Authenticator;
 
 class AuthenticationMethod {
  public:
+  enum MethodType {
+    INVALID,
+    SPAKE2,
+    THIRD_PARTY
+  };
+
   enum HashFunction {

[Wez, 2013/03/22 06:17:01]

Given that HashFunction only applies to SPAKE2, why not fold it in to MethodType
and have four instead of three?

[rmsousa, 2013/03/22 21:19:05]

There are some explicit uses of the hashfunction enum (e.g. we call
ApplyHashFunction as a static while setting the PIN for the host, also, the
SharedSecretHash class below)

     NONE,
     HMAC_SHA256,
   };
 
   // Constructors for various authentication methods.
   static AuthenticationMethod Invalid();
   static AuthenticationMethod Spake2(HashFunction hash_function);
+  static AuthenticationMethod ThirdParty();
 
   // Parses a string that defines an authentication method. Returns an
   // invalid value if the string is invalid.
   static AuthenticationMethod FromString(const std::string& value);
 
   // Applies the specified hash function to |shared_secret| with the
   // specified |tag| as a key.
   static std::string ApplyHashFunction(HashFunction hash_function,
                                        const std::string& tag,
                                        const std::string& shared_secret);
 
-  // Returns true
-  bool is_valid() const { return !invalid_; }
+  bool is_valid() const { return method_type_ != INVALID; }
+
+  MethodType method_type() const { return method_type_; }
 
   // Following methods are valid only when is_valid() returns true.
 
   // Hash function applied to the shared secret on both ends.
   HashFunction hash_function() const;
 
   // Returns string representation of the value stored in this object.
   const std::string ToString() const;
 
   // Comparison operators so that std::find() can be used with
   // collections of this class.
   bool operator ==(const AuthenticationMethod& other) const;
   bool operator !=(const AuthenticationMethod& other) const {
     return !(*this == other);
   }
 
- private:
+ protected:
   AuthenticationMethod();
-  explicit AuthenticationMethod(HashFunction hash_function);
+  AuthenticationMethod(MethodType method_type, HashFunction hash_function);
 
-  bool invalid_;
+  MethodType method_type_;

[Sergey Ulanov, 2013/03/22 05:58:43]

nit: type_

[rmsousa, 2013/03/22 21:19:05]

Done.

   HashFunction hash_function_;
 };
 
 // SharedSecretHash stores hash of a host secret paired with the type
 // of the hashing function.
 struct SharedSecretHash {
   AuthenticationMethod::HashFunction hash_function;
   std::string value;
 
   // Parse string representation of a shared secret hash. The |as_string|
   // must be in form "<hash_function>:<hash_value_base64>".
   bool Parse(const std::string& as_string);
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_AUTHENTICATION_METHOD_H_