Source: security/v2/certificate-storage.js

  1. /**
  2.  * Copyright (C) 2018 Regents of the University of California.
  3.  * @author: Jeff Thompson <jefft0@remap.ucla.edu>
  4.  * @author: From ndn-cxx security https://github.com/named-data/ndn-cxx/blob/master/src/security/v2/certificate-storage.hpp
  5.  *
  6.  * This program is free software: you can redistribute it and/or modify
  7.  * it under the terms of the GNU Lesser General Public License as published by
  8.  * the Free Software Foundation, either version 3 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  * A copy of the GNU Lesser General Public License is in the file COPYING.
  19.  */
  21. /** @ignore */
  22. var Name = require('../../name.js').Name; /** @ignore */
  23. var TrustAnchorContainer = require('./trust-anchor-container.js').TrustAnchorContainer; /** @ignore */
  24. var CertificateV2 = require('./certificate-v2.js').CertificateV2; /** @ignore */
  25. var CertificateCacheV2 = require('./certificate-cache-v2.js').CertificateCacheV2;
  27. /**
  28.  * The CertificateStorage class stores trusted anchors and has a verified
  29.  * certificate cache, and an unverified certificate cache.
  30.  *
  31.  * @constructor
  32.  */
  33. var CertificateStorage = function CertificateStorage()
  34. {
  35.   this.trustAnchors_ = new TrustAnchorContainer();
  36.   this.verifiedCertificateCache_ = new CertificateCacheV2(3600 * 1000.0);
  37.   this.unverifiedCertificateCache_ = new CertificateCacheV2(300 * 1000.0);
  38. };
  40. exports.CertificateStorage = CertificateStorage;
  42. /**
  43.  * Find a trusted certificate in the trust anchor container or in the
  44.  * verified cache.
  45.  * @param {Interest} interestForCertificate The Interest for the certificate.
  46.  * @return {CertificateV2} The found certificate, or null if not found.
  47.  */
  48. CertificateStorage.prototype.findTrustedCertificate = function
  49.   (interestForCertificate)
  50. {
  51.   var certificate = this.trustAnchors_.find(interestForCertificate);
  52.   if (certificate != null)
  53.     return certificate;
  55.   certificate = this.verifiedCertificateCache_.find(interestForCertificate);
  56.   return certificate;
  57. };
  59. /**
  60.  * Check if the certificate with the given name prefix exists in the verified
  61.  * cache, the unverified cache, or in the set of trust anchors.
  62.  * @param {Name} certificatePrefix The certificate name prefix.
  63.  * @return {boolean} True if the certificate is known.
  64.  */
  65. CertificateStorage.prototype.isCertificateKnown = function(certificatePrefix)
  66. {
  67.   return this.trustAnchors_.find(certificatePrefix) != null ||
  68.          this.verifiedCertificateCache_.find(certificatePrefix) != null ||
  69.          this.unverifiedCertificateCache_.find(certificatePrefix) != null;
  70. };
  72. /**
  73.  * Cache the unverified certificate for a period of time (5 minutes).
  74.  * @param {CertificateV2} certificate The certificate packet, which is copied.
  75.  */
  76. CertificateStorage.prototype.cacheUnverifiedCertificate = function(certificate)
  77. {
  78.   this.unverifiedCertificateCache_.insert(certificate);
  79. };
  81. /**
  82.  * Get the trust anchor container.
  83.  * @return {TrustAnchorContainer} The trust anchor container.
  84.  */
  85. CertificateStorage.prototype.getTrustAnchors = function()
  86. {
  87.   return this.trustAnchors_;
  88. };
  90. /**
  91.  * Get the verified certificate cache.
  92.  * @return {CertificateCacheV2} The verified certificate cache.
  93.  */
  94. CertificateStorage.prototype.getVerifiedCertificateCache = function()
  95. {
  96.   return this.verifiedCertificateCache_;
  97. };
  99. /**
  100.  * Get the unverified certificate cache.
  101.  * @return {CertificateCacheV2} The unverified certificate cache.
  102.  */
  103. CertificateStorage.prototype.getUnverifiedCertificateCache = function()
  104. {
  105.   return this.unverifiedCertificateCache_;
  106. };
  108. /**
  109.  * There are two forms of loadAnchor:
  110.  * loadAnchor(groupId, certificate) - Load a static trust anchor. Static trust
  111.  * anchors are permanently associated with the validator and never expire.
  112.  * loadAnchor(groupId, path, refreshPeriod, isDirectory) - Load dynamic trust
  113.  * anchors. Dynamic trust anchors are associated with the validator for as long
  114.  * as the underlying trust anchor file (or set of files) exists.
  115.  * @param {String} groupId The certificate group id.
  116.  * @param {CertificateV2} certificate The certificate to load as a trust anchor,
  117.  * which is copied.
  118.  * @param {String} path The path to load the trust anchors.
  119.  * @param {number} refreshPeriod  The refresh time in milliseconds for the
  120.  * anchors under path. This must be positive. The relevant trust anchors will
  121.  * only be updated when find is called.
  122.  * @param {boolean} isDirectory (optional) If true, then path is a directory.
  123.  * If false or omitted, it is a single file.
  124.  */
  125. CertificateStorage.prototype.loadAnchor = function
  126.   (groupId, certificateOrPath, refreshPeriod, isDirectory)
  127. {
  128.   this.trustAnchors_.insert
  129.     (groupId, certificateOrPath, refreshPeriod, isDirectory);
  130. };
  132. /**
  133.  * Remove any previously loaded static or dynamic trust anchors.
  134.  */
  135. CertificateStorage.prototype.resetAnchors = function()
  136. {
  137.   this.trustAnchors_.clear();
  138. };
  140. /**
  141.  * Cache the verified certificate a period of time (1 hour).
  142.  * @param {CertificateV2} certificate The certificate object, which is copied.
  143.  */
  144. CertificateStorage.prototype.cacheVerifiedCertificate = function(certificate)
  145. {
  146.   this.verifiedCertificateCache_.insert(certificate);
  147. };
  149. /**
  150.  * Remove any cached verified certificates.
  151.  */
  152. CertificateStorage.prototype.resetVerifiedCertificates = function()
  153. {
  154.   this.verifiedCertificateCache_.clear();
  155. };
  157. /**
  158.  * Set the offset when the cache insert() and refresh() get the current time,
  159.  * which should only be used for testing.
  160.  * @param {number} nowOffsetMilliseconds The offset in milliseconds.
  161.  */
  162. CertificateStorage.prototype.setCacheNowOffsetMilliseconds_ = function
  163.   (nowOffsetMilliseconds)
  164. {
  165.   this.verifiedCertificateCache_.setNowOffsetMilliseconds_(nowOffsetMilliseconds);
  166.   this.unverifiedCertificateCache_.setNowOffsetMilliseconds_(nowOffsetMilliseconds);
  167. };