security/manager/tools/genRootCAHashes.js

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4 "use strict";
   5
   6 // How to run this file:
   7 // 1. [obtain firefox source code]
   8 // 2. [build/obtain firefox binaries]
   9 // 3. run `[path to]/firefox -xpcshell genRootCAHashes.js [absolute path to]/RootHashes.inc'
  10
  11 const nsX509CertDB = "@mozilla.org/security/x509certdb;1";
  12 const CertDb = Cc[nsX509CertDB].getService(Ci.nsIX509CertDB);
  13
  14 const { FileUtils } = ChromeUtils.importESModule(
  15   "resource://gre/modules/FileUtils.sys.mjs"
  16 );
  17 const { NetUtil } = ChromeUtils.importESModule(
  18   "resource://gre/modules/NetUtil.sys.mjs"
  19 );
  20 const { CommonUtils } = ChromeUtils.importESModule(
  21   "resource://services-common/utils.sys.mjs"
  22 );
  23
  24 const FILENAME_OUTPUT = "RootHashes.inc";
  25 const FILENAME_TRUST_ANCHORS = "KnownRootHashes.json";
  26 const ROOT_NOT_ASSIGNED = -1;
  27
  28 const JSON_HEADER = `// This Source Code Form is subject to the terms of the Mozilla Public
  29 // License, v. 2.0. If a copy of the MPL was not distributed with this
  30 // file, You can obtain one at http://mozilla.org/MPL/2.0/. */
  31 //
  32 //***************************************************************************
  33 // This is an automatically generated file. It's used to maintain state for
  34 // runs of genRootCAHashes.js; you should never need to manually edit it
  35 //***************************************************************************
  36
  37 // Notes:
  38 // binNumber 1 used to be for "GTE_CyberTrust_Global_Root", but that root was
  39 // removed from the built-in roots module, so now it is used to indicate that
  40 // the certificate is not a built-in and was found in the softoken (cert9.db).
  41
  42 // binNumber 2 used to be for "Thawte_Server_CA", but that root was removed from
  43 // the built-in roots module, so now it is used to indicate that the certificate
  44 // is not a built-in and was found on an external PKCS#11 token.
  45
  46 // binNumber 3 used to be for "Thawte_Premium_Server_CA", but that root was
  47 // removed from the built-in roots module, so now it is used to indicate that
  48 // the certificate is not a built-in and was temporarily imported from the OS as
  49 // part of the "Enterprise Roots" feature.
  50
  51 `;
  52
  53 const FILE_HEADER =
  54   "/* This Source Code Form is subject to the terms of the Mozilla Public\n" +
  55   " * License, v. 2.0. If a copy of the MPL was not distributed with this\n" +
  56   " * file, You can obtain one at http://mozilla.org/MPL/2.0/. */\n" +
  57   "\n" +
  58   "/*****************************************************************************/\n" +
  59   "/* This is an automatically generated file. If you're not                    */\n" +
  60   "/* RootCertificateTelemetryUtils.cpp, you shouldn't be #including it.        */\n" +
  61   "/*****************************************************************************/\n" +
  62   "\n" +
  63   "#define HASH_LEN 32\n";
  64
  65 const FP_PREAMBLE =
  66   "struct CertAuthorityHash {\n" +
  67   "  // See bug 1338873 about making these fields const.\n" +
  68   "  uint8_t hash[HASH_LEN];\n" +
  69   "  int32_t binNumber;\n" +
  70   "};\n\n" +
  71   "static const struct CertAuthorityHash ROOT_TABLE[] = {\n";
  72
  73 const FP_POSTAMBLE = "};\n";
  74
  75 // Helper
  76 function writeString(fos, string) {
  77   fos.write(string, string.length);
  78 }
  79
  80 // Remove all colons from a string
  81 function stripColons(hexString) {
  82   return hexString.replace(/:/g, "");
  83 }
  84
  85 // Expect an array of bytes and make it C-formatted
  86 function hexSlice(bytes, start, end) {
  87   let ret = "";
  88   for (let i = start; i < end; i++) {
  89     let hex = (0 + bytes.charCodeAt(i).toString(16)).slice(-2).toUpperCase();
  90     ret += "0x" + hex;
  91     if (i < end - 1) {
  92       ret += ", ";
  93     }
  94   }
  95   return ret;
  96 }
  97
  98 function stripComments(buf) {
  99   let lines = buf.split("\n");
 100   let entryRegex = /^\s*\/\//;
 101   let data = "";
 102   for (let i = 0; i < lines.length; i++) {
 103     let match = entryRegex.exec(lines[i]);
 104     if (!match) {
 105       data = data + lines[i];
 106     }
 107   }
 108   return data;
 109 }
 110
 111 // Load the trust anchors JSON object from disk
 112 function loadTrustAnchors(file) {
 113   if (file.exists()) {
 114     let stream = Cc["@mozilla.org/network/file-input-stream;1"].createInstance(
 115       Ci.nsIFileInputStream
 116     );
 117     stream.init(file, -1, 0, 0);
 118     let buf = NetUtil.readInputStreamToString(stream, stream.available());
 119     return JSON.parse(stripComments(buf));
 120   }
 121   // If there's no input file, bootstrap.
 122   return { roots: [], maxBin: 0 };
 123 }
 124
 125 // Saves our persistence file so that we don't lose track of the mapping
 126 // between bin numbers and the CA-hashes, even as CAs come and go.
 127 function writeTrustAnchors(file) {
 128   let fos = FileUtils.openSafeFileOutputStream(file);
 129
 130   let serializedData = JSON.stringify(gTrustAnchors, null, "  ");
 131   fos.write(JSON_HEADER, JSON_HEADER.length);
 132   fos.write(serializedData, serializedData.length);
 133
 134   FileUtils.closeSafeFileOutputStream(fos);
 135 }
 136
 137 // Write the C++ header file
 138 function writeRootHashes(fos) {
 139   try {
 140     writeString(fos, FILE_HEADER);
 141
 142     // Output the sorted gTrustAnchors
 143     writeString(fos, FP_PREAMBLE);
 144     gTrustAnchors.roots.forEach(function (fp) {
 145       let fpBytes = atob(fp.sha256Fingerprint);
 146
 147       writeString(fos, "  {\n");
 148       writeString(fos, "    /* " + fp.label + " */\n");
 149       writeString(fos, "    { " + hexSlice(fpBytes, 0, 16) + ",\n");
 150       writeString(fos, "      " + hexSlice(fpBytes, 16, 32) + " },\n");
 151       writeString(fos, "      " + fp.binNumber + " /* Bin Number */\n");
 152
 153       writeString(fos, "  },\n");
 154     });
 155     writeString(fos, FP_POSTAMBLE);
 156
 157     writeString(fos, "\n");
 158   } catch (e) {
 159     dump("ERROR: problem writing output: " + e + "\n");
 160   }
 161 }
 162
 163 // Scan our list (linearly) for the given fingerprint string
 164 function findTrustAnchorByFingerprint(sha256Fingerprint) {
 165   for (let i = 0; i < gTrustAnchors.roots.length; i++) {
 166     if (sha256Fingerprint == gTrustAnchors.roots[i].sha256Fingerprint) {
 167       return i;
 168     }
 169   }
 170   return ROOT_NOT_ASSIGNED;
 171 }
 172
 173 // Get a clean label for a given certificate; usually the common name.
 174 function getLabelForCert(cert) {
 175   let label = cert.commonName;
 176
 177   if (label.length < 5) {
 178     label = cert.subjectName;
 179   }
 180
 181   // replace non-ascii characters
 182   label = label.replace(/[^[:ascii:]]/g, "_");
 183   // replace non-word characters
 184   label = label.replace(/[^A-Za-z0-9]/g, "_");
 185   return label;
 186 }
 187
 188 // Fill in the gTrustAnchors list with trust anchors from the database.
 189 function insertTrustAnchorsFromDatabase() {
 190   // We only want CA certs for SSL
 191   const CERT_TYPE = Ci.nsIX509Cert.CA_CERT;
 192   const TRUST_TYPE = Ci.nsIX509CertDB.TRUSTED_SSL;
 193
 194   // Iterate through the whole Cert DB
 195   for (let cert of CertDb.getCerts()) {
 196     // Find the certificate in our existing list. Do it here because we need to check if
 197     // it's untrusted too.
 198
 199     // If this is a trusted cert
 200     if (CertDb.isCertTrusted(cert, CERT_TYPE, TRUST_TYPE)) {
 201       // Base64 encode the hex string
 202       let binaryFingerprint = CommonUtils.hexToBytes(
 203         stripColons(cert.sha256Fingerprint)
 204       );
 205       let encodedFingerprint = btoa(binaryFingerprint);
 206
 207       // Scan to see if this is already in the database.
 208       if (
 209         findTrustAnchorByFingerprint(encodedFingerprint) == ROOT_NOT_ASSIGNED
 210       ) {
 211         // Let's get a usable name; some old certs do not have CN= filled out
 212         let label = getLabelForCert(cert);
 213
 214         // Add to list
 215         gTrustAnchors.maxBin += 1;
 216         gTrustAnchors.roots.push({
 217           label,
 218           binNumber: gTrustAnchors.maxBin,
 219           sha256Fingerprint: encodedFingerprint,
 220         });
 221       }
 222     }
 223   }
 224 }
 225
 226 //
 227 //  PRIMARY LOGIC
 228 //
 229
 230 if (arguments.length != 1) {
 231   throw new Error(
 232     "Usage: genRootCAHashes.js <absolute path to current RootHashes.inc>"
 233   );
 234 }
 235
 236 var trustAnchorsFile = new FileUtils.File(
 237   PathUtils.join(
 238     Services.dirsvc.get("CurWorkD", Ci.nsIFile).path,
 239     FILENAME_TRUST_ANCHORS
 240   )
 241 );
 242 var rootHashesFile = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
 243 rootHashesFile.initWithPath(arguments[0]);
 244
 245 // Open the known hashes file; this is to ensure stable bin numbers.
 246 var gTrustAnchors = loadTrustAnchors(trustAnchorsFile);
 247
 248 // Collect all certificate entries
 249 insertTrustAnchorsFromDatabase();
 250
 251 // Update known hashes before we sort
 252 writeTrustAnchors(trustAnchorsFile);
 253
 254 // Sort all trust anchors before writing, as AccumulateRootCA.cpp
 255 // will perform binary searches
 256 gTrustAnchors.roots.sort(function (a, b) {
 257   // We need to work from the binary values, not the base64 values.
 258   let aBin = atob(a.sha256Fingerprint);
 259   let bBin = atob(b.sha256Fingerprint);
 260
 261   if (aBin < bBin) {
 262     return -1;
 263   }
 264   if (aBin > bBin) {
 265     return 1;
 266   }
 267   return 0;
 268 });
 269
 270 // Write the output file.
 271 var rootHashesFileOutputStream =
 272   FileUtils.openSafeFileOutputStream(rootHashesFile);
 273 writeRootHashes(rootHashesFileOutputStream);
 274 FileUtils.closeSafeFileOutputStream(rootHashesFileOutputStream);