Bug 1024809 - (OneCRL) Create a blocklist mechanism to revoke intermediate certs. r=keeler,Unfocused
☠☠ backed out by 1e0e447828ec ☠ ☠
authorMark Goodwin <mgoodwin@mozilla.com>, Harsh Pathak <hpathak@mozilla.com>
Thu, 27 Nov 2014 04:12:00 +0100
changeset 217849 761071f57ab615bfc6c93148ac9e07bab141257b
parent 217848 eeb943d179c5bc20052df881238c938b1ff5f7dd
child 217850 7f34fc3870ba819ca88ca6be5447100ad99549df
push id52383
push usercbook@mozilla.com
push dateThu, 27 Nov 2014 14:55:01 +0000
treeherdermozilla-inbound@7f34fc3870ba [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerskeeler, Unfocused
bugs1024809
milestone36.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1024809 - (OneCRL) Create a blocklist mechanism to revoke intermediate certs. r=keeler,Unfocused
security/certverifier/NSSCertDBTrustDomain.cpp
security/certverifier/NSSCertDBTrustDomain.h
security/manager/boot/public/moz.build
security/manager/boot/public/nsICertBlocklist.idl
security/manager/boot/src/CertBlocklist.cpp
security/manager/boot/src/CertBlocklist.h
security/manager/boot/src/moz.build
security/manager/boot/src/nsBOOTModule.cpp
security/manager/ssl/src/nsNSSComponent.cpp
security/manager/ssl/tests/unit/test_cert_blocklist.js
security/manager/ssl/tests/unit/test_onecrl/sample_revocations.txt
security/manager/ssl/tests/unit/tlsserver/cert9.db
security/manager/ssl/tests/unit/tlsserver/generate_certs.sh
security/manager/ssl/tests/unit/tlsserver/key4.db
security/manager/ssl/tests/unit/tlsserver/test-int-ee.der
security/manager/ssl/tests/unit/tlsserver/test-int.der
security/manager/ssl/tests/unit/tlsserver/unknown-issuer.der
security/manager/ssl/tests/unit/xpcshell.ini
toolkit/mozapps/extensions/nsBlocklistService.js
--- a/security/certverifier/NSSCertDBTrustDomain.cpp
+++ b/security/certverifier/NSSCertDBTrustDomain.cpp
@@ -4,22 +4,23 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "NSSCertDBTrustDomain.h"
 
 #include <stdint.h>
 
 #include "ExtendedValidation.h"
-#include "nsNSSCertificate.h"
-#include "NSSErrorsService.h"
 #include "OCSPRequestor.h"
 #include "certdb.h"
 #include "mozilla/Telemetry.h"
+#include "nsNSSCertificate.h"
 #include "nss.h"
+#include "NSSErrorsService.h"
+#include "nsServiceManagerUtils.h"
 #include "pk11pub.h"
 #include "pkix/pkix.h"
 #include "pkix/pkixnss.h"
 #include "pkix/ScopedPtr.h"
 #include "prerror.h"
 #include "prmem.h"
 #include "prprf.h"
 #include "ScopedNSSTypes.h"
@@ -63,16 +64,17 @@ NSSCertDBTrustDomain::NSSCertDBTrustDoma
   , mOCSPFetching(ocspFetching)
   , mOCSPCache(ocspCache)
   , mPinArg(pinArg)
   , mOCSPGetConfig(ocspGETConfig)
   , mPinningMode(pinningMode)
   , mMinimumNonECCBits(forEV ? MINIMUM_NON_ECC_BITS_EV : MINIMUM_NON_ECC_BITS_DV)
   , mHostname(hostname)
   , mBuiltChain(builtChain)
+  , mCertBlocklist(do_GetService(NS_CERTBLOCKLIST_CONTRACTID))
 {
 }
 
 // E=igca@sgdn.pm.gouv.fr,CN=IGC/A,OU=DCSSI,O=PM/SGDN,L=Paris,ST=France,C=FR
 static const uint8_t ANSSI_SUBJECT_DATA[] =
                        "\x30\x81\x85\x31\x0B\x30\x09\x06\x03\x55\x04"
                        "\x06\x13\x02\x46\x52\x31\x0F\x30\x0D\x06\x03"
                        "\x55\x04\x08\x13\x06\x46\x72\x61\x6E\x63\x65"
@@ -333,16 +335,37 @@ NSSCertDBTrustDomain::CheckRevocation(En
   // Since this affects EV there is no reason why DV should be more strict
   // so all intermediatates are allowed to have OCSP responses up to one year
   // old.
   uint16_t maxOCSPLifetimeInDays = 10;
   if (endEntityOrCA == EndEntityOrCA::MustBeCA) {
     maxOCSPLifetimeInDays = 365;
   }
 
+  if (!mCertBlocklist) {
+    return Result::FATAL_ERROR_LIBRARY_FAILURE;
+  }
+
+  bool isCertRevoked;
+  nsresult nsrv = mCertBlocklist->IsCertRevoked(
+                    certID.issuer.UnsafeGetData(),
+                    certID.issuer.GetLength(),
+                    certID.serialNumber.UnsafeGetData(),
+                    certID.serialNumber.GetLength(),
+                    &isCertRevoked);
+  if (NS_FAILED(nsrv)) {
+    return Result::FATAL_ERROR_LIBRARY_FAILURE;
+  }
+
+  if (isCertRevoked) {
+    PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
+           ("NSSCertDBTrustDomain: certificate is in blocklist"));
+    return Result::ERROR_REVOKED_CERTIFICATE;
+  }
+
   // If we have a stapled OCSP response then the verification of that response
   // determines the result unless the OCSP response is expired. We make an
   // exception for expired responses because some servers, nginx in particular,
   // are known to serve expired responses due to bugs.
   // We keep track of the result of verifying the stapled response but don't
   // immediately return failure if the response has expired.
   Result stapledOCSPResponseResult = Success;
   if (stapledOCSPResponse) {
--- a/security/certverifier/NSSCertDBTrustDomain.h
+++ b/security/certverifier/NSSCertDBTrustDomain.h
@@ -2,19 +2,20 @@
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_psm__NSSCertDBTrustDomain_h
 #define mozilla_psm__NSSCertDBTrustDomain_h
 
+#include "CertVerifier.h"
+#include "nsICertBlocklist.h"
 #include "pkix/pkixtypes.h"
 #include "secmodt.h"
-#include "CertVerifier.h"
 
 namespace mozilla { namespace psm {
 
 SECStatus InitializeNSS(const char* dir, bool readOnly);
 
 void DisableMD5();
 
 extern const char BUILTIN_ROOTS_MODULE_DEFAULT_NAME[];
@@ -105,13 +106,14 @@ private:
   const OCSPFetching mOCSPFetching;
   OCSPCache& mOCSPCache; // non-owning!
   void* mPinArg; // non-owning!
   const CertVerifier::ocsp_get_config mOCSPGetConfig;
   CertVerifier::PinningMode mPinningMode;
   const unsigned int mMinimumNonECCBits;
   const char* mHostname; // non-owning - only used for pinning checks
   ScopedCERTCertList* mBuiltChain; // non-owning
+  nsCOMPtr<nsICertBlocklist> mCertBlocklist;
 };
 
 } } // namespace mozilla::psm
 
 #endif // mozilla_psm__NSSCertDBTrustDomain_h
--- a/security/manager/boot/public/moz.build
+++ b/security/manager/boot/public/moz.build
@@ -1,15 +1,16 @@
 # -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
 # vim: set filetype=python:
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 XPIDL_SOURCES += [
     'nsIBufEntropyCollector.idl',
+    'nsICertBlocklist.idl',
     'nsISecurityUITelemetry.idl',
     'nsISecurityWarningDialogs.idl',
     'nsISSLStatusProvider.idl',
 ]
 
 XPIDL_MODULE = 'pipboot'
 
new file mode 100644
--- /dev/null
+++ b/security/manager/boot/public/nsICertBlocklist.idl
@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIX509Cert;
+
+%{C++
+#define NS_CERTBLOCKLIST_CONTRACTID "@mozilla.org/security/certblocklist;1"
+%}
+
+/**
+ * Represents a service to add certificates as explicitly blocked/distrusted.
+ */
+[scriptable, uuid(44b0ee42-1af3-45e7-b601-7f17bd67c5cc)]
+interface nsICertBlocklist : nsISupports {
+  /**
+   * Add details of a revoked certificate :
+   * issuer name (base-64 encoded DER) and serial number (base-64 encoded DER).
+   */
+   void addRevokedCert(in string issuer, in string serialNumber);
+
+  /**
+   * Persist (fresh) blocklist entries to the profile (if a profile directory is
+   * available). Note: calling this will result in synchronous I/O.
+   */
+   void saveEntries();
+
+  /**
+   * Check if a certificate is blocked.
+   * isser - issuer name, DER encoded
+   * serial - serial number, DER encoded
+   */
+   boolean isCertRevoked([const, array, size_is(issuer_length)] in octet issuer,
+                          in unsigned long issuer_length,
+                          [const, array, size_is(serial_length)] in octet serial,
+                          in unsigned long serial_length);
+};
new file mode 100644
--- /dev/null
+++ b/security/manager/boot/src/CertBlocklist.cpp
@@ -0,0 +1,469 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "CertBlocklist.h"
+#include "mozilla/Base64.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsCRTGlue.h"
+#include "nsDirectoryServiceUtils.h"
+#include "nsIFileStreams.h"
+#include "nsILineInputStream.h"
+#include "nsIX509Cert.h"
+#include "nsNetCID.h"
+#include "nsNetUtil.h"
+#include "nsTHashtable.h"
+#include "nsThreadUtils.h"
+#include "pkix/Input.h"
+#include "prlog.h"
+
+NS_IMPL_ISUPPORTS(CertBlocklist, nsICertBlocklist)
+
+static PRLogModuleInfo* gCertBlockPRLog;
+
+CertBlocklistItem::CertBlocklistItem(mozilla::pkix::Input aIssuer,
+                                     mozilla::pkix::Input aSerial)
+{
+  mIssuerData = new uint8_t[aIssuer.GetLength()];
+  memcpy(mIssuerData, aIssuer.UnsafeGetData(), aIssuer.GetLength());
+  mIssuer.Init(mIssuerData, aIssuer.GetLength());
+
+  mSerialData = new uint8_t[aSerial.GetLength()];
+  memcpy(mSerialData, aSerial.UnsafeGetData(), aSerial.GetLength());
+  mSerial.Init(mSerialData, aSerial.GetLength());
+}
+
+CertBlocklistItem::CertBlocklistItem(const CertBlocklistItem& aItem)
+{
+  uint32_t issuerLength = aItem.mIssuer.GetLength();
+  mIssuerData = new uint8_t[issuerLength];
+  memcpy(mIssuerData, aItem.mIssuerData, issuerLength);
+  mIssuer.Init(mIssuerData, issuerLength);
+
+  uint32_t serialLength = aItem.mSerial.GetLength();
+  mSerialData = new uint8_t[serialLength];
+  memcpy(mSerialData, aItem.mSerialData, serialLength);
+  mSerial.Init(mSerialData, serialLength);
+  mIsCurrent = aItem.mIsCurrent;
+}
+
+CertBlocklistItem::~CertBlocklistItem()
+{
+  delete[] mIssuerData;
+  delete[] mSerialData;
+}
+
+nsresult
+CertBlocklistItem::ToBase64(nsACString& b64IssuerOut, nsACString& b64SerialOut)
+{
+  nsDependentCSubstring issuerString(reinterpret_cast<char *>(mIssuerData),
+                                     mIssuer.GetLength());
+  nsDependentCSubstring serialString(reinterpret_cast<char *>(mSerialData),
+                                     mSerial.GetLength());
+  nsresult rv = mozilla::Base64Encode(issuerString, b64IssuerOut);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+  rv = mozilla::Base64Encode(serialString, b64SerialOut);
+  return rv;
+}
+
+bool
+CertBlocklistItem::operator==(const CertBlocklistItem& aItem) const
+{
+  bool retval = InputsAreEqual(aItem.mIssuer, mIssuer) &&
+                InputsAreEqual(aItem.mSerial, mSerial);
+  return retval;
+}
+
+uint32_t
+CertBlocklistItem::Hash() const
+{
+  uint32_t hash;
+  uint32_t serialLength = mSerial.GetLength();
+  // there's no requirement for a serial to be as large as 32 bits; if it's
+  // smaller, fall back to the first octet (otherwise, the last four)
+  if (serialLength >= 4) {
+    hash = *(uint32_t *)(mSerialData + serialLength - 4);
+  } else {
+    hash = *mSerialData;
+  }
+  return hash;
+}
+
+CertBlocklist::CertBlocklist()
+  : mMutex("CertBlocklist::mMutex")
+  , mModified(false)
+{
+  if (!gCertBlockPRLog) {
+    gCertBlockPRLog = PR_NewLogModule("CertBlock");
+  }
+}
+
+CertBlocklist::~CertBlocklist()
+{
+}
+
+nsresult
+CertBlocklist::Init()
+{
+  mozilla::MutexAutoLock lock(mMutex);
+  PR_LOG(gCertBlockPRLog, PR_LOG_DEBUG, ("CertBlocklist::Init"));
+  if (!NS_IsMainThread()) {
+    PR_LOG(gCertBlockPRLog, PR_LOG_DEBUG,
+           ("CertBlocklist::Init - called off main thread"));
+    return NS_ERROR_NOT_SAME_THREAD;
+  }
+  // Load the revocations file into the cert blocklist
+  PR_LOG(gCertBlockPRLog, PR_LOG_DEBUG,
+         ("CertBlocklist::Init - not initialized; initializing"));
+  nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR,
+                                       getter_AddRefs(mBackingFile));
+  if (NS_FAILED(rv) || !mBackingFile) {
+    PR_LOG(gCertBlockPRLog, PR_LOG_DEBUG,
+           ("CertBlocklist::Init - couldn't get profile dir"));
+    return NS_OK;
+  }
+  rv = mBackingFile->Append(NS_LITERAL_STRING("revocations.txt"));
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  nsAutoCString path;
+  rv = mBackingFile->GetNativePath(path);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  PR_LOG(gCertBlockPRLog, PR_LOG_DEBUG,
+         ("CertBlocklist::Init certList path: %s", path.get()));
+
+  bool exists = false;
+  rv = mBackingFile->Exists(&exists);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  if (!exists) {
+    PR_LOG(gCertBlockPRLog, PR_LOG_WARN,
+           ("CertBlocklist::Init no revocations file"));
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIFileInputStream> fileStream(
+      do_CreateInstance(NS_LOCALFILEINPUTSTREAM_CONTRACTID, &rv));
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  rv = fileStream->Init(mBackingFile, -1, -1, false);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  nsCOMPtr<nsILineInputStream> lineStream(do_QueryInterface(fileStream, &rv));
+  nsAutoCString line;
+  nsAutoCString issuer;
+  nsAutoCString serial;
+  // read in the revocations file. The file format is as follows: each line
+  // contains a comment, base64 encoded DER for an issuer or base64 encoded DER
+  // for a serial number. Comment lines start with '#', serial number lines, ' '
+  // (a space) and anything else is assumed to be an issuer.
+  bool more = true;
+  do {
+    rv = lineStream->ReadLine(line, &more);
+    if (NS_FAILED(rv)) {
+      break;
+    }
+    // ignore comments and empty lines
+    if (line.IsEmpty() || line.First() == '#') {
+      continue;
+    }
+    if (line.First() != ' ') {
+      issuer = line;
+      continue;
+    }
+    serial = line;
+    serial.Trim(" ", true, false, false);
+    // serial numbers 'belong' to the last issuer line seen; if no issuer has
+    // been seen, the serial number is ignored
+    if (issuer.IsEmpty() || serial.IsEmpty()) {
+      continue;
+    }
+    PR_LOG(gCertBlockPRLog, PR_LOG_DEBUG,
+           ("CertBlocklist::Init adding: %s %s", issuer.get(), serial.get()));
+    rv = AddRevokedCertInternal(issuer.get(),
+                                serial.get(),
+                                CertOldFromLocalCache,
+                                lock);
+    if (NS_FAILED(rv)) {
+      // we warn here, rather than abandoning, since we need to
+      // ensure that as many items as possible are read
+      PR_LOG(gCertBlockPRLog, PR_LOG_WARN,
+             ("CertBlocklist::Init adding revoked cert failed"));
+    }
+  } while (more);
+
+  return NS_OK;
+}
+
+// void addRevokedCert (in string issuer, in string serialNumber);
+NS_IMETHODIMP
+CertBlocklist::AddRevokedCert(const char* aIssuer,
+                              const char* aSerialNumber)
+{
+  PR_LOG(gCertBlockPRLog, PR_LOG_DEBUG,
+         ("CertBlocklist::addRevokedCert - issuer is: %s and serial: %s",
+          aIssuer, aSerialNumber));
+  mozilla::MutexAutoLock lock(mMutex);
+  return AddRevokedCertInternal(aIssuer,
+                                aSerialNumber,
+                                CertNewFromBlocklist,
+                                lock);
+}
+
+nsresult
+CertBlocklist::AddRevokedCertInternal(const char* aIssuer,
+                                      const char* aSerialNumber,
+                                      CertBlocklistItemState aItemState,
+                                      mozilla::MutexAutoLock& /*proofOfLock*/)
+{
+  nsCString decodedIssuer;
+  nsCString decodedSerial;
+
+  nsresult rv;
+  rv = mozilla::Base64Decode(nsDependentCString(aIssuer), decodedIssuer);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+  rv = mozilla::Base64Decode(nsDependentCString(aSerialNumber), decodedSerial);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  mozilla::pkix::Input issuer;
+  mozilla::pkix::Input serial;
+
+  mozilla::pkix::Result pkrv;
+  pkrv = issuer.Init(reinterpret_cast<const uint8_t*>(decodedIssuer.get()),
+                     decodedIssuer.Length());
+  if (pkrv != mozilla::pkix::Success) {
+    return NS_ERROR_FAILURE;
+  }
+  pkrv = serial.Init(reinterpret_cast<const uint8_t*>(decodedSerial.get()),
+                     decodedSerial.Length());
+  if (pkrv != mozilla::pkix::Success) {
+    return NS_ERROR_FAILURE;
+  }
+
+  CertBlocklistItem item(issuer, serial);
+
+  if (aItemState == CertNewFromBlocklist) {
+    // we want SaveEntries to be a no-op if no new entries are added
+    if (!mBlocklist.Contains(item)) {
+      mModified = true;
+    }
+
+    // Ensure that any existing item is replaced by a fresh one so we can
+    // use mIsCurrent to decide which entries to write out
+    mBlocklist.RemoveEntry(item);
+    item.mIsCurrent = true;
+  }
+  mBlocklist.PutEntry(item);
+
+  return NS_OK;
+}
+
+// Data needed for writing blocklist items out to the revocations file
+struct BlocklistSaveInfo
+{
+  IssuerTable issuerTable;
+  BlocklistStringSet issuers;
+  nsCOMPtr<nsIOutputStream> outputStream;
+  bool success = true;
+};
+
+// Write a line for a given string in the output stream
+nsresult
+WriteLine(nsIOutputStream* outputStream, const nsACString& string)
+{
+  nsAutoCString line(string);
+  line.Append('\n');
+
+  const char* data = line.get();
+  uint32_t length = line.Length();
+  nsresult rv = NS_OK;
+  while (NS_SUCCEEDED(rv) && length) {
+    uint32_t bytesWritten = 0;
+    rv = outputStream->Write(data, length, &bytesWritten);
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+    // if no data is written, something is wrong
+    if (!bytesWritten) {
+      return NS_ERROR_FAILURE;
+    }
+    length -= bytesWritten;
+    data += bytesWritten;
+  }
+  return rv;
+}
+
+// sort blocklist items into lists of serials for each issuer
+PLDHashOperator
+ProcessEntry(BlocklistItemKey* aHashKey, void* aUserArg)
+{
+  BlocklistSaveInfo* saveInfo = reinterpret_cast<BlocklistSaveInfo*>(aUserArg);
+  CertBlocklistItem item = aHashKey->GetKey();
+
+  if (!item.mIsCurrent) {
+    return PL_DHASH_NEXT;
+  }
+
+  nsAutoCString encIssuer;
+  nsAutoCString encSerial;
+
+  nsresult rv = item.ToBase64(encIssuer, encSerial);
+  if (NS_FAILED(rv)) {
+    saveInfo->success = false;
+    return PL_DHASH_STOP;
+  }
+
+  saveInfo->issuers.PutEntry(encIssuer);
+  BlocklistStringSet* issuerSet = saveInfo->issuerTable.Get(encIssuer);
+  if (!issuerSet) {
+    issuerSet = new BlocklistStringSet();
+    saveInfo->issuerTable.Put(encIssuer, issuerSet);
+  }
+  issuerSet->PutEntry(encSerial);
+  return PL_DHASH_NEXT;
+}
+
+// write serial data to the output stream
+PLDHashOperator
+WriteSerial(nsCStringHashKey* aHashKey, void* aUserArg)
+{
+  BlocklistSaveInfo* saveInfo = reinterpret_cast<BlocklistSaveInfo*>(aUserArg);
+
+  nsresult rv = WriteLine(saveInfo->outputStream,
+                          NS_LITERAL_CSTRING(" ") + aHashKey->GetKey());
+  if (NS_FAILED(rv)) {
+    saveInfo->success = false;
+    return PL_DHASH_STOP;
+  }
+  return PL_DHASH_NEXT;
+}
+
+// Write issuer data to the output stream
+PLDHashOperator
+WriteIssuer(nsCStringHashKey* aHashKey, void* aUserArg)
+{
+  BlocklistSaveInfo* saveInfo = reinterpret_cast<BlocklistSaveInfo *>(aUserArg);
+  nsAutoPtr<BlocklistStringSet> issuerSet;
+
+  saveInfo->issuerTable.RemoveAndForget(aHashKey->GetKey(), issuerSet);
+
+  nsresult rv = WriteLine(saveInfo->outputStream, aHashKey->GetKey());
+  if (!NS_SUCCEEDED(rv)) {
+    return PL_DHASH_STOP;
+  }
+
+  issuerSet->EnumerateEntries(WriteSerial, saveInfo);
+  if (!saveInfo->success) {
+    saveInfo->success = false;
+    return PL_DHASH_STOP;
+  }
+  return PL_DHASH_NEXT;
+}
+
+// void saveEntries();
+// Store the blockist in a text file containing base64 encoded issuers and
+// serial numbers.
+//
+// Each item is stored on a separate line; each issuer is followed by its
+// revoked serial numbers, indented by one space.
+//
+// lines starting with a # character are ignored
+NS_IMETHODIMP
+CertBlocklist::SaveEntries()
+{
+  mozilla::MutexAutoLock lock(mMutex);
+  if (!mModified) {
+    return NS_OK;
+  }
+  if (!mBackingFile) {
+    // We allow this to succeed with no profile directory for tests
+    PR_LOG(gCertBlockPRLog, PR_LOG_WARN,
+           ("CertBlocklist::SaveEntries no file in profile to write to"));
+    return NS_OK;
+  }
+
+  BlocklistSaveInfo saveInfo;
+  nsresult rv;
+  rv = NS_NewAtomicFileOutputStream(getter_AddRefs(saveInfo.outputStream),
+                                    mBackingFile, -1, -1, 0);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+  mBlocklist.EnumerateEntries(ProcessEntry, &saveInfo);
+  if (!saveInfo.success) {
+    PR_LOG(gCertBlockPRLog, PR_LOG_WARN,
+           ("CertBlocklist::SaveEntries writing revocation data failed"));
+    return NS_ERROR_FAILURE;
+  }
+
+  rv = WriteLine(saveInfo.outputStream,
+                 NS_LITERAL_CSTRING("# Auto generated contents. Do not edit."));
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  saveInfo.issuers.EnumerateEntries(WriteIssuer, &saveInfo);
+  if (!saveInfo.success) {
+    PR_LOG(gCertBlockPRLog, PR_LOG_WARN,
+           ("CertBlocklist::SaveEntries writing revocation data failed"));
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsISafeOutputStream> safeStream =
+      do_QueryInterface(saveInfo.outputStream);
+  NS_ASSERTION(safeStream, "expected a safe output stream!");
+  if (!safeStream) {
+    return NS_ERROR_FAILURE;
+  }
+  rv = safeStream->Finish();
+  if (NS_FAILED(rv)) {
+    PR_LOG(gCertBlockPRLog, PR_LOG_WARN,
+           ("CertBlocklist::SaveEntries saving revocation data failed"));
+    return rv;
+  }
+  mModified = false;
+  return NS_OK;
+}
+
+// boolean isCertRevoked([const, array, size_is(issuerLength)] in octet issuer,
+//                       in unsigned long issuerLength,
+//                       [const, array, size_is(serialLength)] in octet serial,
+//                       in unsigned long serialLength);
+NS_IMETHODIMP CertBlocklist::IsCertRevoked(const uint8_t* aIssuer, uint32_t aIssuerLength,
+                                           const uint8_t* aSerial, uint32_t aSerialLength,
+                                           bool* _retval)
+{
+  mozilla::MutexAutoLock lock(mMutex);
+
+  mozilla::pkix::Input issuer;
+  mozilla::pkix::Input serial;
+  if (issuer.Init(aIssuer, aIssuerLength) != mozilla::pkix::Success) {
+    return NS_ERROR_FAILURE;
+  }
+  if (serial.Init(aSerial, aSerialLength) != mozilla::pkix::Success) {
+    return NS_ERROR_FAILURE;
+  }
+
+  CertBlocklistItem item(issuer, serial);
+
+  *_retval = mBlocklist.Contains(item);
+
+  return NS_OK;
+}
new file mode 100644
--- /dev/null
+++ b/security/manager/boot/src/CertBlocklist.h
@@ -0,0 +1,71 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef CertBlocklist_h
+#define CertBlocklist_h
+
+#include "mozilla/Mutex.h"
+#include "nsClassHashtable.h"
+#include "nsCOMPtr.h"
+#include "nsICertBlocklist.h"
+#include "nsIOutputStream.h"
+#include "nsTHashtable.h"
+#include "nsIX509CertDB.h"
+#include "pkix/Input.h"
+
+#define NS_CERT_BLOCKLIST_CID \
+{0x11aefd53, 0x2fbb, 0x4c92, {0xa0, 0xc1, 0x05, 0x32, 0x12, 0xae, 0x42, 0xd0} }
+
+enum CertBlocklistItemState {
+  CertNewFromBlocklist,
+  CertOldFromLocalCache
+};
+
+class CertBlocklistItem
+{
+public:
+  CertBlocklistItem(mozilla::pkix::Input aIssuer, mozilla::pkix::Input aSerial);
+  CertBlocklistItem(const CertBlocklistItem& aItem);
+  ~CertBlocklistItem();
+  nsresult ToBase64(nsACString& b64IssuerOut, nsACString& b64SerialOut);
+  bool operator==(const CertBlocklistItem& aItem) const;
+  uint32_t Hash() const;
+  bool mIsCurrent = false;
+
+private:
+  mozilla::pkix::Input mIssuer;
+  uint8_t* mIssuerData;
+  mozilla::pkix::Input mSerial;
+  uint8_t* mSerialData;
+};
+
+typedef nsGenericHashKey<CertBlocklistItem> BlocklistItemKey;
+typedef nsTHashtable<BlocklistItemKey> BlocklistTable;
+typedef nsTHashtable<nsCStringHashKey> BlocklistStringSet;
+typedef nsClassHashtable<nsCStringHashKey, BlocklistStringSet> IssuerTable;
+
+class CertBlocklist : public nsICertBlocklist
+{
+public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSICERTBLOCKLIST
+  CertBlocklist();
+  nsresult Init();
+
+private:
+  BlocklistTable mBlocklist;
+  nsresult AddRevokedCertInternal(const char* aIssuer,
+                                  const char* aSerial,
+                                  CertBlocklistItemState aItemState,
+                                  mozilla::MutexAutoLock& /*proofOfLock*/);
+  mozilla::Mutex mMutex;
+  bool mModified = false;
+  nsCOMPtr<nsIFile> mBackingFile;
+
+protected:
+  virtual ~CertBlocklist();
+};
+
+#endif // CertBlocklist_h
--- a/security/manager/boot/src/moz.build
+++ b/security/manager/boot/src/moz.build
@@ -4,16 +4,17 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 EXPORTS.mozilla += [
     'DataStorage.h',
 ]
 
 UNIFIED_SOURCES += [
+    'CertBlocklist.cpp',
     'DataStorage.cpp',
     'nsBOOTModule.cpp',
     'nsEntropyCollector.cpp',
     'nsSecureBrowserUIImpl.cpp',
     'nsSecurityHeaderParser.cpp',
     'nsSecurityWarningDialogs.cpp',
     'nsSiteSecurityService.cpp',
     'PublicKeyPinningService.cpp',
--- a/security/manager/boot/src/nsBOOTModule.cpp
+++ b/security/manager/boot/src/nsBOOTModule.cpp
@@ -1,43 +1,48 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "mozilla/ModuleUtils.h"
 
+#include "CertBlocklist.h"
 #include "nsEntropyCollector.h"
 #include "nsSecureBrowserUIImpl.h"
 #include "nsSecurityWarningDialogs.h"
 #include "nsSiteSecurityService.h"
 
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsEntropyCollector)
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsSecureBrowserUIImpl)
+NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(CertBlocklist, Init)
 NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsSecurityWarningDialogs, Init)
 NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsSiteSecurityService, Init)
 
 NS_DEFINE_NAMED_CID(NS_ENTROPYCOLLECTOR_CID);
 NS_DEFINE_NAMED_CID(NS_SECURITYWARNINGDIALOGS_CID);
 NS_DEFINE_NAMED_CID(NS_SECURE_BROWSER_UI_CID);
 NS_DEFINE_NAMED_CID(NS_SITE_SECURITY_SERVICE_CID);
