Reland: Password manager: Gnome support for Public Suffix List matching

chrome/browser/password_manager/native_backend_gnome_x.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 "chrome/browser/password_manager/native_backend_gnome_x.h"
 
 #include <dlfcn.h>
 #include <gnome-keyring.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time/time.h"
+#include "chrome/browser/password_manager/psl_matching_helper.h"
 #include "components/autofill/core/common/password_form.h"
 #include "content/public/browser/browser_thread.h"
 
 using autofill::PasswordForm;
 using base::UTF8ToUTF16;
 using base::UTF16ToUTF8;
 using content::BrowserThread;
 
 #define GNOME_KEYRING_DEFINE_POINTER(name) \
   typeof(&::gnome_keyring_##name) GnomeKeyringLoader::gnome_keyring_##name;
@@ skipping 58 matching lines @@
 
 #endif  // defined(DLOPEN_GNOME_KEYRING)
 
 namespace {
 
 const char kGnomeKeyringAppString[] = "chrome";
 
 // Convert the attributes of a given keyring entry into a new PasswordForm.
 // Note: does *not* get the actual password, as that is not a key attribute!
 // Returns NULL if the attributes are for the wrong application.
-PasswordForm* FormFromAttributes(GnomeKeyringAttributeList* attrs) {
+scoped_ptr<PasswordForm> FormFromAttributes(GnomeKeyringAttributeList* attrs) {
   // Read the string and int attributes into the appropriate map.
   std::map<std::string, std::string> string_attr_map;
   std::map<std::string, uint32_t> uint_attr_map;
   for (guint i = 0; i < attrs->len; ++i) {
     GnomeKeyringAttribute attr = gnome_keyring_attribute_list_index(attrs, i);
     if (attr.type == GNOME_KEYRING_ATTRIBUTE_TYPE_STRING)
       string_attr_map[attr.name] = attr.value.string;
     else if (attr.type == GNOME_KEYRING_ATTRIBUTE_TYPE_UINT32)
       uint_attr_map[attr.name] = attr.value.integer;
   }
   // Check to make sure this is a password we care about.
   const std::string& app_value = string_attr_map["application"];
   if (!base::StringPiece(app_value).starts_with(kGnomeKeyringAppString))
-    return NULL;
+    return scoped_ptr<PasswordForm>();
 
-  PasswordForm* form = new PasswordForm();
+  scoped_ptr<PasswordForm> form(new PasswordForm());
   form->origin = GURL(string_attr_map["origin_url"]);
   form->action = GURL(string_attr_map["action_url"]);
   form->username_element = UTF8ToUTF16(string_attr_map["username_element"]);
   form->username_value = UTF8ToUTF16(string_attr_map["username_value"]);
   form->password_element = UTF8ToUTF16(string_attr_map["password_element"]);
   form->submit_element = UTF8ToUTF16(string_attr_map["submit_element"]);
   form->signon_realm = string_attr_map["signon_realm"];
   form->ssl_valid = uint_attr_map["ssl_valid"];
   form->preferred = uint_attr_map["preferred"];
   int64 date_created = 0;
   bool date_ok = base::StringToInt64(string_attr_map["date_created"],
                                      &date_created);
   DCHECK(date_ok);
   form->date_created = base::Time::FromTimeT(date_created);
   form->blacklisted_by_user = uint_attr_map["blacklisted_by_user"];
   form->scheme = static_cast<PasswordForm::Scheme>(uint_attr_map["scheme"]);
 
-  return form;
+  return form.Pass();
 }
 
 // Parse all the results from the given GList into a PasswordFormList, and free
 // the GList. PasswordForms are allocated on the heap, and should be deleted by
-// the consumer.
+// the consumer. If not empty, |filter_by_signon_realm| is used to filter out
+// results -- only credentials with signon realms passing the PSL matching
+// (done by |helper|) against |filter_by_signon_realm| will be kept.
 void ConvertFormList(GList* found,
+                     const std::string& filter_by_signon_realm,
+                     const PSLMatchingHelper& helper,
                      NativeBackendGnome::PasswordFormList* forms) {
+  PSLMatchingHelper::PSLDomainMatchMetric psl_domain_match_metric =
+      PSLMatchingHelper::PSL_DOMAIN_MATCH_NONE;
   for (GList* element = g_list_first(found); element != NULL;
        element = g_list_next(element)) {
     GnomeKeyringFound* data = static_cast<GnomeKeyringFound*>(element->data);
     GnomeKeyringAttributeList* attrs = data->attributes;
 
-    PasswordForm* form = FormFromAttributes(attrs);
+    scoped_ptr<PasswordForm> form(FormFromAttributes(attrs));
     if (form) {
+      if (!filter_by_signon_realm.empty() &&
+          form->signon_realm != filter_by_signon_realm) {
+        // This is not an exact match, we try PSL matching.
+        if (!(PSLMatchingHelper::IsPublicSuffixDomainMatch(
+                 filter_by_signon_realm, form->signon_realm))) {
+          continue;
+        }
+        psl_domain_match_metric = PSLMatchingHelper::PSL_DOMAIN_MATCH_FOUND;
+        form->original_signon_realm = form->signon_realm;
+      }
       if (data->secret) {
         form->password_value = UTF8ToUTF16(data->secret);
       } else {
         LOG(WARNING) << "Unable to access password from list element!";
       }
-      forms->push_back(form);
+      forms->push_back(form.release());
     } else {
       LOG(WARNING) << "Could not initialize PasswordForm from attributes!";
     }
   }
+  if (!filter_by_signon_realm.empty()) {
+    UMA_HISTOGRAM_ENUMERATION(
+        "PasswordManager.PslDomainMatchTriggering",
+        helper.IsMatchingEnabled()
+            ? psl_domain_match_metric
+            : PSLMatchingHelper::PSL_DOMAIN_MATCH_DISABLED,
+        PSLMatchingHelper::PSL_DOMAIN_MATCH_COUNT);
+  }
 }
 
 // Schema is analagous to the fields in PasswordForm.
 const GnomeKeyringPasswordSchema kGnomeSchema = {
   GNOME_KEYRING_ITEM_GENERIC_SECRET, {
     { "origin_url", GNOME_KEYRING_ATTRIBUTE_TYPE_STRING },
     { "action_url", GNOME_KEYRING_ATTRIBUTE_TYPE_STRING },
     { "username_element", GNOME_KEYRING_ATTRIBUTE_TYPE_STRING },
     { "username_value", GNOME_KEYRING_ATTRIBUTE_TYPE_STRING },
     { "password_element", GNOME_KEYRING_ATTRIBUTE_TYPE_STRING },
@@ skipping 73 matching lines @@
 
   // All these callbacks are called on UI thread.
   static void OnOperationDone(GnomeKeyringResult result, gpointer data);
 
   static void OnOperationGetList(GnomeKeyringResult result, GList* list,
                                  gpointer data);
 
   base::WaitableEvent event_;
   GnomeKeyringResult result_;
   NativeBackendGnome::PasswordFormList forms_;
+  // Two additional arguments to OnOperationGetList:
+  // If the credential search is related to a particular form,
+  // |original_signon_realm_| contains the signon realm of that form. It is used
+  // to filter the relevant results out of all the found ones.
+  std::string original_signon_realm_;
+  const PSLMatchingHelper helper_;
 };
 
 void GKRMethod::AddLogin(const PasswordForm& form, const char* app_string) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   time_t date_created = form.date_created.ToTimeT();
   // If we are asked to save a password with 0 date, use the current time.
   // We don't want to actually save passwords as though on January 1, 1970.
   if (!date_created)
     date_created = time(NULL);
   gnome_keyring_store_password(
@@ skipping 16 matching lines @@
       "date_created", base::Int64ToString(date_created).c_str(),
       "blacklisted_by_user", form.blacklisted_by_user,
       "scheme", form.scheme,
       "application", app_string,
       NULL);
 }
 
 void GKRMethod::AddLoginSearch(const PasswordForm& form,
                                const char* app_string) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  original_signon_realm_ = form.signon_realm;
   // Search GNOME Keyring for matching passwords to update.
   ScopedAttributeList attrs(gnome_keyring_attribute_list_new());
   AppendString(&attrs, "origin_url", form.origin.spec());
   AppendString(&attrs, "username_element", UTF16ToUTF8(form.username_element));
   AppendString(&attrs, "username_value", UTF16ToUTF8(form.username_value));
   AppendString(&attrs, "password_element", UTF16ToUTF8(form.password_element));
   AppendString(&attrs, "submit_element", UTF16ToUTF8(form.submit_element));
   AppendString(&attrs, "signon_realm", form.signon_realm);
   AppendString(&attrs, "application", app_string);
   gnome_keyring_find_items(GNOME_KEYRING_ITEM_GENERIC_SECRET,
                            attrs.get(),
                            OnOperationGetList,
                            /*data=*/this,
                            /*destroy_data=*/NULL);
 }
 
 void GKRMethod::UpdateLoginSearch(const PasswordForm& form,
                                   const char* app_string) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  original_signon_realm_ = form.signon_realm;
   // Search GNOME Keyring for matching passwords to update.
   ScopedAttributeList attrs(gnome_keyring_attribute_list_new());
   AppendString(&attrs, "origin_url", form.origin.spec());
   AppendString(&attrs, "username_element", UTF16ToUTF8(form.username_element));
   AppendString(&attrs, "username_value", UTF16ToUTF8(form.username_value));
   AppendString(&attrs, "password_element", UTF16ToUTF8(form.password_element));
   AppendString(&attrs, "signon_realm", form.signon_realm);
   AppendString(&attrs, "application", app_string);
   gnome_keyring_find_items(GNOME_KEYRING_ITEM_GENERIC_SECRET,
                            attrs.get(),
@@ skipping 16 matching lines @@
       "username_value", UTF16ToUTF8(form.username_value).c_str(),
       "password_element", UTF16ToUTF8(form.password_element).c_str(),
       "submit_element", UTF16ToUTF8(form.submit_element).c_str(),
       "signon_realm", form.signon_realm.c_str(),
       "application", app_string,
       NULL);
 }
 
 void GKRMethod::GetLogins(const PasswordForm& form, const char* app_string) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  original_signon_realm_ = form.signon_realm;
   // Search GNOME Keyring for matching passwords.
   ScopedAttributeList attrs(gnome_keyring_attribute_list_new());
-  AppendString(&attrs, "signon_realm", form.signon_realm);
+  if (!helper_.ShouldPSLDomainMatchingApply(
+           PSLMatchingHelper::GetRegistryControlledDomain(
+               GURL(form.signon_realm)))) {
+    AppendString(&attrs, "signon_realm", form.signon_realm);
+  }
   AppendString(&attrs, "application", app_string);
   gnome_keyring_find_items(GNOME_KEYRING_ITEM_GENERIC_SECRET,
                            attrs.get(),
                            OnOperationGetList,
                            /*data=*/this,
                            /*destroy_data=*/NULL);
 }
 
 void GKRMethod::GetLoginsList(uint32_t blacklisted_by_user,
                               const char* app_string) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  original_signon_realm_.clear();
   // Search GNOME Keyring for matching passwords.
   ScopedAttributeList attrs(gnome_keyring_attribute_list_new());
   AppendUint32(&attrs, "blacklisted_by_user", blacklisted_by_user);
   AppendString(&attrs, "application", app_string);
   gnome_keyring_find_items(GNOME_KEYRING_ITEM_GENERIC_SECRET,
                            attrs.get(),
                            OnOperationGetList,
                            /*data=*/this,
                            /*destroy_data=*/NULL);
 }
 
 void GKRMethod::GetAllLogins(const char* app_string) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  original_signon_realm_.clear();
   // We need to search for something, otherwise we get no results - so
   // we search for the fixed application string.
   ScopedAttributeList attrs(gnome_keyring_attribute_list_new());
   AppendString(&attrs, "application", app_string);
   gnome_keyring_find_items(GNOME_KEYRING_ITEM_GENERIC_SECRET,
                            attrs.get(),
                            OnOperationGetList,
                            /*data=*/this,
                            /*destroy_data=*/NULL);
 }
