Certificate Transparency: Code for unpacking EV cert hashes whitelist

net/ssl/ssl_config_service.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 "net/ssl/ssl_config_service.h"
 
 #include "base/lazy_instance.h"
 #include "base/synchronization/lock.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 
 namespace net {
 
 SSLConfigService::SSLConfigService()
     : observer_list_(ObserverList<Observer>::NOTIFY_EXISTING_ONLY) {
 }
 
-// GlobalCRLSet holds a reference to the global CRLSet. It simply wraps a lock
-// around a scoped_refptr so that getting a reference doesn't race with
-// updating the CRLSet.
-class GlobalCRLSet {
+// GlobalSSLObject holds a reference to a global SSL object, such as the
+// CRLSet or the EVCertsWhitelist. It simply wraps a lock  around a
+// scoped_refptr so that getting a reference doesn't race with
+// updating the global object.
+template <class T>
+class GlobalSSLObject {
  public:
-  void Set(const scoped_refptr<CRLSet>& new_crl_set) {
+  void Set(const scoped_refptr<T>& new_ssl_object) {
     base::AutoLock locked(lock_);
-    crl_set_ = new_crl_set;
+    ssl_object_ = new_ssl_object;
   }
 
-  scoped_refptr<CRLSet> Get() const {
+  scoped_refptr<T> Get() const {
     base::AutoLock locked(lock_);
-    return crl_set_;
+    return ssl_object_;
   }
 
  private:
-  scoped_refptr<CRLSet> crl_set_;
+  scoped_refptr<T> ssl_object_;
   mutable base::Lock lock_;
 };
 
+typedef GlobalSSLObject<CRLSet> GlobalCRLSet;
+typedef GlobalSSLObject<ct::EVCertsWhitelist> GlobalEVCertsWhitelist;
+
 base::LazyInstance<GlobalCRLSet>::Leaky g_crl_set = LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<GlobalEVCertsWhitelist>::Leaky g_ev_whitelist =
+    LAZY_INSTANCE_INITIALIZER;
 
 // static
 void SSLConfigService::SetCRLSet(scoped_refptr<CRLSet> crl_set) {
   // Note: this can be called concurently with GetCRLSet().
   g_crl_set.Get().Set(crl_set);
 }
 
 // static
 scoped_refptr<CRLSet> SSLConfigService::GetCRLSet() {
   return g_crl_set.Get().Get();
 }
 
+// static
+void SSLConfigService::SetEVCertsWhitelist(
+    scoped_refptr<ct::EVCertsWhitelist> ev_whitelist) {
+  g_ev_whitelist.Get().Set(ev_whitelist);
+}
+
+scoped_refptr<ct::EVCertsWhitelist> SSLConfigService::GetEVCertsWhitelist() {
+  return g_ev_whitelist.Get().Get();
+}
+// static
+
 void SSLConfigService::AddObserver(Observer* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void SSLConfigService::RemoveObserver(Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void SSLConfigService::NotifySSLConfigChange() {
   FOR_EACH_OBSERVER(Observer, observer_list_, OnSSLConfigChanged());
@@ skipping 25 matching lines @@
 bool SSLConfigService::IsSNIAvailable(SSLConfigService* service) {
   if (!service)
     return false;
 
   SSLConfig ssl_config;
   service->GetSSLConfig(&ssl_config);
   return ssl_config.version_max >= SSL_PROTOCOL_VERSION_TLS1;
 }
 
 }  // namespace net