+NS_DEFINE_NAMED_CID(NS_CERT_BLOCKLIST_CID);
 
 static const mozilla::Module::CIDEntry kBOOTCIDs[] = {
   { &kNS_ENTROPYCOLLECTOR_CID, false, nullptr, nsEntropyCollectorConstructor },
   { &kNS_SECURITYWARNINGDIALOGS_CID, false, nullptr, nsSecurityWarningDialogsConstructor },
   { &kNS_SECURE_BROWSER_UI_CID, false, nullptr, nsSecureBrowserUIImplConstructor },
   { &kNS_SITE_SECURITY_SERVICE_CID, false, nullptr, nsSiteSecurityServiceConstructor },
+  { &kNS_CERT_BLOCKLIST_CID, false, nullptr, CertBlocklistConstructor},
   { nullptr }
 };
 
 static const mozilla::Module::ContractIDEntry kBOOTContracts[] = {
   { NS_ENTROPYCOLLECTOR_CONTRACTID, &kNS_ENTROPYCOLLECTOR_CID },
   { NS_SECURITYWARNINGDIALOGS_CONTRACTID, &kNS_SECURITYWARNINGDIALOGS_CID },
   { NS_SECURE_BROWSER_UI_CONTRACTID, &kNS_SECURE_BROWSER_UI_CID },
   { NS_SSSERVICE_CONTRACTID, &kNS_SITE_SECURITY_SERVICE_CID },
+  { NS_CERTBLOCKLIST_CONTRACTID, &kNS_CERT_BLOCKLIST_CID },
   { nullptr }
 };
 
 static const mozilla::Module kBootModule = {
   mozilla::Module::kVersion,
   kBOOTCIDs,
   kBOOTContracts
 };