@@ skipping 46 matching lines @@
   method->event_.Signal();
 }
 
 // static
 void GKRMethod::OnOperationGetList(GnomeKeyringResult result, GList* list,
                                    gpointer data) {
   GKRMethod* method = static_cast<GKRMethod*>(data);
   method->result_ = result;
   method->forms_.clear();
   // |list| will be freed after this callback returns, so convert it now.
-  ConvertFormList(list, &method->forms_);
+  ConvertFormList(
+      list, method->original_signon_realm_, method->helper_, &method->forms_);
+  method->original_signon_realm_.clear();
   method->event_.Signal();
 }
 
 }  // namespace
 
 NativeBackendGnome::NativeBackendGnome(LocalProfileId id, PrefService* prefs)
     : profile_id_(id), prefs_(prefs) {
   // TODO(mdm): after a few more releases, remove the code which is now dead due
   // to the true || here, and simplify this code. We don't do it yet to make it
   // easier to revert if necessary.
@@ skipping 309 matching lines @@
     // Each other profile must be able to migrate the shared data as well,
     // so we must leave it alone. After a few releases, we'll add code to
     // delete them, and eventually remove this migration code.
     // TODO(mdm): follow through with the plan above.
     PasswordStoreX::SetPasswordsUseLocalProfileId(prefs_);
   } else {
     // We failed to migrate for some reason. Use the old app string.
     app_string_ = kGnomeKeyringAppString;
   }
 }