@blamejs/pki 0.6.14 → 0.6.16

package/lib/cms-compress.js

@@ -1,19 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright (c) blamejs contributors
 "use strict";
-//
-// @internal -- the pki.cms.compress / pki.cms.decompress implementation. The operator-facing
+// @internal
 // @module pki.cms + the @primitive blocks live in cms-verify.js, which re-exports these (the
-// cms-encrypt.js / cms-decrypt.js model).
-//
-// CMS CompressedData (RFC 3274) -- the size-transform content type. compress ZLIB-compresses
-// (RFC 1950 / RFC 1951) the content and wraps it as a CompressedData ContentInfo; decompress parses
-// one (over the shipped strict schema-cms parser), enforces version 0 + id-alg-zlibCompress +
-// absent-or-NULL params (RFC 3274 sec. 2), and BOUNDED-inflates the eContent. There is NO crypto
-// here -- CompressedData provides no integrity / confidentiality / authentication (RFC 8551 sec.
-// 2.4.5); it is purely a size transform. The one load-bearing defense is the decompression-bomb
-// cap: inflate stops at C.LIMITS.COMPRESS_MAX_BYTES before the output is materialized (a
-// resource-exhaustion defense, CWE-409), and every zlib fault collapses to a uniform typed error.
 
 var zlib = require("zlib");
 var oid = require("./oid");
@@ -29,12 +18,8 @@ function O(n) { return oid.byName(n); }
 function _err(code, message, cause) { return new CmsError(code, message, cause); }
 
 var OID_ZLIB = O("id-alg-zlibCompress");
-// The NULL params DER (0x05 0x00) -- the one non-absent encoding RFC 3274 sec. 2 permits (MAY be NULL).
 var NULL_PARAMS_DER = Buffer.from([0x05, 0x00]);
 
-// Compress `content` and wrap it as a CMS CompressedData ContentInfo (RFC 3274 sec. 1.1): version 0,
-// compressionAlgorithm = id-alg-zlibCompress with ABSENT parameters, encapContentInfo = { eContentType
-// (default id-data), eContent = the RFC 1950 ZLIB stream }.
 async function compress(content, opts) {
   opts = opts || {};
   var raw = guard.bytes.source(content, CmsError, "cms/bad-input", "content");
@@ -48,29 +33,25 @@ async function compress(content, opts) {
   catch (e) { throw _err("cms/bad-input", "the content could not be compressed (check opts.level)", e); }
   var cd = b.sequence([
     b.integer(0),
-    b.sequence([b.oid(OID_ZLIB)]),                 // compressionAlgorithm, params ABSENT (RFC 3274 sec. 2)
+    b.sequence([b.oid(OID_ZLIB)]),
     b.sequence([b.oid(ctOid), b.explicit(0, b.octetString(stream))]),
   ]);
   var ci = b.sequence([b.oid(O("compressedData")), b.explicit(0, cd)]);
   return opts.pem ? schemaCms.pemEncode(ci, "CMS") : ci;
 }
 
-// Parse a CMS CompressedData and recover its content. Requires contentTypeName == compressedData,
-// version 0 (enforced by the parser), compressionAlgorithm == id-alg-zlibCompress with absent-or-NULL
-// params, and a present eContent; then BOUNDED-inflates. Every failure is a typed CmsError.
 async function decompress(input, opts) {
   opts = opts || {};
   var cap = C.LIMITS.COMPRESS_MAX_BYTES;
   if (opts.maxOutputBytes !== undefined) {
     var mo = opts.maxOutputBytes;
     if (typeof mo !== "number" || !isFinite(mo) || mo <= 0 || Math.floor(mo) !== mo) throw _err("cms/bad-input", "opts.maxOutputBytes must be a positive integer");
-    if (mo < cap) cap = mo;   // a caller may tighten the cap DOWNWARD only, never loosen it
+    if (mo < cap) cap = mo;
   }
   var parsed = schemaCms.parse(_toDer(input));
   if (parsed.contentTypeName !== "compressedData") throw _err("cms/unsupported-content-type", "input is not a CMS CompressedData (got " + parsed.contentTypeName + ")");
   var alg = parsed.compressionAlgorithm;
   if (alg.oid !== OID_ZLIB) throw _err("cms/unsupported-algorithm", "unsupported compressionAlgorithm " + (alg.name || alg.oid) + " (only id-alg-zlibCompress, RFC 3274 sec. 2)");
-  // RFC 3274 sec. 2: the parameters SHOULD be omitted but MAY be NULL. Reject any other encoding.
   if (alg.parameters != null && Buffer.compare(alg.parameters, NULL_PARAMS_DER) !== 0) throw _err("cms/bad-algorithm-parameters", "id-alg-zlibCompress parameters must be absent or NULL (RFC 3274 sec. 2)");
   var eci = parsed.encapContentInfo;
   if (eci.eContent == null) throw _err("cms/no-encapsulated-content", "the CompressedData carries no encapsulated content (a detached CompressedData cannot be decompressed)");
@@ -79,8 +60,6 @@ async function decompress(input, opts) {
     content: content,
     contentType: eci.eContentType,
     contentTypeName: oid.name(eci.eContentType) || eci.eContentType,
-    // Coverage residual: reaching here requires alg.oid === id-alg-zlibCompress (line above), which is
-    // always a registered name, so the `|| alg.oid` fallback is a defensive belt, never selected.
     compressionAlgorithm: alg.name || alg.oid,
   };
 }
@@ -91,14 +70,6 @@ function _toDer(input) {
   throw _err("cms/bad-input", "input must be a DER Buffer, Uint8Array, or PEM string");
 }
 
-// Inflate the RFC 1950 ZLIB stream through the shared bounded-decompression guard, which applies
-// the output cap at the decompressor (so a bomb is refused mid-stream, before it is allocated) and
-// requires the whole octet string to be exactly one compressed frame (so trailing bytes cannot give
-// one content a second encoding). This module keeps its own verdict codes: a cap breach is
-// cms/decompress-too-large, every other fault the uniform cms/decompress-failed.
-//
-// `_err` is a factory and the guard calls it as one. Handing it CmsError instead would throw
-// "class cannot be invoked without new" on the rejection path, turning a refusal into a crash.
 function _inflateBounded(stream, cap) {
   var view = guard.bytes.view(stream, CmsError, "cms/decompress-failed", "the compressed content");
   return guard.compress.bounded("zlib", view, cap, _err,