@blamejs/pki 0.6.14 → 0.6.15

package/lib/rc2.js

@@ -1,17 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright (c) blamejs contributors
 "use strict";
-//
-// @internal -- no operator-facing namespace. RC2 is exposed only through the legacy-PBE bag decryption of
-// pki.pkcs12.open (RFC 7292 App. C), never as a general cipher; RC2 is a broken 64-bit block cipher (RC2-40
-// is export-crippled) kept solely to READ old `openssl pkcs12 -legacy` / NSS stores.
-//
-// rc2 -- a from-scratch RFC 2268 RC2-CBC. OpenSSL 3.x moved RC2 to the legacy provider (not loaded by Node),
-// so node:crypto cannot decrypt these bags; this in-tree primitive fills that single gap (Hard rule #1: own
-// code, no npm hop, so MANIFEST stays empty; it is a lib primitive alongside webcrypto.js, outside lib/vendor/). The
-// RFC 2268 sec. 5 known-answer vectors pin the cipher; the `openssl -legacy` store is the end-to-end KAT.
+// @internal
 
-// RFC 2268 sec. 2: PITABLE, a fixed 256-byte permutation of the digits of pi used by the key schedule.
 var PITABLE = [
   0xd9, 0x78, 0xf9, 0xc4, 0x19, 0xdd, 0xb5, 0xed, 0x28, 0xe9, 0xfd, 0x79, 0x4a, 0xa0, 0xd8, 0x9d,
   0xc6, 0x7e, 0x37, 0x83, 0x2b, 0x76, 0x53, 0x8e, 0x62, 0x4c, 0x64, 0x88, 0x44, 0x8b, 0xfb, 0xa2,
@@ -31,13 +22,12 @@ var PITABLE = [
   0xc5, 0xf3, 0xdb, 0x47, 0xe5, 0xa5, 0x9c, 0x77, 0x0a, 0xa6, 0x20, 0x68, 0xfe, 0x7f, 0xc1, 0xad,
 ];
 
-// RFC 2268 sec. 2: expand `key` (1..128 bytes) to the 64 16-bit words K[0..63], reducing to `effectiveBits`.
 function _expandKey(key, effectiveBits) {
   var T = key.length, L = new Array(128);
   for (var i = 0; i < T; i++) L[i] = key[i];
   for (i = T; i < 128; i++) L[i] = PITABLE[(L[i - 1] + L[i - T]) & 0xff];
   var T8 = (effectiveBits + 7) >>> 3;
-  var TM = 0xff >>> ((8 - (effectiveBits & 7)) & 7);   // 255 mod 2^(8 + effectiveBits - 8*T8)
+  var TM = 0xff >>> ((8 - (effectiveBits & 7)) & 7);
   L[128 - T8] = PITABLE[L[128 - T8] & TM];
   for (i = 127 - T8; i >= 0; i--) L[i] = PITABLE[L[i + 1] ^ L[i + T8]];
   var K = new Array(64);
@@ -49,7 +39,6 @@ function _rotl16(x, n) { return ((x << n) | (x >>> (16 - n))) & 0xffff; }
 function _rotr16(x, n) { return ((x >>> n) | (x << (16 - n))) & 0xffff; }
 var SHIFT = [1, 2, 3, 5];
 
-// RFC 2268 sec. 3: encrypt one 8-byte block (little-endian 16-bit words) in place-ish, returning 8 bytes.
 function _encBlock(K, b, off) {
   var R = [b[off] | (b[off + 1] << 8), b[off + 2] | (b[off + 3] << 8), b[off + 4] | (b[off + 5] << 8), b[off + 6] | (b[off + 7] << 8)];
   var j = 0, i;
@@ -69,7 +58,6 @@ function _encBlock(K, b, off) {
   return R;
 }
 
-// RFC 2268 sec. 3 inverse: decrypt one 8-byte block.
 function _decBlock(K, b, off) {
   var R = [b[off] | (b[off + 1] << 8), b[off + 2] | (b[off + 3] << 8), b[off + 4] | (b[off + 5] << 8), b[off + 6] | (b[off + 7] << 8)];
   var j = 63, i;
@@ -93,12 +81,9 @@ function _wordsToBytes(R) {
   return Buffer.from([R[0] & 0xff, (R[0] >>> 8) & 0xff, R[1] & 0xff, (R[1] >>> 8) & 0xff, R[2] & 0xff, (R[2] >>> 8) & 0xff, R[3] & 0xff, (R[3] >>> 8) & 0xff]);
 }
 
-// ECB block encrypt/decrypt (used by the KAT; CBC wraps them).
 function encryptBlock(key, effectiveBits, block) { return _wordsToBytes(_encBlock(_expandKey(key, effectiveBits), block, 0)); }
 function decryptBlock(key, effectiveBits, block) { return _wordsToBytes(_decBlock(_expandKey(key, effectiveBits), block, 0)); }
 
-// RC2-CBC decrypt with PKCS#7 unpadding. `E`/`code` are the caller's typed-error factory + code; a structural
-// fault (bad length, invalid pad) throws E(code) so the caller can collapse it to its uniform decrypt verdict.
 function cbcDecrypt(key, effectiveBits, iv, ct, E, code) {
   if (ct.length === 0 || ct.length % 8 !== 0) throw E(code, "RC2-CBC ciphertext length must be a non-zero multiple of 8");
   var K = _expandKey(key, effectiveBits), out = Buffer.alloc(ct.length), prev = iv;
@@ -113,7 +98,6 @@ function cbcDecrypt(key, effectiveBits, iv, ct, E, code) {
   return out.subarray(0, out.length - pad);
 }
 
-// RC2-CBC encrypt with PKCS#7 padding (for the round-trip KAT; pkcs12.open only decrypts).
 function cbcEncrypt(key, effectiveBits, iv, pt) {
   var padLen = 8 - (pt.length % 8), padded = Buffer.concat([pt, Buffer.alloc(padLen, padLen)]);
   var K = _expandKey(key, effectiveBits), out = Buffer.alloc(padded.length), prev = iv;

package/lib/rfc3339.js

@@ -13,9 +13,6 @@
  * domain fault code.
  */
 
-// Exactly `count` ASCII digits at `start`, as an integer, or null on any non-digit or short read.
-// The grammar is decided character by character (no regex, whose match protocol re-dispatches through
-// a replaceable `exec`); `\d` in the original is ASCII [0-9] only, matched here as 48..57.
 function _digitsAt(v, start, count) {
   if (start + count > v.length) return null;
   var val = 0;
@@ -27,10 +24,6 @@ function _digitsAt(v, start, count) {
   return val;
 }
 
-// RFC 3339 date-time scanned into its components, or null on any grammar violation:
-// YYYY "-" MM "-" DD [Tt] HH ":" MM ":" SS, an optional "." + one-or-more fraction digits, then a
-// zone -- [Zz] or ([+-]) OFFHH ":" OFFMM -- with nothing after. Calendar validity is checked by the
-// caller. `offset` carries the numeric-offset hours/minutes when present, else null.
 function _scanDateTime(v) {
   var n = v.length, p = 0;
   var year = _digitsAt(v, p, 4); if (year === null) return null; p += 4;
@@ -44,7 +37,7 @@ function _scanDateTime(v) {
   var min = _digitsAt(v, p, 2); if (min === null) return null; p += 2;
   if (v.charAt(p) !== ":") return null; p += 1;
   var sec = _digitsAt(v, p, 2); if (sec === null) return null; p += 2;
-  if (v.charAt(p) === ".") {   // optional fractional second: "." + one or more digits
+  if (v.charAt(p) === ".") {
     p += 1;
     var fracStart = p;
     while (p < n) { var fc = v.charCodeAt(p); if (fc < 48 || fc > 57) break; p += 1; }
@@ -60,40 +53,30 @@ function _scanDateTime(v) {
     var offMin = _digitsAt(v, p, 2); if (offMin === null) return null; p += 2;
     offset = { hour: offHour, min: offMin };
   } else {
-    return null;   // a zone is required
+    return null;
   }
-  if (p !== n) return null;   // no trailing characters
+  if (p !== n) return null;
   return { year: year, month: month, day: day, hour: hour, min: min, sec: sec, offset: offset };
 }
 
-// isValid(v) -> boolean: v is a syntactically well-formed AND calendar-valid RFC 3339 date-time string.
 function isValid(v) {
   if (typeof v !== "string") return false;
   var t = _scanDateTime(v);
   if (!t) return false;
   if (t.month < 1 || t.month > 12) return false;
-  // Reject a :60 leap second (Node's Date.parse returns NaN for it, so a comparison on such a value
-  // would silently pass) and any hour/minute/second out of range.
   if (t.hour > 23 || t.min > 59 || t.sec > 59) return false;
   var leap = (t.year % 4 === 0 && t.year % 100 !== 0) || t.year % 400 === 0;
   var daysInMonth = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
   if (t.day < 1 || t.day > daysInMonth[t.month - 1]) return false;
-  if (t.offset) { if (t.offset.hour > 23 || t.offset.min > 59) return false; }   // a numeric zone offset must itself be valid
+  if (t.offset) { if (t.offset.hour > 23 || t.offset.min > 59) return false; }
   return true;
 }
 
-// parse(v, E, code, label) -> Date: a calendar-valid RFC 3339 date-time as a comparable Date; otherwise
-// throws E(code, message) (the caller's (code, message) factory). isValid guarantees `new Date(v)` is a
-// real instant (never NaN), so a returned Date is always safe to compare.
 function parse(v, E, code, label) {
   if (!isValid(v)) throw E(code, (label || "the value") + " is not a valid RFC 3339 date-time");
   return new Date(v);
 }
 
-// RFC 3339 sec. 5.6 `full-date`: a calendar date with no time component. A distinct production from
-// the date-time above, and deliberately a separate pair of functions instead of a flag: a consumer
-// that expects one and is handed the other has a malformed value, not a permissible variant.
-// RFC 3339 full-date scanned into its components (YYYY "-" MM "-" DD, nothing after), or null.
 function _scanFullDate(v) {
   var p = 0;
   var year = _digitsAt(v, p, 4); if (year === null) return null; p += 4;
@@ -105,9 +88,6 @@ function _scanFullDate(v) {
   return { year: year, month: month, day: day };
 }
 
-// isValidDate(v) -> boolean: v is a syntactically well-formed AND calendar-valid RFC 3339 full-date.
-// Calendar validity matters as much as shape: "2021-02-30" parses as a Date in JS by rolling over
-// into March, so a shape-only check would silently accept a day that does not exist.
 function isValidDate(v) {
   if (typeof v !== "string") return false;
   var t = _scanFullDate(v);
@@ -118,9 +98,6 @@ function isValidDate(v) {
   return t.day >= 1 && t.day <= daysInMonth[t.month - 1];
 }
 
-// parseDate(v, E, code, label) -> Date at UTC midnight. Anchored explicitly at UTC ("T00:00:00Z")
-// instead of left to `new Date("YYYY-MM-DD")`, so the instant does not shift with the host time
-// zone. A freshness or rollback comparison must not depend on where it runs.
 function parseDate(v, E, code, label) {
   if (!isValidDate(v)) throw E(code, (label || "the value") + " is not a valid RFC 3339 full-date (YYYY-MM-DD)");
   return new Date(v + "T00:00:00Z");