--- a/security/manager/ssl/src/nsNSSComponent.cpp
+++ b/security/manager/ssl/src/nsNSSComponent.cpp
@@ -2,25 +2,26 @@
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "nsNSSComponent.h"
 
 #include "ExtendedValidation.h"
-#include "NSSCertDBTrustDomain.h"
 #include "mozilla/Telemetry.h"
+#include "nsAppDirectoryServiceDefs.h"
 #include "nsCertVerificationThread.h"
-#include "nsAppDirectoryServiceDefs.h"
 #include "nsComponentManagerUtils.h"
 #include "nsDirectoryServiceDefs.h"
+#include "nsICertBlocklist.h"
 #include "nsICertOverrideService.h"
+#include "NSSCertDBTrustDomain.h"
+#include "nsThreadUtils.h"
 #include "mozilla/Preferences.h"
-#include "nsThreadUtils.h"
 #include "mozilla/PublicSSL.h"
 #include "mozilla/StaticPtr.h"
 
 #ifndef MOZ_NO_SMART_CARDS
 #include "nsSmartCardMonitor.h"
 #endif
 
 #include "nsCRT.h"
@@ -1066,16 +1067,22 @@ nsNSSComponent::InitializeNSS()
                        Preferences::GetBool("security.ssl.enable_alpn",
                                             ALPN_ENABLED_DEFAULT));
 
   if (NS_FAILED(InitializeCipherSuite())) {
     PR_LOG(gPIPNSSLog, PR_LOG_ERROR, ("Unable to initialize cipher suite settings\n"));
     return NS_ERROR_FAILURE;
   }
 
