chrome.platformKeys: Add filtering by certificate types

chrome/browser/chromeos/platform_keys/platform_keys_service.cc

 // Copyright 2014 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/chromeos/platform_keys/platform_keys_service.h"
 
 #include "base/base64.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/values.h"
@@ skipping 463 matching lines @@
         service_->TaskFinished(this);
         // |this| might be invalid now.
         return;
     }
   }
 
   // Retrieves all certificates matching |request_|. Will call back to
   // |GotMatchingCerts()|.
   void GetMatchingCerts() {
     platform_keys::subtle::SelectClientCertificates(
-        request_,
+        request_.certificate_authorities,
         base::Bind(&SelectTask::GotMatchingCerts, weak_factory_.GetWeakPtr()),
         service_->browser_context_);
   }
 
   // If the certificate request could be processed successfully, |matches| will
   // contain the list of matching certificates (maybe empty) and |error_message|
   // will be empty. If an error occurred, |matches| will be null and
   // |error_message| contain an error message.
   void GotMatchingCerts(scoped_ptr<net::CertificateList> matches,
                         const std::string& error_message) {
     if (!error_message.empty()) {
       next_step_ = Step::DONE;
       callback_.Run(nullptr /* no certificates */, error_message);
       DoStep();
       return;
     }
-    matches_.swap(*matches);
+
+    // If the type field does not contain any entries, certificates of all types
+    // shall be returned.
+    if (request_.certificate_key_types.size() == 0) {
+      matches_.swap(*matches);
+      DoStep();
+      return;
+    }
+
+    // Filter the retrieved certificates returning only those whose type is
+    // equal to one of the entries in the type field of the certificate request.
+    for (scoped_refptr<net::X509Certificate>& certificate : *matches) {
+      net::X509Certificate::PublicKeyType actual_key_type =
+          net::X509Certificate::kPublicKeyTypeUnknown;
+      size_t unused_key_size = 0;
+      net::X509Certificate::GetPublicKeyInfo(
+          certificate->os_cert_handle(), &unused_key_size, &actual_key_type);
+      const std::vector<net::X509Certificate::PublicKeyType>& accepted_types =
+          request_.certificate_key_types;
+      if (std::find(accepted_types.begin(), accepted_types.end(),
+                    actual_key_type) != accepted_types.end()) {
+        matches_.push_back(certificate.Pass());
+      }
+    }
     DoStep();
   }
 
   // Calls |service_->select_delegate_->Select()| to select a cert from
   // |matches_|, which will be stored in |selected_cert_|.
   // Will call back to |GotSelection()|.
   void SelectCerts() {
     CHECK(interactive_);
     if (matches_.empty()) {
       // Don't show a select dialog if no certificate is matching.
@@ skipping 249 matching lines @@
     const GetPlatformKeysCallback& callback,
     scoped_ptr<base::Value> value) {
   scoped_ptr<KeyEntries> key_entries(new KeyEntries);
   if (value)
     key_entries = KeyEntriesFromState(*value);
 
   callback.Run(key_entries.Pass());
 }
 
 }  // namespace chromeos