Source: security/validity-period.js

  1. /**
  2.  * Copyright (C) 2016-2018 Regents of the University of California.
  3.  * @author: Jeff Thompson <jefft0@remap.ucla.edu>
  4.  * @author: From ndn-cxx src/security https://github.com/named-data/ndn-cxx
  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. /**
  22.  * A ValidityPeriod is used in a Data packet's SignatureInfo and represents the
  23.  * begin and end times of a certificate's validity period.
  24.  *
  25.  * There are three forms of the ValidityPeriod constructor:
  26.  * ValidityPeriod() - Create a default ValidityPeriod where the period is not
  27.  * specified.
  28.  * ValidityPeriod(validityPeriod) - Create a new ValidityPeriod with a copy of
  29.  * the fields in the given validityPeriod object.
  30.  * ValidityPeriod(notBefore, notAfter) - Create a ValidityPeriod with the given
  31.  * period.
  32.  * @param {ValidityPeriod} validityPeriod The ValidityPeriod to copy.
  33.  * @param {number} notBefore The beginning of the validity period range as
  34.  * milliseconds since Jan 1, 1970 UTC. Note that this is rounded up to the
  35.  * nearest whole second.
  36.  * @param {number} notAfter The end of the validity period range as milliseconds
  37.  * since Jan 1, 1970 UTC. Note that this is rounded down to the nearest whole
  38.  * second.
  39.  * @constructor
  40.  */
  41. var ValidityPeriod = function ValidityPeriod(validityPeriodOrNotBefore, notAfter)
  42. {
  43.   this.changeCount_ = 0;
  45.   if (typeof validityPeriodOrNotBefore === 'object' &&
  46.       validityPeriodOrNotBefore instanceof ValidityPeriod) {
  47.     // Copy values.
  48.     validityPeriod = validityPeriodOrNotBefore;
  49.     this.notBefore_ = validityPeriod.notBefore_;
  50.     this.notAfter_ = validityPeriod.notAfter_;
  51.   }
  52.   else if (notAfter != undefined) {
  53.     notBefore = validityPeriodOrNotBefore;
  54.     this.setPeriod(notBefore, notAfter)
  55.   }
  56.   else
  57.     this.clear();
  58. };
  60. exports.ValidityPeriod = ValidityPeriod;
  62. /**
  63.  * Check if the period has been set.
  64.  * @return {boolean} True if the period has been set, false if the period is not
  65.  * specified (after calling the default constructor or clear).
  66.  */
  67. ValidityPeriod.prototype.hasPeriod = function()
  68. {
  69.   return !(this.notBefore_ === Number.MAX_VALUE &&
  70.            this.notAfter_ === -Number.MAX_VALUE);
  71. };
  73. /**
  74.  * Get the beginning of the validity period range.
  75.  * @return {number} The time as milliseconds since Jan 1, 1970 UTC.
  76.  */
  77. ValidityPeriod.prototype.getNotBefore = function() { return this.notBefore_; };
  79. /**
  80.  * Get the end of the validity period range.
  81.  * @return {number} The time as milliseconds since Jan 1, 1970 UTC.
  82.  */
  83. ValidityPeriod.prototype.getNotAfter = function() { return this.notAfter_; };
  85. /** Reset to a default ValidityPeriod where the period is not specified.
  86.  */
  87. ValidityPeriod.prototype.clear = function()
  88. {
  89.   this.notBefore_ = Number.MAX_VALUE;
  90.   this.notAfter_ = -Number.MAX_VALUE;
  91.   ++this.changeCount_;
  92. };
  94. /**
  95.  * Set the validity period.
  96.  * @param {number} notBefore The beginning of the validity period range as
  97.  * milliseconds since Jan 1, 1970 UTC. Note that this is rounded up to the
  98.  * nearest whole second.
  99.  * @param {number} notAfter The end of the validity period range as milliseconds
  100.  * since Jan 1, 1970 UTC. Note that this is rounded down to the nearest whole
  101.  * second.
  102.  * @return {ValidityPeriod} This ValidityPeriod so that you can chain calls to
  103.  * update values.
  104.  */
  105. ValidityPeriod.prototype.setPeriod = function(notBefore, notAfter)
  106. {
  107.   // Round up to the nearest second.
  108.   this.notBefore_ = Math.round(Math.ceil(Math.round(notBefore) / 1000.0) * 1000.0);
  109.   // Round down to the nearest second.
  110.   this.notAfter_ = Math.round(Math.floor(Math.round(notAfter) / 1000.0) * 1000.0);
  111.   ++this.changeCount_;
  113.   return this;
  114. };
  116. /**
  117.  * Check if the time falls within the validity period.
  118.  * @param {number} time (optional) The time to check as milliseconds since
  119.  * Jan 1, 1970 UTC. If omitted, use the current time.
  120.  * @return {boolean} True if the beginning of the validity period is less than
  121.  * or equal to time and time is less than or equal to the end of the validity
  122.  * period.
  123.  */
  124. ValidityPeriod.prototype.isValid = function(time)
  125. {
  126.   if (time == undefined)
  127.       // Round up to the nearest second like in setPeriod.
  128.       time = Math.round(Math.ceil
  129.         (Math.round(new Date().getTime()) / 1000.0) * 1000.0);
  131.   return this.notBefore_ <= time && time <= this.notAfter_;
  132. };
  134. /**
  135.  * If the signature is a type that has a ValidityPeriod (so that
  136.  * getFromSignature will succeed), return true. Note: This is a static method of
  137.  * ValidityPeriod instead of a method of Signature so that the Signature base
  138.  * class does not need to be overloaded with all the different kinds of
  139.  * information that various signature algorithms may use.
  140.  * @param {Signature} An object of a subclass of Signature.
  141.  * @return {boolean} True if the signature is a type that has a ValidityPeriod,
  142.  * otherwise false.
  143.  */
  144. ValidityPeriod.canGetFromSignature = function(signature)
  145. {
  146.   return signature.constructor != undefined &&
  147.     (signature.constructor.name === "Sha256WithRsaSignature" ||
  148.      signature.constructor.name === "Sha256WithEcdsaSignature");
  149. };
  151. /**
  152.  * If the signature is a type that has a ValidityPeriod, then return it.
  153.  * Otherwise throw an error.
  154.  * @param {Signature} An object of a subclass of Signature.
  155.  * @return {ValidityPeriod} The signature's ValidityPeriod. It is an error if
  156.  * signature doesn't have a ValidityPeriod.
  157.  */
  158. ValidityPeriod.getFromSignature = function(signature)
  159. {
  160.   if (signature.constructor != undefined &&
  161.       (signature.constructor.name === "Sha256WithRsaSignature" ||
  162.        signature.constructor.name === "Sha256WithEcdsaSignature"))
  163.     return signature.getValidityPeriod();
  164.   else
  165.     throw new Error
  166.       ("ValidityPeriod.getFromSignature: Signature type does not have a ValidityPeriod");
  167. };
  169. /**
  170.  * Get the change count, which is incremented each time this object is changed.
  171.  * @return {number} The change count.
  172.  */
  173. ValidityPeriod.prototype.getChangeCount = function()
  174. {
  175.   return this.changeCount_;
  176. };