+  // ensure the CertBlocklist is initialised
+  nsCOMPtr<nsICertBlocklist> certList = do_GetService(NS_CERTBLOCKLIST_CONTRACTID);
+  if (!certList) {
+    return NS_ERROR_FAILURE;
+  }
+
   // dynamic options from prefs
   setValidationOptions(true, lock);
 
   mHttpForNSS.initTable();
 
 #ifndef MOZ_NO_SMART_CARDS
   LaunchSmartCardThreads();
 #endif
new file mode 100644
--- /dev/null
+++ b/security/manager/ssl/tests/unit/test_cert_blocklist.js
@@ -0,0 +1,264 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// This test checks a number of things:
+// * it ensures that data loaded from revocations.txt on startup is present
+// * it ensures that certItems in blocklist.xml are persisted correctly
+// * it ensures that items in the CertBlocklist are seen as revoked by the
+//   cert verifier
+// * it does a sanity check to ensure other cert verifier behavior is
+//   unmodified
+
+let { XPCOMUtils } = Cu.import("resource://gre/modules/XPCOMUtils.jsm", {});
+
+// First, we need to setup appInfo for the blocklist service to work
+let id = "xpcshell@tests.mozilla.org";
+let appName = "XPCShell";
+let version = "1";
+let platformVersion = "1.9.2";
+let appInfo = {
+  // nsIXULAppInfo
+  vendor: "Mozilla",
+  name: appName,
+  ID: id,
+  version: version,
+  appBuildID: "2007010101",
+  platformVersion: platformVersion ? platformVersion : "1.0",
+  platformBuildID: "2007010101",
+
+  // nsIXULRuntime
+  inSafeMode: false,
+  logConsoleErrors: true,
+  OS: "XPCShell",
+  XPCOMABI: "noarch-spidermonkey",
+  invalidateCachesOnRestart: function invalidateCachesOnRestart() {
+    // Do nothing
+  },
+
+  // nsICrashReporter
+  annotations: {},
+
+  annotateCrashReport: function(key, data) {
+    this.annotations[key] = data;
+  },
+
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIXULAppInfo,
+                                         Ci.nsIXULRuntime,
+                                         Ci.nsICrashReporter,
+                                         Ci.nsISupports])
+};
+
+let XULAppInfoFactory = {
+  createInstance: function (outer, iid) {
+    appInfo.QueryInterface(iid);
+    if (outer != null) {
+      throw Cr.NS_ERROR_NO_AGGREGATION;
+    }
+    return appInfo.QueryInterface(iid);
+  }
+};
+
+let registrar = Components.manager.QueryInterface(Ci.nsIComponentRegistrar);
+const XULAPPINFO_CONTRACTID = "@mozilla.org/xre/app-info;1";
+const XULAPPINFO_CID = Components.ID("{c763b610-9d49-455a-bbd2-ede71682a1ac}");
+registrar.registerFactory(XULAPPINFO_CID, "XULAppInfo",
+                          XULAPPINFO_CONTRACTID, XULAppInfoFactory);
+
+// we need to ensure we setup revocation data before certDB, or we'll start with
+// no revocation.txt in the profile
+let profile = do_get_profile();
+let revocations = profile.clone();
+revocations.append("revocations.txt");
+if (!revocations.exists()) {
+  let existing = do_get_file("test_onecrl/sample_revocations.txt", false);
+  existing.copyTo(profile,"revocations.txt");
+}
+
+let certDB = Cc["@mozilla.org/security/x509certdb;1"]
+               .getService(Ci.nsIX509CertDB);
+
+// set up a test server to serve the blocklist.xml
+let testserver = new HttpServer();
+
+let blocklist_contents =
+    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
+    "<blocklist xmlns=\"http://www.mozilla.org/2006/addons-blocklist\">" +
+    // test with some bad data ...
+    "<certItems><certItem issuerName='Some nonsense in issuer'>" +
+    "<serialNumber>AkHVNA==</serialNumber>" +
+    "</certItem><certItem issuerName='MA0xCzAJBgNVBAMMAmNh'>" +
+    "<serialNumber>some nonsense in serial</serialNumber>" +
+    "</certItem><certItem issuerName='some nonsense in both issuer'>" +
+    "<serialNumber>and serial</serialNumber></certItem>" +
+    // some mixed
+    // In this case, the issuer name and the valid serialNumber correspond
+    // to test-int.der in tlsserver/
+    "<certItem issuerName='MBIxEDAOBgNVBAMTB1Rlc3QgQ0E='>" +
+    "<serialNumber>oops! more nonsense.</serialNumber>" +
+    "<serialNumber>BA==</serialNumber></certItem>" +
+    // ... and some good
+    // This item corresponds to an entry in sample_revocations.txt where:
+    // isser name is "another imaginary issuer" base-64 encoded, and
+    // serialNumbers are:
+    // "serial2." base-64 encoded, and
+    // "another serial." base-64 encoded
+    // We need this to ensure that existing items are retained if they're
+    // also in the blocklist
+    "<certItem issuerName='YW5vdGhlciBpbWFnaW5hcnkgaXNzdWVy'>" +
+    "<serialNumber>c2VyaWFsMi4=</serialNumber>" +
+    "<serialNumber>YW5vdGhlciBzZXJpYWwu</serialNumber>" +
+    "</certItem></certItems></blocklist>";
+testserver.registerPathHandler("/push_blocked_cert/",
+  function serveResponse(request, response) {
+    response.write(blocklist_contents);
+  });
+
+// start the test server
+testserver.start(-1);
+let port = testserver.identity.primaryPort;
+
+// Setup the addonManager
+let addonManager = Cc["@mozilla.org/addons/integration;1"]
+                     .getService(Ci.nsIObserver)
+                     .QueryInterface(Ci.nsITimerCallback);
+addonManager.observe(null, "addons-startup", null);
+
+let converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"]
+                  .createInstance(Ci.nsIScriptableUnicodeConverter);
+converter.charset = "UTF-8";
+
+function verify_cert(file, expectedError) {
+  let cert_der = readFile(do_get_file(file));
+  let ee = certDB.constructX509(cert_der, cert_der.length);
+  equal(expectedError, certDB.verifyCertNow(ee, certificateUsageSSLServer,
+                                            NO_FLAGS, {}, {}));
+}
+
+function load_cert(cert, trust) {
+  let file = "tlsserver/" + cert + ".der";
+  addCertFromFile(certDB, file, trust);
+}
+
+function testIsRevoked(certList, issuerString, serialString) {
+  let issuer = converter.convertToByteArray(issuerString, {});
+  let serial = converter.convertToByteArray(serialString, {});
+  return certList.isCertRevoked(issuer,
+                                issuerString.length,
+                                serial,
+                                serialString.length);
+}
+
+function run_test() {
+  // import the certificates we need
+  load_cert("test-ca", "CTu,CTu,CTu");
+  load_cert("test-int", ",,");
+
+  let certList = Cc["@mozilla.org/security/certblocklist;1"]
+                   .getService(Ci.nsICertBlocklist);
+
+  // check some existing items in revocations.txt are blocked. Since the
+  // CertBlocklistItems don't know about the data they contain, we can use
+  // arbitrary data (not necessarily DER) to test if items are revoked or not.
+  // This test corresponds to:
+  // issuer: c29tZSBpbWFnaW5hcnkgaXNzdWVy
+  // serial: c2VyaWFsLg==
+  ok(testIsRevoked(certList, "some imaginary issuer","serial."),
+     "issuer / serial pair should be blocked");
+
+  // And this test corresponds to:
+  // issuer: YW5vdGhlciBpbWFnaW5hcnkgaXNzdWVy
+  // serial: c2VyaWFsMi4=
+  ok(testIsRevoked(certList, "another imaginary issuer","serial2."),
+     "issuer / serial pair should be blocked");
+
+  // Soon we'll load a blocklist which revokes test-int.der, which issued
+  // test-int-ee.der.
+  // Check the cert validates before we load the blocklist
+  let file = "tlsserver/test-int-ee.der";
+  verify_cert(file, Cr.NS_OK);
+
+  // blocklist load is async so we must use add_test from here
+  add_test(function() {
+    let certblockObserver = {
+      observe: function(aSubject, aTopic, aData) {
+        run_next_test();
+        Services.obs.removeObserver(this, "blocklist-updated");
+      }
+    }
+
+    Services.obs.addObserver(certblockObserver, "blocklist-updated", false);
+    Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
+                               port + "/push_blocked_cert/");
+    let blocklist = Cc["@mozilla.org/extensions/blocklist;1"]
+                      .getService(Ci.nsITimerCallback);
+    blocklist.notify(null);
+  });
+
+  add_test(function() {
+    // The blocklist will be loaded now. Let's check the data is sane.
+    // In particular, we should still have the revoked issuer / serial pair
+    // that was in both revocations.txt and the blocklist.xml
+    ok(testIsRevoked(certList, "another imaginary issuer", "serial2."),
+      "issuer / serial pair should be blocked");
+
+    // Check that both serials in the certItem with multiple serials were read
+    // properly
+    ok(testIsRevoked(certList, "another imaginary issuer", "serial2."),
+       "issuer / serial pair should be blocked");
+    ok(testIsRevoked(certList, "another imaginary issuer", "another serial."),
+       "issuer / serial pair should be blocked");
+
+    // Check the blocklist entry has been persisted properly to the backing
+    // file
+    let profile = do_get_profile();
+    let revocations = profile.clone();
+    revocations.append("revocations.txt");
+    ok(revocations.exists(), "the revocations file should exist");
+    let inputStream = Cc["@mozilla.org/network/file-input-stream;1"]
+                        .createInstance(Ci.nsIFileInputStream);
+    inputStream.init(revocations,-1, -1, 0);
+    inputStream.QueryInterface(Ci.nsILineInputStream);
+    let contents = "";
+    let hasmore = false;
+    do {
+      var line = {};
+      hasmore = inputStream.readLine(line);
+      contents = contents + (contents.length == 0 ? "" : "\n") + line.value;
+    } while (hasmore);
+    let expected = "# Auto generated contents. Do not edit.\n" +
+                  "MBIxEDAOBgNVBAMTB1Rlc3QgQ0E=\n" +
+                  " BA==\n" +
+                  "YW5vdGhlciBpbWFnaW5hcnkgaXNzdWVy\n" +
+                  " YW5vdGhlciBzZXJpYWwu\n" +
+                  " c2VyaWFsMi4=";
+    equal(contents, expected, "revocations.txt should be as expected");
+
+    // Check the blocklisted intermediate now causes a failure
+    let file = "tlsserver/test-int-ee.der";
+    verify_cert(file, SEC_ERROR_REVOKED_CERTIFICATE);
+
+    // Check a non-blocklisted chain still validates OK
+    file = "tlsserver/default-ee.der";
+    verify_cert(file, Cr.NS_OK);
+
+    // Check a bad cert is still bad (unknown issuer)
+    file = "tlsserver/unknown-issuer.der";
+    verify_cert(file, SEC_ERROR_UNKNOWN_ISSUER);
+
+    // check that save with no further update is a no-op
+    let lastModified = revocations.lastModifiedTime;
+    // add an already existing entry
+    certList.addRevokedCert("YW5vdGhlciBpbWFnaW5hcnkgaXNzdWVy","c2VyaWFsMi4=");
+    certList.saveEntries();
+    let newModified = revocations.lastModifiedTime;
+    equal(lastModified, newModified,
+          "saveEntries with no modifications should not update the backing file");
+
+    run_next_test();
+  });
+
+  // we need to start the async portions of the test
+  run_next_test();
+}
new file mode 100644
--- /dev/null
+++ b/security/manager/ssl/tests/unit/test_onecrl/sample_revocations.txt
@@ -0,0 +1,26 @@
+# a sample revocations.txt for tests
+# Lines starting with '#' are ignored - as are empty lines like this:
+
+# otherwise:
+# non-empty lines are treated as base-64 encoded DER issuer data
+# ...unless the line starts with a ' ' (space) character, in which case it's
+# assumed to be base-64 encoded DER serial data.
+
+# First a serial with no issuer to ensure this doesn't cause parsing to fail
+# (there should be an issuer first, but we need to test this won't fail)
+ dGVzdA==
+# next, let's ensure data that isn't valid base64 doesn't cause breakage.
+ this serial isn't valid base64 (but then there's no issuer anyway)
+Neither is this issuer, though the serial is fine
+ dGVzdA==
+dGVzdA==
+ in this case, issuer is fine but not the serial
+# Next two entries; we can add valid base-64 encoded data for some basic tests:
+# issuer is "some imaginary issuer" base-64 encoded
+# and serial "serial." base-64 encoded
+c29tZSBpbWFnaW5hcnkgaXNzdWVy
+ c2VyaWFsLg==
+# issuer is "another imaginary issuer" base-64 encoded
+# serial is "serial2." base-64 encoded
+YW5vdGhlciBpbWFnaW5hcnkgaXNzdWVy
+ c2VyaWFsMi4=
index 87d341115bbef1a813d2fb8dfae0628bfee092d0..48dd5a9525d44b895b1f3236cacbc1e4797b0a60
GIT binary patch
literal 327680
zc%1B=2UrtL_qP*5QIIAG(nD4Hh9+IQAWfQ73y{#8A&{O3Dj<rzKK6!+UF-#Wuh<nE
zhy@FZy`X;CWEBKrdEVET|Mgwx*6f+&%sD$dv-{g2n`9%xg3@UeVoEMGJCR1T#f`?{
z@i-465r@M|;cz%v?12|N(C3o4Ht@J#BFJI+Kt`V5ij!vdz;RUgC)nrN<?O+NCjbBd
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000002M|7kp=rPbB-@UiJRWC|lW
zGclc<lb=7NASo+7S;jlu*E7<W7!cy)8$%TOh@m0G?|x$cL=s|S>MkYB5GBlzm6$}y
z`d&l&hYUhr#|*ZnK9bVvT6*|l!ub4xqzp<j?RyQWA2MLx&aEJsdJ?47HNI^}dVYQZ
zh5EgU<PS+i&W<@8Nv5T?co}s)J^UnlT4GWb<-7NLK?2JY>FE{Z+df**F+;)wf<41y
ziGjYc#Hf&fuqa=24c?(4enA1=kwj0g(C|nLVj?1VkOU7K!NV3U3tvEAA)zlhqE8*s
zr;fs>Xcb30bYYJ!9MHu8bm53DoX|xgx=0c%oP?<m(NdTZu@Nps>#-9q?S)GR;c|d*
z=_p(}373h&Ws-22ENqyld7}0S%Qm92Ftd#?vyCvbjWDx~Ftd#?vyCvbtuV?~7-cJr
zvK2<z3Zoo^UI(GqLFjc5dL2YwVNM5O&H=)jj-sWo2ZdW|gNVv#tc|d>c8CBQVUw|<
zu&;%+ZH2XMg|+PvQEgF0(JQvXrJZnTFI=MQwiB+^PPkS(;keifW9@~p_K4^eG&Y%H
zZ)<03PiiaLv=!S`uxl&Yw-p`QiUZn;j^B$8ZD9^=VGeC!4sBr$-@+W)n&Z&c9EY~%
zIJ7m#p{+R%ZOw6LYmP%(a|A`FwqjyiF{!PX+*TyF6)A1Sl<!61jvy)~wKXRRZ4TK!
z5g{iDd)yHb($>EYPNpOYX?0&cJWeDZqq5Rzlo5#qv|Qoy5#JBe5v1=$f<X2pr34E+
z{}U>KJ^7#bZ@X880RR91000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
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
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
V0000000000000000092q^FN8xcfSAt
--- a/security/manager/ssl/tests/unit/tlsserver/generate_certs.sh
+++ b/security/manager/ssl/tests/unit/tlsserver/generate_certs.sh
@@ -262,28 +262,30 @@ make_EE otherIssuerEE 'CN=Wrong CA Pin T
 export_cert localhostAndExampleCom default-ee.der
 
 # A cert that is like localhostAndExampleCom, but with a different serial number for
 # testing the "OCSP response is from the right issuer, but it is for the wrong cert"
 # case.
 make_EE ocspOtherEndEntity 'CN=Other Cert' testCA "localhost,*.example.com"
 
 make_INT testINT 'CN=Test Intermediate' testCA
+export_cert testINT test-int.der
 make_EE ocspEEWithIntermediate 'CN=Test End-entity with Intermediate' testINT "localhost,*.example.com"
 make_EE expired 'CN=Expired Test End-entity' testCA "expired.example.com" "-w -400"
 export_cert expired expired-ee.der
 make_EE mismatch 'CN=Mismatch Test End-entity' testCA "doesntmatch.example.com"
 make_EE selfsigned 'CN=Self-signed Test End-entity' testCA "selfsigned.example.com" "-x"
 # If the certificate 'CN=Test Intermediate' isn't loaded into memory,
 # this certificate will have an unknown issuer.
 # deletedINT is never kept in the database, so it always gets regenerated.
 # That's ok, because if unknownissuer was already in the database, it won't
 # get regenerated. Either way, deletedINT will then be removed again.
 make_INT deletedINT 'CN=Test Intermediate to delete' testCA
 make_EE unknownissuer 'CN=Test End-entity from unknown issuer' deletedINT "unknownissuer.example.com"
+export_cert unknownissuer unknown-issuer.der
 
 $RUN_MOZILLA $CERTUTIL -d $DB_ARGUMENT -D -n deletedINT
 
 make_INT expiredINT 'CN=Expired Test Intermediate' testCA "-w -400"
 make_EE expiredissuer 'CN=Test End-entity with expired issuer' expiredINT "expiredissuer.example.com"
 NSS_ALLOW_WEAK_SIGNATURE_ALG=1 make_EE md5signature 'CN=Test End-entity with MD5 signature' testCA "md5signature.example.com" "-Z MD5"
 make_EE untrustedissuer 'CN=Test End-entity with untrusted issuer' otherCA "untrustedissuer.example.com"
 
@@ -315,9 +317,13 @@ make_EE_with_nsCertType nsCertTypeCritic
 
 # Make an X.509 version 1 certificate that will issue another certificate.
 # By default, this causes an error in verification that we allow overrides for.
 # However, if the v1 certificate is a trust anchor, then verification succeeds.
 make_V1 v1Cert 'CN=V1 Cert' testCA
 export_cert v1Cert v1Cert.der
 make_EE eeIssuedByV1Cert 'CN=EE Issued by V1 Cert' v1Cert "localhost,*.example.com"
 
+# Make a valid EE using testINT to test OneCRL revocation of testINT
+make_EE eeIssuedByIntermediate 'CN=EE issued by intermediate' testINT "localhost"
+export_cert eeIssuedByIntermediate test-int-ee.der
+
 cleanup
index 5598271c5a31c60e7b70c47b9710afa4dfdd9cad..81e70d293046a2cea5ef1d692c4a738a2229b088
GIT binary patch
literal 458752
zc%1CrcT`i`_BZ@&s`REb=^%n2Y#=~T=^g0;B1lPSQl$5iO{{<-R>X=Ouw(Cvy`TbC
zL{aQ0B4WXcZ^FsF0WQx<?s)(BJ!O8zaIdXj=60SL$qGr}O!M=M&y3NCO-Y|k&D1a>
z6_YTGWT&A)B9VHTza&W<Ld;(RgMN>Zxa%cNd@U?N{3eacpGhi|B(4-(D_|7Z=Kso{
znSY&!dH?_b0000000000000000000000000000000000000000000000000000000
z0000000000000000000000000000000001h|EnYk3oEFqVhn>!DlI8yc1$MKiJD3M
z*E-74-`PIEStG#S!P8meUw^8h7ay(R>+kMm?>|Fhs`CtuKyP=yKxYjfZw*HuZx>H@
z#{dm~XJ1cyM`uHg_{^BuCjTs^`o^P#6dYACQhaiBOm0S667x?Zs9BjQ1HX^>*YzVz
z{&gneAS9%qpoxVJd_YtpH9k5yBf~d6KAV~uBg}5j-P_4ISYse$wZQoR4Lzy}ZmMr5
zIB<>W1J_8R(qfW0A0jm58Ux{fT*FM?ML<YltR@!mPup3vgqWyI&W8vNxduBPp%W8*
zM}8p%rGNd`#Ajq=#iVmSMqtQg{z?DiDijm_g%+5wf~F?6#B$&!<HVdZz9Bc;;0tiS
z;p`oJ`~wU%s5tW%^LC?}GJlz|&IkU0^(Q8*KccXHOJV(%GVoj0hfv6@gE{M9!8%y7
z4iwhGiglo}4m9S$YT#1%KgWS9;-&+~fBqiwz|nl*XfbfK95_-2j#dLl>cEjUaEuyg
z?4S1j>2KiN^q=#AE1M2n*>vE_rUO?t9k{aTz?Dr0u530?Wj0V{Hc(|YP-QkyWigOi
z45StVsl`BQ@lQH%O^bnRS`K_9<)7og1PA_0P4R!uS+%AE-I8%8(}9-RrvtMd_-M0%
zk2V|lXfpoKNB{GI|NM#Bz>z#~G#@y!{%-QX-%1|%Tgd~ri}^sU`9Q5X{?DJVYNKMz
z&B$ivCY)1K&gq~JAahR5Ij0t!Q%lY%<=>|koH7eenFXiJf>UPkuQCfxI~JUFEI930
zaN4opv}3_($AZ(21*aY6sTJpx$~mQRPNO)d(VWv5&S~twPY3=X{Bug<v_oUH6Kzh#
zqiF*Zr{DuP^R=+jH{%mhaMk=@-T84oOCwA;=lsmOXaPay0V95~?ye>NSpWb400000
z00000000000000000000000000000000000000000000000000000000000000000
z000000000000000000000001h|JR5si!zTmJ%L30AU+YDL<iAIG!xf|2I4qTPt*~c
zi8aJBqLg3|c|;l!Pf&>&gdgEf*b`O+PK+nih%tmX{U-e){Up7RzKOn?;HUqjf1<yo
zKc(NNXV4Sq2k3S5CG`3K)BmLa0000000000000000000000000000000000000000
z0000000000000000000000000000000000000000000000000000000@V}2y`~sM)
z)tSxsz=>#0hB518RC-5>5$i<n;Ev{rtP_<6`D=!(6UjH8nFa$V2i?sluueu-{!-H)
zIEj~=qQ^Sn>vroIKXCFAFVr14xpZmcIM#{Gx3(Cafs?j2Q*G9X)ZJz&t$~wkx8gMi
zPR^;MX$+if*%znIIw38czC&%`Wbx!%sskq_-Et}eC-dgSjvY8*NKaN4=I6%>%Wo*L
z);#BvimWwDHAsQArcItC&svjY+Q+cgS%r<GS!;Clb2-);xx-49wa$F_K!&vj-z<}6
zt$|J<Qmoa__pKyr^*TeBV6AQoY{Xfs)3I}6tktgifhcRW4zLnotrYi$QLL5Ru|Sx$
z;@c#ISnEWGT0z#TH#bUvwd%Yo=4Y)M^WXCc@$-wQj13ZH-ZD5LLn3|?eMB$ufp|;2
zAlivm;x2KUxK3Om&JibxBSby1o2VhS5F3apVg<2;C?)0*1d&f<5vfEX5lc{snZ$I$
zpYS5w2uH$(up-EWF)@J{M`#dZ33=vU00000000000000000000000000000000000
z000000000000000000000000000000000000000000000000000000000000007|s
zECT!_3}+pTSqCH5VIu2b$T}FX4ii`hebzybbr{b&=&}yuSO*=}L7R2ZVjVPD2MyLi
zopn%S9aLEd71m)a>!8d!D6tNTtb+pUAkR9CVI4-Z4sxu6EbAb{I!Ln)Qmlg{>mb28
zh_eo2tb-`)Ai_F~VjYB82O-u$kaZAX9r#%XK7M|Zh$!<v8K*Ny#1G;V(Mfa=twb|%
zjc6c_6ZJ$Lv6)yyEF($@29Zak5%C0-m_hgv?u0#IMVJu!geIXx$Pgj~M*l(oMDL_`
z&|B%v^lS76`f++ay^g+_zJ|VxUdsFn00000000000000000000000000000000000
z000000000000000000000000000000000000000000000000000000000000005u~
z^UGq}Ng+6UHD<3y>~$i0HDs>_>~#Wr)n~7I>~%bQ)n%{a*sBhE)n>0+>{XM!YOq&z
z_NvBSRoSZwdmYPOmD#HjdsSqw3hY&$y^dk8quHw*dzEFcGVE2Fy-KlHN%ktiUd7p~
z7<(0EuOjSq6nhnBuR`oqki819SAO=&C&Vu+!nzLgCcx<o67hrhM064zL@UuuTq7EY
z<3v4CM{Fk65X*>Cf<fdFX+%6hC1wzQggaqRSP>?KKA}k{5i*1bfzf}^KhZns9rRXu
zGyNL9fqtA`Pp_kIrmvwdqn9%O0ssI200000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000001J?EfD<
z&R&h#s}Xyh$X*TEs{wnRz+Uy)s~&qD&t7%e>p1qR!(O%7s}_6JWUm_RRh_-6u~$|0
zs={8!vR7sHs>EIu*{cG3m1nPG*z0KaD#u=B*{ckDm1eI}>{XJzO0ZXP_A16+McJze
zdmY7Ih1shRdlh7_0_>Haz48h1%ZjkB!@LRb0zXnwPQm)Zp9OwJhDCBkb%msY!$skQ
zaN$&9UZE1<PcNh2E8IuCrArjG6(kg$r>7NtDR@KQO57$k&~*#1(t`;N!m40yku$xU
zI8qp0SV<%nnikxmpQ76q78NZm?D(JlX9fTO000000000000000000000000000000
z0000000000000000000000000000000000000000000000000000000000000RD$4
z@{=){Pg&gx`Q*S&XHTwozOeA<xcy{ZoE1cC?7q9REMrN0$nkGZy(Tt^>U=83tYDcC
z^=$E@I)|6!-%HN4>_6ZZxk}ZD6-doEwM)8XwBr#oKkb8JpH`YbG(9ts6=>%-G<{l^
zK1KKIov<9~&F{OGjn6h@1-Bk=zmaqI$KP)4a6v{}>X}Vh?S%%cfY?gaSzRuC{;ExK
zM&JES^u+K7RTBm-W#4n_9ly`<^sdd)Auo>9U7aqRq|XWrH8s=Iz0a6@bM!ebe!#77
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
new file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..f534b74c99202f9f8acccd736d21ec58a2c42295
GIT binary patch
literal 533
zc$_n6ViGiHVys%g%*4pV#H6*|fR~L^tIebBJ1-+6H!FjIjG>f)1RHZG3$w6bNNRD3
zf@fYyYEf=#N@ik7s)3w1uc3*dfsr{7n;DoyiSwEua}87sl?)Uhx+Ps*6*7y9OH)%6
zk}4H4kxglwk8CR=D+6<5FM~m2CsSi1!?Av!H}hTOTb6poW~Du<*nB_gdHQ=vA*b>j
z<8|g{(#;2ZA2qzwS=nNsW;s_}<dE6Sk1w4H+EZLPma!?yKl~Fu=htTC{Jf}V&tBv$
zeNY|sF2dy3LcgD^w`%W|F`D?sZt&#~F#m32(rsn3wD{lbO=}z899Vl*HOo@9mNQ>d
z{YEwuGb01z;wXa%0}-G<WCdAx4Y->)bMliDb29RaOAL(IIJDUqSy|Z`8Clc}R1B10
zd;`Wdv5b<E0xNxexN0j40}BIv10Ik`!i<dnS(pqM&;pzp=;z(6yJwz$xaC#tI+pYQ
z@0;WZinv@^ymWI&@5Lt`6MO$!1T49ob~wZ-o_C+mJNbeQt{)EkI^%brPkqgv_wK82
zUXTB|D%ioJCj0O**AwwVZpS^$tTq|9x^hQvbh#O{wDV*0cT@RC+glR5!;2RF;gQw%
Wnz68;EUxcsi`xD-3=XdkeFp#{5x&>}
new file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..72318b65f0268c18b60fd8aa2f65221a618a7116
GIT binary patch
literal 498
zc$_n6Vti-N#2CJSnTe5!iIK&CmyJ`a&7<u*FC!x>D}#ZMp@0D&8*?ZNvoL!|YH^8z
zv!j8WIIp3Jfw`fvA&@dOj1uQHLFO9B7)lvPK=cTL^?2r$q!#6-rer3Tq#88NN4A5J
zm4Ugjm%*U1lc}+h;kTf*cFnQI;(N@GmPg-h?_RG}lh9WB@7~|KJ>qqr-Zhx{_r0?+
znk&Jb^Lev_vi0lRJUxvsob-Q9zCVGD@AR^qH!{mMJ8#yF4SuINa}uL*t<k}gy6>NU
zVwR6TuT<Avu_(v(zQ_;XB?%Lg6kh*i<Gh&P67=fLJYW84jv4Y*?(H9$m>C%u7ke3a
z7#Oi}XtM!BfSr+%Ma@9PKncb-U~Ci1C@Cqh($~+)PfpCq$S*FjvM{hP&^HhQ`dL<(
zk?}tZhXEUqVq#=K3r=RBAJea&T(G7oX<Nr}spzDswG&!Jv!~>`{!l13;Ja@kBj8)Q
za-B-+k%cL1avHzza2Z`FQ>d@$-?{$!^Vs?oxn{N>*Cdt+rXMf4BPe{Tn>%npLr923
z-W}oHb8PE;H#8URm^AISvXwjwGrPpXwO98fZ+v8Ns%+)FhTJ<QFXmjl_x5Hm0Bg&y
As{jB1
new file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..59518ea3f16a99ab7eef9c4f4981c87f46b7ed0a
GIT binary patch
literal 568
zc$_n6VlpvkVw}5xnTe5!iIK~ImyJ`a&7<u*FC!x>D}#ZWp^AYL8*?ZNv#@kXYH^8z
zXI@EaQEqBVW@1UILP@?tN@`AONveUIIIp3Jfw`fvA&@dOiW28FLFO9h8R{5lLCjGG
zo8y|7qMMpml37xzkXDqRt5BMkotIypr;u4(T$);B&^RC2C5)^L%#FPa292Fejg1Uv
z7u%mPY2N?j$q$dY#}zItva4-dzwpAp19Lgvt_(l=`M`t)AqO;s1@haOH#PWgDrz`u
zsQCMX^8RYB`yx|M&oi4W6Za;WS?xmj;`Sd$_*}N8JvTPCZ1NQj`Tpy>>O;o&+R^p-
zQ|}vXRy%#-=l;|kTONNbbFZCxNOtpAEe08e%{h%s%!~|-i?a+e3{-$Vk`-i;HIQzS
zgn9tte!bL+#N2|MRK4W<TmvIE4sAAIXtFahvZxt=!V}6jU~Ci1C@Cqh($~+)PfpCq
z$S*FjvM{hP&^O=#nJmo6_@9NzfB`L1n1Nv+nG&L1F-_fA-axh8pYy`}iVwak&o-9W
zh^jpNFA*tyXz|2pnp<3|a?dXR@k_jS(t-6_$yelbZZC7Rv3YBI(u<>~jy3!Cp`d@O
zUTmM~-NjIIey@f6J!vuNl-H7%1n<-wdGe{9-OOO#w5{5kcNTqfJAPxC&*Xhxt5Od9
Ln|jMIq5lm4DG|;s
--- a/security/manager/ssl/tests/unit/xpcshell.ini
+++ b/security/manager/ssl/tests/unit/xpcshell.ini
@@ -13,16 +13,17 @@ support-files =
   test_name_constraints/**
   test_cert_trust/**
   test_cert_version/**
   test_cert_eku/**
   test_ocsp_url/**
   test_ocsp_fetch_method/**
   test_keysize/**
   test_pinning_dynamic/**
+  test_onecrl/**
 
 [test_datasignatureverifier.js]
 [test_hash_algorithms.js]
 [test_hmac.js]
 
 [test_sts_preloadlist_perwindowpb.js]
 # Bug 978426: Test fails consistently only on B2G ARM
 skip-if = buildapp == "b2g" && processor == "arm"
@@ -41,16 +42,17 @@ skip-if = buildapp == "b2g" && processor
 [test_pinning_dynamic.js]
 [test_pinning_header_parsing.js]
 
 [test_certificate_usages.js]
 [test_ocsp_stapling.js]
 run-sequentially = hardcoded ports
 # Bug 1009158: this test times out on Android
 skip-if = os == "android"
+[test_cert_blocklist.js]
 [test_ocsp_stapling_expired.js]
 run-sequentially = hardcoded ports
 # Bug 1009158: this test times out on Android
 skip-if = os == "android"
 [test_ocsp_stapling_with_intermediate.js]
 run-sequentially = hardcoded ports
 # Bug 1009158: this test times out on Android
 skip-if = os == "android"
--- a/toolkit/mozapps/extensions/nsBlocklistService.js
+++ b/toolkit/mozapps/extensions/nsBlocklistService.js
@@ -69,16 +69,20 @@ var gBlocklistLevel = DEFAULT_LEVEL;
 XPCOMUtils.defineLazyServiceGetter(this, "gConsole",
                                    "@mozilla.org/consoleservice;1",
                                    "nsIConsoleService");
 
 XPCOMUtils.defineLazyServiceGetter(this, "gVersionChecker",
                                    "@mozilla.org/xpcom/version-comparator;1",
                                    "nsIVersionComparator");
 
+XPCOMUtils.defineLazyServiceGetter(this, "gCertBlocklistService",
+                                   "@mozilla.org/security/certblocklist;1",
+                                   "nsICertBlocklist");
+
 XPCOMUtils.defineLazyGetter(this, "gPref", function bls_gPref() {
   return Cc["@mozilla.org/preferences-service;1"].getService(Ci.nsIPrefService).
          QueryInterface(Ci.nsIPrefBranch);
 });
 
 XPCOMUtils.defineLazyGetter(this, "gApp", function bls_gApp() {
   return Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULAppInfo).
          QueryInterface(Ci.nsIXULRuntime);
@@ -720,16 +724,23 @@ Blocklist.prototype = {
 #      </emItems>
 #      <pluginItems>
 #        <pluginItem blockID="i4">
 #          <!-- All match tags must match a plugin to blocklist a plugin -->
 #          <match name="name" exp="some plugin"/>
 #          <match name="description" exp="1[.]2[.]3"/>
 #        </pluginItem>
 #      </pluginItems>
+#      <certItems>
+#        <!-- issuerName is the DER issuer name data base64 encoded... -->
+#        <certItem issuerName="MA0xCzAJBgNVBAMMAmNh">
+#          <!-- ... as is the serial number DER data -->
+#          <serialNumber>AkHVNA==</serialNumber>
+#        </certItem>
+#      </certItems>
 #    </blocklist>
    */
 
   _loadBlocklistFromFile: function Blocklist_loadBlocklistFromFile(file) {
     if (!gBlocklistEnabled) {
       LOG("Blocklist::_loadBlocklistFromFile: blocklist is disabled");
       return;
     }
@@ -857,22 +868,27 @@ Blocklist.prototype = {
         case "emItems":
           this._addonEntries = this._processItemNodes(element.childNodes, "em",
                                                       this._handleEmItemNode);
           break;
         case "pluginItems":
           this._pluginEntries = this._processItemNodes(element.childNodes, "plugin",
                                                        this._handlePluginItemNode);
           break;
+        case "certItems":
+          this._processItemNodes(element.childNodes, "cert",
+                                 this._handleCertItemNode.bind(this));
+          break;
         default:
           Services.obs.notifyObservers(element,
                                        "blocklist-data-" + element.localName,
                                        null);
         }
       }
+      gCertBlocklistService.saveEntries();
     }
     catch (e) {
       LOG("Blocklist::_loadBlocklistFromFile: Error constructing blocklist " + e);
       return;
     }
   },
 
   _processItemNodes: function Blocklist_processItemNodes(itemNodes, prefix, handler) {
@@ -884,16 +900,32 @@ Blocklist.prototype = {
           blocklistElement.localName != itemName)
         continue;
 
       handler(blocklistElement, result);
     }
     return result;
   },
 
+  _handleCertItemNode: function Blocklist_handleCertItemNode(blocklistElement,
+                                                             result) {
+    let issuer = blocklistElement.getAttribute("issuerName");
+    for (let snElement of blocklistElement.children) {
+      try {
+        if (issuer) {
+          gCertBlocklistService.addRevokedCert(issuer, snElement.textContent);
+        }
+      } catch (e) {
+        // we want to keep trying other elements since missing all items
+        // is worse than missing one
+        LOG("Blocklist::_handleCertItemNode: Error adding revoked cert " + e);
+      }
+    }
+  },
+
   _handleEmItemNode: function Blocklist_handleEmItemNode(blocklistElement, result) {
     if (!matchesOSABI(blocklistElement))
       return;
 
     let blockEntry = {
       versions: [],
       prefs: [],
       blockID: null,