@blamejs/core 0.14.0 → 0.14.2

package/lib/mail-auth.js

@@ -70,12 +70,12 @@ var SPF_DNS_LOOKUP_LIMIT = 10;
 // that the policy MUST permerror. Attackers chain misconfigured
 // `include:`s pointing at non-existent domains to amplify recursive
 // resolver work without tripping the 10-lookup ceiling.
-var SPF_VOID_LOOKUP_LIMIT = 2;                                                   // allow:raw-byte-literal — RFC 7208 §4.6.4 void-lookup ceiling
+var SPF_VOID_LOOKUP_LIMIT = 2;                                                   // RFC 7208 §4.6.4 void-lookup ceiling
 
 // RFC 7208 §3.3 — each SPF TXT record MUST NOT exceed 450 bytes when
 // concatenated across multi-string TXT chunks. The spec lifts a
 // receiver MUST-refuse on >450-byte records to bound parse work.
-var SPF_RECORD_MAX_BYTES = 450;                                                  // allow:raw-byte-literal — RFC 7208 §3.3 record ceiling
+var SPF_RECORD_MAX_BYTES = 450;                                                  // RFC 7208 §3.3 record ceiling
 
 // SPF redirect= modifier (RFC 7208 §6.1) recursion cap. The modifier
 // re-evaluates against a different domain; a chain of redirect= cycles
@@ -84,7 +84,7 @@ var SPF_RECORD_MAX_BYTES = 450;
 // hard cap below is an additional belt-and-braces against malformed
 // upstream policies that would otherwise spin until the lookup cap
 // alone tripped.
-var SPF_REDIRECT_DEPTH_LIMIT = 10;                                               // allow:raw-byte-literal — same shape as RFC 7208 §4.6.4 lookup ceiling
+var SPF_REDIRECT_DEPTH_LIMIT = 10;                                               // same shape as RFC 7208 §4.6.4 lookup ceiling
 
 // Shared safe-DNS TXT/A/AAAA/MX/PTR lookup. Operator-supplied
 // `dnsLookup(qname, type)` is honored for every type when present:
@@ -114,7 +114,7 @@ async function _safeResolveTxt(qname, operatorLookup) {
   var out = [];
   for (var i = 0; i < r.rrs.length; i += 1) {
     var rr = r.rrs[i];
-    if (rr && rr.type === 16) {                                                  // allow:raw-byte-literal — IANA DNS qtype TXT
+    if (rr && rr.type === 16) {                                                  // IANA DNS qtype TXT
       out.push(Array.isArray(rr.decoded) ? rr.decoded : [String(rr.decoded)]);
     }
   }
@@ -145,7 +145,7 @@ async function _safeResolveA(qname, family /* 4|6 */, operatorLookup) {
   var out = [];
   for (var i = 0; i < r.rrs.length; i += 1) {
     var rr = r.rrs[i];
-    var wantType = family === 6 ? 28 : 1;                                        // allow:raw-byte-literal — IANA DNS qtype AAAA / A
+    var wantType = family === 6 ? 28 : 1;                                        // IANA DNS qtype AAAA / A
     if (rr && rr.type === wantType) out.push(rr.decoded);
   }
   if (out.length === 0) {
@@ -183,7 +183,7 @@ async function _safeResolveMx(qname, operatorLookup) {
   var entries = [];
   for (var i = 0; i < r.rrs.length; i += 1) {
     var rr = r.rrs[i];
-    if (rr && rr.type === 15) {                                                  // allow:raw-byte-literal — IANA DNS qtype MX
+    if (rr && rr.type === 15) {                                                  // IANA DNS qtype MX
       var d = rr.decoded || {};
       if (d.exchange) {
         entries.push({ exchange: String(d.exchange).replace(/\.$/, ""),
@@ -213,7 +213,7 @@ async function _safeReverse(ip) {
   var out = [];
   for (var i = 0; i < r.rrs.length; i += 1) {
     var rr = r.rrs[i];
-    if (rr && rr.type === 12) {                                                  // allow:raw-byte-literal — IANA DNS qtype PTR
+    if (rr && rr.type === 12) {                                                  // IANA DNS qtype PTR
       // Strip trailing dot if present (PTR rdata is FQDN with root dot).
       var name = String(rr.decoded || "").replace(/\.$/, "");
       if (name.length > 0) out.push(name);
@@ -231,7 +231,7 @@ function _ipToReverseArpa(ip) {
   if (typeof ip !== "string") return null;
   if (net.isIPv4(ip)) {
     var p = ip.split(".");
-    if (p.length !== 4) return null;                                             // allow:raw-byte-literal — IPv4 octet count
+    if (p.length !== 4) return null;                                             // IPv4 octet count
     return p[3] + "." + p[2] + "." + p[1] + "." + p[0] + ".in-addr.arpa";
   }
   if (net.isIPv6(ip)) {
@@ -239,8 +239,8 @@ function _ipToReverseArpa(ip) {
     if (!groups) return null;
     var hex = "";
     for (var i = 0; i < groups.length; i += 1) {
-      var s = groups[i].toString(16);                                            // allow:raw-byte-literal — hex radix
-      while (s.length < 4) s = "0" + s;                                          // allow:raw-byte-literal — IPv6 group nibble count
+      var s = groups[i].toString(16);                                            // hex radix
+      while (s.length < 4) s = "0" + s;                                          // IPv6 group nibble count
       hex += s;
     }
     var rev = hex.split("").reverse().join(".");
@@ -253,12 +253,12 @@ function _ipToReverseArpa(ip) {
 
 function _ipv4ToInt(ip) {
   var parts = ip.split(".");
-  if (parts.length !== 4) return null;                                           // allow:raw-byte-literal — IPv4 octet count
+  if (parts.length !== 4) return null;                                           // IPv4 octet count
   var n = 0;
-  for (var i = 0; i < 4; i += 1) {                                               // allow:raw-byte-literal — IPv4 octet count
+  for (var i = 0; i < 4; i += 1) {                                               // IPv4 octet count
     var p = parseInt(parts[i], 10);
-    if (!isFinite(p) || p < 0 || p > 255) return null;                           // allow:raw-byte-literal — IPv4 octet range
-    n = (n * 256) + p;                                                           // allow:raw-byte-literal — IPv4 octet base
+    if (!isFinite(p) || p < 0 || p > 255) return null;                           // IPv4 octet range
+    n = (n * 256) + p;                                                           // IPv4 octet base
   }
   return n;
 }
@@ -274,20 +274,20 @@ function _ipv6Expand(ip) {
 function _ipv6InCidr(ip, cidr) {
   var slash = cidr.indexOf("/");
   var net = slash === -1 ? cidr : cidr.slice(0, slash);
-  var mask = slash === -1 ? 128 : parseInt(cidr.slice(slash + 1), 10);                        // allow:raw-byte-literal — IPv6 max prefix
-  if (!isFinite(mask) || mask < 0 || mask > 128) return false;                                // allow:raw-byte-literal — IPv6 max prefix
+  var mask = slash === -1 ? 128 : parseInt(cidr.slice(slash + 1), 10);                        // IPv6 max prefix
+  if (!isFinite(mask) || mask < 0 || mask > 128) return false;                                // IPv6 max prefix
   var ipGroups  = _ipv6Expand(ip);
   var netGroups = _ipv6Expand(net);
   if (!ipGroups || !netGroups) return false;
   if (mask === 0) return true;
   // Compare group-by-group up to the prefix boundary.
-  var fullGroups = Math.floor(mask / 16);                                                     // allow:raw-byte-literal — bits per group
-  var remainBits = mask - fullGroups * 16;                                                    // allow:raw-byte-literal — bits per group
+  var fullGroups = Math.floor(mask / 16);                                                     // bits per group
+  var remainBits = mask - fullGroups * 16;                                                    // bits per group
   for (var g = 0; g < fullGroups; g += 1) {
     if (ipGroups[g] !== netGroups[g]) return false;
   }
-  if (remainBits > 0 && fullGroups < 8) {                                                     // allow:raw-byte-literal — IPv6 group count
-    var groupMask = (0xffff << (16 - remainBits)) & 0xffff;                                   // allow:raw-byte-literal — bits per group
+  if (remainBits > 0 && fullGroups < 8) {                                                     // IPv6 group count
+    var groupMask = (0xffff << (16 - remainBits)) & 0xffff;                                   // bits per group
     if ((ipGroups[fullGroups] & groupMask) !== (netGroups[fullGroups] & groupMask)) return false;
   }
   return true;
@@ -296,13 +296,13 @@ function _ipv6InCidr(ip, cidr) {
 function _ipv4InCidr(ip, cidr) {
   var slash = cidr.indexOf("/");
   var net = slash === -1 ? cidr : cidr.slice(0, slash);
-  var mask = slash === -1 ? 32 : parseInt(cidr.slice(slash + 1), 10);             // allow:raw-byte-literal — IPv4 max prefix
-  if (mask < 0 || mask > 32) return false;                                       // allow:raw-byte-literal — IPv4 max prefix
+  var mask = slash === -1 ? 32 : parseInt(cidr.slice(slash + 1), 10);             // IPv4 max prefix
+  if (mask < 0 || mask > 32) return false;                                       // IPv4 max prefix
   var ipInt = _ipv4ToInt(ip);
   var netInt = _ipv4ToInt(net);
   if (ipInt === null || netInt === null) return false;
   if (mask === 0) return true;
-  var bits = 32 - mask;                                                          // allow:raw-byte-literal — IPv4 max prefix
+  var bits = 32 - mask;                                                          // IPv4 max prefix
   // Use BigInt to avoid 32-bit signed-int wrap.
   var maskInt = (BigInt("0xFFFFFFFF") << BigInt(bits)) & BigInt("0xFFFFFFFF");
   return (BigInt(ipInt) & maskInt) === (BigInt(netInt) & maskInt);
@@ -411,8 +411,8 @@ async function _fetchSpfRecord(domain, dnsLookup) {
 function _parseADualCidr(raw, mech, defaultDomain) {
   var rest   = raw.slice(mech.length);
   var domain = defaultDomain;
-  var v4Mask = 32;                                                                 // allow:raw-byte-literal — IPv4 max prefix
-  var v6Mask = 128;                                                                // allow:raw-byte-literal — IPv6 max prefix
+  var v4Mask = 32;                                                                 // IPv4 max prefix
+  var v6Mask = 128;                                                                // IPv6 max prefix
 
   if (rest.charAt(0) === ":") {
     rest = rest.slice(1);
@@ -451,7 +451,7 @@ function _parseADualCidr(raw, mech, defaultDomain) {
           JSON.stringify(raw));
       }
       var v4n = parseInt(v4Str, 10);
-      if (!isFinite(v4n) || v4n < 0 || v4n > 32 || String(v4n) !== v4Str) {         // allow:raw-byte-literal — IPv4 max prefix
+      if (!isFinite(v4n) || v4n < 0 || v4n > 32 || String(v4n) !== v4Str) {         // IPv4 max prefix
         throw new MailAuthError("mail-auth/spf-bad-cidr",
           "SPF " + mech + " v4 cidr-length invalid: " + JSON.stringify(raw));
       }
@@ -468,7 +468,7 @@ function _parseADualCidr(raw, mech, defaultDomain) {
           JSON.stringify(raw));
       }
       var v6n = parseInt(v6Part, 10);
-      if (!isFinite(v6n) || v6n < 0 || v6n > 128 || String(v6n) !== v6Part) {       // allow:raw-byte-literal — IPv6 max prefix
+      if (!isFinite(v6n) || v6n < 0 || v6n > 128 || String(v6n) !== v6Part) {       // IPv6 max prefix
         throw new MailAuthError("mail-auth/spf-bad-cidr",
           "SPF " + mech + " v6 cidr-length invalid: " + JSON.stringify(raw));
       }
@@ -509,7 +509,7 @@ async function _spfMatchAMx(mech, raw, ip, isIpv6, defaultDomain, dnsLookup, loo
   catch (e) { return { error: "permerror", reason: e.message }; }
 
   var mask = isIpv6 ? parsed.v6Mask : parsed.v4Mask;
-  var family = isIpv6 ? 6 : 4;                                                     // allow:raw-byte-literal — IP family marker
+  var family = isIpv6 ? 6 : 4;                                                     // IP family marker
 
   var targetIps = [];
   if (mech === "a") {
@@ -535,7 +535,7 @@ async function _spfMatchAMx(mech, raw, ip, isIpv6, defaultDomain, dnsLookup, loo
     // Crossing this is a permerror; receivers MUST NOT silently
     // truncate, since a misconfigured sender publishing 20 MX hosts
     // would otherwise have only the first 10 contribute to authz.
-    if (mxHosts.length > 10) {                                                      // allow:raw-byte-literal — RFC 7208 §4.6.4 MX limit
+    if (mxHosts.length > 10) {                                                      // RFC 7208 §4.6.4 MX limit
       return { error: "permerror",
                reason: "SPF mx:" + parsed.domain + " resolved " + mxHosts.length +
                        " MX hosts (RFC 7208 §4.6.4 caps at 10)" };
@@ -831,7 +831,7 @@ var DMARCBIS_VALID_PSD = { y: 1, n: 1, u: 1 };
 
 function _parseDmarcRecord(text) {
   var policy = { v: null, p: null, sp: null, np: null, psd: null,
-                 pct: 100, adkim: "r", aspf: "r" };                              // allow:raw-byte-literal — RFC 7489 default pct
+                 pct: 100, adkim: "r", aspf: "r" };                              // RFC 7489 default pct
   var pairs = text.split(";");                                                              // allow:bare-split-on-quoted-header — RFC 7489 §6.4 DMARC tag-list grammar: `tag-spec *( ";" tag-spec )` with tag-value = 0*( tval *( WSP / FWS ) ); NO quoted-string allowed
   for (var i = 0; i < pairs.length; i += 1) {
     var kv = pairs[i].trim();
@@ -1023,8 +1023,8 @@ async function dmarcEvaluate(opts) {
   // retry-stable. The fallback is the framework's hardening floor
   // (replaces Math.random); retry-stability requires the operator to
   // wire a key.
-  var pctRaw = parseInt(policy.pct, 10);                                                       // allow:raw-byte-literal — pct percentage, not bytes
-  var pct = isFinite(pctRaw) && pctRaw >= 0 && pctRaw <= 100 ? pctRaw : 100;                    // allow:raw-byte-literal — pct percentage, not bytes
+  var pctRaw = parseInt(policy.pct, 10);                                                       // pct percentage, not bytes
+  var pct = isFinite(pctRaw) && pctRaw >= 0 && pctRaw <= 100 ? pctRaw : 100;                    // pct percentage, not bytes
   var sampleRoll;
   if (typeof opts.pctSampleKey === "string" && opts.pctSampleKey.length > 0) {
     // Deterministic per-message sample roll. SHAKE256 → first 4 bytes
@@ -1032,10 +1032,10 @@ async function dmarcEvaluate(opts) {
     // information needed for 0..99 and uniform mapping is fine.
     var hash = nodeCrypto.createHash("shake256", { outputLength: 4 })
                           .update(String(opts.pctSampleKey)).digest();
-    var u32 = (hash[0] << 24 >>> 0) + (hash[1] << 16) + (hash[2] << 8) + hash[3];               // allow:raw-byte-literal — uint32 bit assembly
-    sampleRoll = u32 % 100;                                                                     // allow:raw-byte-literal — pct sample roll
+    var u32 = (hash[0] << 24 >>> 0) + (hash[1] << 16) + (hash[2] << 8) + hash[3];               // uint32 bit assembly
+    sampleRoll = u32 % 100;                                                                     // pct sample roll
   } else {
-    sampleRoll = bCrypto.randomInt(0, 100);                                                     // allow:raw-byte-literal — pct sample roll
+    sampleRoll = bCrypto.randomInt(0, 100);                                                     // pct sample roll
   }
   var sampled = !pass && pct < 100 && sampleRoll >= pct;
   var recommendedAction = pass ? "deliver" :
@@ -1098,7 +1098,7 @@ function _parseHeaderLines(headerSection) {
 
 // RFC 8617 §5.1.2 caps the chain at 50 sets to bound verifier work and
 // limit how far an attacker can push junk headers.
-var ARC_MAX_HOPS = 50;                                                           // allow:raw-byte-literal — RFC 8617 §5.1.2 chain ceiling
+var ARC_MAX_HOPS = 50;                                                           // RFC 8617 §5.1.2 chain ceiling
 
 async function arcVerify(rfc822, opts) {
   if (typeof rfc822 !== "string" || rfc822.length === 0) {
@@ -1253,7 +1253,7 @@ async function arcVerify(rfc822, opts) {
   // timestamp) and x= (expiration) tags. Default 5 min.
   var arcClockSkewMs = typeof opts.clockSkewMs === "number" && opts.clockSkewMs >= 0           // allow:numeric-opt-Infinity — operator-supplied skew, default 5 min
     ? opts.clockSkewMs : C.TIME.minutes(5);
-  var nowSec = Math.floor(Date.now() / 1000);                                                  // allow:raw-byte-literal — Unix epoch seconds divisor
+  var nowSec = Math.floor(Date.now() / 1000);                                                  // Unix epoch seconds divisor
 
   for (var hopIdx = 0; hopIdx < hops.length; hopIdx += 1) {
     var hop = hops[hopIdx];
@@ -1268,7 +1268,7 @@ async function arcVerify(rfc822, opts) {
     var amsX = amsTags.x ? parseInt(amsTags.x, 10) : null;
     var asT  = asTags.t  ? parseInt(asTags.t, 10)  : null;
     var asX  = asTags.x  ? parseInt(asTags.x, 10)  : null;
-    var skewSec = Math.floor(arcClockSkewMs / 1000);                                          // allow:raw-byte-literal — sec divisor
+    var skewSec = Math.floor(arcClockSkewMs / 1000);                                          // sec divisor
     var timeFault = null;
     if (amsT && isFinite(amsT) && amsT - skewSec > nowSec) timeFault = "ams-t-future";
     if (amsX && isFinite(amsX) && amsX + skewSec < nowSec) timeFault = "ams-x-expired";
@@ -1512,8 +1512,8 @@ function _canonRelaxedHeader(name, value) {
 
 function _pemFromB64KeyMaterial(b64) {
   var pem = "-----BEGIN PUBLIC KEY-----\n";
-  for (var i = 0; i < b64.length; i += 64) {                                     // allow:raw-byte-literal — PEM wrap width
-    pem += b64.slice(i, i + 64) + "\n";                                          // allow:raw-byte-literal — PEM wrap width
+  for (var i = 0; i < b64.length; i += 64) {                                     // PEM wrap width
+    pem += b64.slice(i, i + 64) + "\n";                                          // PEM wrap width
   }
   pem += "-----END PUBLIC KEY-----\n";
   return pem;
@@ -1819,7 +1819,7 @@ function authResultsEmit(opts) {
 //   //   }
 
 var DMARC_RUA_MAX_REPORT_BYTES = C.BYTES.mib(8);
-var DMARC_RUA_MAX_RECORDS_PER_REPORT = 10000;                                     // allow:raw-byte-literal allow:raw-time-literal — record cap, not seconds
+var DMARC_RUA_MAX_RECORDS_PER_REPORT = 10000;                                     // allow:raw-time-literal — record cap, not seconds
 
 function _arrayOf(value) {
   if (value === undefined || value === null) return [];
@@ -2020,7 +2020,7 @@ function _shapeAggregateReport(parsed) {
 function _isValidPtrName(name) {
   if (typeof name !== "string") return false;
   var trimmed = name.replace(/\.$/, "");
-  if (trimmed.length === 0 || trimmed.length > 253) return false;                // allow:raw-byte-literal — RFC 1035 hostname cap
+  if (trimmed.length === 0 || trimmed.length > 253) return false;                // RFC 1035 hostname cap
   // Labels: 1..63 octets, LDH (letter / digit / hyphen) + leading
   // alphanum (RFC 1035 §2.3.1). Permissive: PTR rdata can in practice
   // contain underscores (mail-server idiom) — allow underscore in
@@ -2028,7 +2028,7 @@ function _isValidPtrName(name) {
   var labels = trimmed.split(".");
   for (var i = 0; i < labels.length; i += 1) {
     var lab = labels[i];
-    if (lab.length === 0 || lab.length > 63) return false;                       // allow:raw-byte-literal — RFC 1035 label cap
+    if (lab.length === 0 || lab.length > 63) return false;                       // RFC 1035 label cap
     if (!/^[A-Za-z0-9_](?:[A-Za-z0-9_-]{0,61}[A-Za-z0-9_])?$/.test(lab)) return false;
   }
   return true;

package/lib/mail-bimi.js

@@ -387,7 +387,7 @@ function validateTinyPsSvg(svgBytes) {
     if (t.type === "processingInstruction") {
       var pir = (t.raw || "").trim();
       if (!/^<\?xml\b/i.test(pir)) {
-        _vio("pi-forbidden", "processing instruction is forbidden in Tiny-PS: " + pir.slice(0, 40))   /* allow:raw-byte-literal — display truncation chars, not bytes */;
+        _vio("pi-forbidden", "processing instruction is forbidden in Tiny-PS: " + pir.slice(0, 40))   /* display truncation chars, not bytes */;
       }
       continue;
     }
@@ -979,7 +979,7 @@ function _extractBimiCertPolicy(cert) {
       // RFC 3709 4.1 - LogotypeExtn carries SubjectLogo (best-effort
       // SVG extraction; full RFC 3709 unpack requires walking nested
       // SEQUENCEs to LogotypeImageData).
-      var found = _scanForEmbeddedSvg(inner, 8); /* allow:raw-byte-literal — string-prefix length for magic-bytes match, not bytes */
+      var found = _scanForEmbeddedSvg(inner, 8); /* string-prefix length for magic-bytes match, not bytes */
       if (found) rv.logoSvg = found;
     }
   }
@@ -992,7 +992,7 @@ function _scanForEmbeddedSvg(node, depthBudget) {
 
   if (!node.constructed) {
     if (!node.value || node.value.length < 4) return null;
-    var prefix = node.value.slice(0, Math.min(node.value.length, 64)).toString("utf8");   /* allow:raw-byte-literal — display truncation length, not bytes */
+    var prefix = node.value.slice(0, Math.min(node.value.length, 64)).toString("utf8");   /* display truncation length, not bytes */
     if (prefix.indexOf("<svg") !== -1 || /<\?xml[\s\S]*<svg/.test(prefix)) {
       return node.value.toString("utf8");
     }

package/lib/mail-crypto-pgp.js

@@ -84,7 +84,7 @@
  *       audit:          opts.audit,            // optional b.audit handle
  *     });
  *     // → { armored: "-----BEGIN PGP SIGNATURE----- ...",
- *     //     multipartSigned: "Content-Type: multipart/signed; ...",
+ *     //     multipartSigned: <Buffer ...>,   // RFC 3156 wrapper bytes
  *     //     signedAt:        epochSeconds, fingerprint: "abcd..." }
  *
  *     var rv = b.mail.crypto.pgp.verify({
@@ -122,23 +122,23 @@ var { defineClass } = require("./framework-error");
 var MailCryptoError = defineClass("MailCryptoError", { alwaysPermanent: true });
 
 // RFC 9580 §9 public-key algorithm IDs that this module emits/accepts.
-var PUB_ALG_RSA            = 1;   // allow:raw-byte-literal — RFC 9580 §9.1 RSA
-var PUB_ALG_ED25519_LEGACY = 22;  // allow:raw-byte-literal — RFC 9580 §9.1 EdDSA Ed25519Legacy
+var PUB_ALG_RSA            = 1;   // RFC 9580 §9.1 RSA
+var PUB_ALG_ED25519_LEGACY = 22;  // RFC 9580 §9.1 EdDSA Ed25519Legacy
 
 // RFC 9580 §9.5 hash algorithm IDs.
-var HASH_ALG_SHA256 = 8;          // allow:raw-byte-literal — RFC 9580 §9.5 SHA2-256
-var HASH_ALG_SHA512 = 10;         // allow:raw-byte-literal — RFC 9580 §9.5 SHA2-512
+var HASH_ALG_SHA256 = 8;          // RFC 9580 §9.5 SHA2-256
+var HASH_ALG_SHA512 = 10;         // RFC 9580 §9.5 SHA2-512
 
 // RFC 9580 §5.2.1 signature type — Signature of a binary document.
-var SIG_TYPE_BINARY = 0;          // allow:raw-byte-literal — RFC 9580 §5.2.1
+var SIG_TYPE_BINARY = 0;          // RFC 9580 §5.2.1
 
 // RFC 9580 §5.2.3.1 subpacket types we emit / consume.
-var SUBPKT_SIG_CREATION_TIME = 2;  // allow:raw-byte-literal — RFC 9580 §5.2.3.4
-var SUBPKT_ISSUER_FPR        = 33; // allow:raw-byte-literal — RFC 9580 §5.2.3.35 Issuer Fingerprint
+var SUBPKT_SIG_CREATION_TIME = 2;  // RFC 9580 §5.2.3.4
+var SUBPKT_ISSUER_FPR        = 33; // RFC 9580 §5.2.3.35 Issuer Fingerprint
 
 // RSA modulus floor — matches DKIM RFC 8301 §3.1 and the framework's
 // cross-mail-surface posture (lib/mail-dkim.js RSA_WEAK_BITS).
-var RSA_MIN_BITS = 2048;          // allow:raw-byte-literal — RFC 8301 §3.1
+var RSA_MIN_BITS = 2048;          // RFC 8301 §3.1
 
 // ASCII armor framing per RFC 9580 §6.2.
 var ARMOR_BEGIN = "-----BEGIN PGP SIGNATURE-----";
@@ -564,19 +564,27 @@ function sign(opts) {
   // key/cert material flows through createSign/verify, not this path.
   // allow:raw-randombytes-token — boundary string, not auth credential
   var boundary = "blamejs-pgp-" + nodeCrypto.randomBytes(12).toString("hex");
-  var multipartSigned =
-    'Content-Type: multipart/signed; micalg="pgp-' + hashName + '"; ' +
-    'protocol="application/pgp-signature"; boundary="' + boundary + '"\r\n' +
-    "\r\n" +
-    "--" + boundary + "\r\n" +
-    (Buffer.isBuffer(message) ? message.toString("binary") : message) +
-    "\r\n--" + boundary + "\r\n" +
-    'Content-Type: application/pgp-signature; name="signature.asc"\r\n' +
-    "Content-Description: OpenPGP digital signature\r\n" +
-    'Content-Disposition: attachment; filename="signature.asc"\r\n' +
-    "\r\n" +
-    armored +
-    "--" + boundary + "--\r\n";
+  // The OpenPGP signature covers the signed-part bytes exactly, so the
+  // multipart/signed wrapper is assembled as a Buffer — a JS-string round
+  // trip through latin1/utf8 could corrupt non-ASCII signed content and
+  // break signature verification. `multipartSigned` is therefore a Buffer.
+  var messageBytes = Buffer.isBuffer(message) ? message : Buffer.from(message, "utf8");
+  var multipartSigned = Buffer.concat([
+    Buffer.from(
+      'Content-Type: multipart/signed; micalg="pgp-' + hashName + '"; ' +
+      'protocol="application/pgp-signature"; boundary="' + boundary + '"\r\n' +
+      "\r\n" +
+      "--" + boundary + "\r\n", "utf8"),
+    messageBytes,
+    Buffer.from(
+      "\r\n--" + boundary + "\r\n" +
+      'Content-Type: application/pgp-signature; name="signature.asc"\r\n' +
+      "Content-Description: OpenPGP digital signature\r\n" +
+      'Content-Disposition: attachment; filename="signature.asc"\r\n' +
+      "\r\n" +
+      armored +
+      "--" + boundary + "--\r\n", "utf8"),
+  ]);
 
   // Audit (drop-silent — never crash the request that triggered us).
   _audit(opts.audit, "mail.crypto.pgp.sign", "success", {
@@ -932,8 +940,8 @@ function _audit(auditHandle, action, outcome, metadata) {
 var bCrypto    = require("./crypto");
 var pqcSoftware = require("./pqc-software");
 
-var PGP_PQ_MAGIC = Buffer.from("BJ-PGP-PQ", "ascii");                                                 // allow:raw-byte-literal — 9-byte framework magic
-var PGP_PQ_VERSION = 1;                                                                               // allow:raw-byte-literal — envelope version
+var PGP_PQ_MAGIC = Buffer.from("BJ-PGP-PQ", "ascii");                                                 // 9-byte framework magic
+var PGP_PQ_VERSION = 1;                                                                               // envelope version
 
 function experimentalEncrypt(opts) {
   opts = validateOpts.requireObject(opts, "mail.crypto.pgp.experimental.encrypt",
@@ -948,7 +956,7 @@ function experimentalEncrypt(opts) {
       "encrypt: opts.recipients must be a non-empty array");
   }
   var plaintext = Buffer.isBuffer(opts.message) ? opts.message : Buffer.from(opts.message, "utf8");
-  var sessionKey = bCrypto.generateBytes(32);                                                         // allow:raw-byte-literal — 256-bit session key
+  var sessionKey = bCrypto.generateBytes(32);                                                         // 256-bit session key
   var ciphertext = bCrypto.encryptPacked(plaintext, sessionKey);
   var recipientBlobs = [];
   for (var i = 0; i < opts.recipients.length; i += 1) {
@@ -961,7 +969,7 @@ function experimentalEncrypt(opts) {
       throw new MailCryptoError("mail-crypto/pgp/bad-recipient",
         "encrypt: recipients[" + i + "].publicKey must be a Uint8Array (ML-KEM-1024)");
     }
-    if (r.recipientId.length > 255) {                                                                 // allow:raw-byte-literal — u8 length cap
+    if (r.recipientId.length > 255) {                                                                 // u8 length cap
       throw new MailCryptoError("mail-crypto/pgp/bad-recipient",
         "encrypt: recipients[" + i + "].recipientId must be <= 255 bytes");
     }
@@ -969,7 +977,7 @@ function experimentalEncrypt(opts) {
     var kek = bCrypto.kdf(Buffer.concat([
       Buffer.from(encap.sharedSecret),
       Buffer.from("pgp/experimental/chacha20-poly1305", "ascii"),
-    ]), 32);                                                                                          // allow:raw-byte-literal — 256-bit KEK
+    ]), 32);                                                                                          // 256-bit KEK
     var wrappedKey = bCrypto.encryptPacked(sessionKey, kek);
     var ct = Buffer.from(encap.cipherText);
     recipientBlobs.push(Buffer.concat([
@@ -984,7 +992,7 @@ function experimentalEncrypt(opts) {
   var envelope = Buffer.concat([
     PGP_PQ_MAGIC,
     Buffer.from([PGP_PQ_VERSION]),
-    Buffer.from([opts.recipients.length]),                                                            // allow:raw-byte-literal — u8 recipient count
+    Buffer.from([opts.recipients.length]),                                                            // u8 recipient count
     Buffer.concat(recipientBlobs),
     _u32be(ciphertext.length),
     ciphertext,
@@ -1038,9 +1046,9 @@ function experimentalDecrypt(opts) {
     }
     var ridLen = envelope[off]; off += 1;
     var rid = envelope.slice(off, off + ridLen); off += ridLen;
-    var ctLen = envelope.readUInt16BE(off); off += 2;                                                 // allow:raw-byte-literal — u16-be width
+    var ctLen = envelope.readUInt16BE(off); off += 2;                                                 // u16-be width
     var ct = envelope.slice(off, off + ctLen); off += ctLen;
-    var wkLen = envelope.readUInt16BE(off); off += 2;                                                 // allow:raw-byte-literal — u16-be width
+    var wkLen = envelope.readUInt16BE(off); off += 2;                                                 // u16-be width
     var wrappedKey = envelope.slice(off, off + wkLen); off += wkLen;
     if (matchedSessionKey) continue;
     if (!rid.equals(opts.recipientId)) continue;
@@ -1053,7 +1061,7 @@ function experimentalDecrypt(opts) {
     var kek = bCrypto.kdf(Buffer.concat([
       Buffer.from(shared),
       Buffer.from("pgp/experimental/chacha20-poly1305", "ascii"),
-    ]), 32);                                                                                          // allow:raw-byte-literal — 256-bit KEK
+    ]), 32);                                                                                          // 256-bit KEK
     try { matchedSessionKey = bCrypto.decryptPacked(wrappedKey, kek); }
     catch (e2) {
       throw new MailCryptoError("mail-crypto/pgp/unwrap-failed",
@@ -1064,7 +1072,7 @@ function experimentalDecrypt(opts) {
     throw new MailCryptoError("mail-crypto/pgp/no-matching-recipient",
       "decrypt: no recipient in envelope matches opts.recipientId");
   }
-  var bodyLen = envelope.readUInt32BE(off); off += 4;                                                 // allow:raw-byte-literal — u32-be width
+  var bodyLen = envelope.readUInt32BE(off); off += 4;                                                 // u32-be width
   var body = envelope.slice(off, off + bodyLen);
   var plaintext;
   try { plaintext = bCrypto.decryptPacked(body, matchedSessionKey); }
@@ -1079,8 +1087,8 @@ function experimentalDecrypt(opts) {
 function _armorMessage(bytes) {
   var b64 = bytes.toString("base64");
   var lines = [];
-  for (var i = 0; i < b64.length; i += 64) {                                                          // allow:raw-byte-literal — RFC 2045 base64 line length
-    lines.push(b64.slice(i, i + 64));                                                                 // allow:raw-byte-literal — RFC 2045 base64 line length
+  for (var i = 0; i < b64.length; i += 64) {                                                          // RFC 2045 base64 line length
+    lines.push(b64.slice(i, i + 64));                                                                 // RFC 2045 base64 line length
   }
   return "-----BEGIN PGP MESSAGE-----\r\nVersion: blamejs-pgp-pq-v1\r\n\r\n" +
          lines.join("\r\n") + "\r\n-----END PGP MESSAGE-----\r\n";
@@ -1159,7 +1167,7 @@ function wkdFetch(email, opts) {
   var maxBytes = typeof opts.maxKeyBytes === "number" ? opts.maxKeyBytes : (256 * 1024);            // allow:raw-byte-literal — 256 KiB default key cap
   var urls = wkdComputeUrl(email, { advancedHost: opts.advancedHost });
   return Promise.resolve(opts.httpsGet(urls.direct)).then(function (resp) {
-    if (resp && resp.status === 200 && Buffer.isBuffer(resp.body) && resp.body.length > 0) {          // allow:raw-byte-literal — HTTP 200
+    if (resp && resp.status === 200 && Buffer.isBuffer(resp.body) && resp.body.length > 0) {          // HTTP 200
       if (resp.body.length > maxBytes) {
         throw new MailCryptoError("mail-crypto/pgp/wkd-too-large",
           "wkd.fetch: key bytes " + resp.body.length + " exceed maxKeyBytes=" + maxBytes);
@@ -1167,7 +1175,7 @@ function wkdFetch(email, opts) {
       return { keyBytes: resp.body, source: "direct", url: urls.direct };
     }
     return Promise.resolve(opts.httpsGet(urls.advanced)).then(function (resp2) {
-      if (resp2 && resp2.status === 200 && Buffer.isBuffer(resp2.body) && resp2.body.length > 0) {    // allow:raw-byte-literal — HTTP 200
+      if (resp2 && resp2.status === 200 && Buffer.isBuffer(resp2.body) && resp2.body.length > 0) {    // HTTP 200
         if (resp2.body.length > maxBytes) {
           throw new MailCryptoError("mail-crypto/pgp/wkd-too-large",
             "wkd.fetch: key bytes " + resp2.body.length + " exceed maxKeyBytes=" + maxBytes);
@@ -1190,7 +1198,7 @@ function wkdComputeUrl(email, opts) {
   // upper bound (64 local + 1 @ + 255 domain). Refuse beyond that BEFORE
   // any further processing to defend tokenisation paths against
   // adversarial-length inputs.
-  if (email.length > 320) {                                                                            // allow:raw-byte-literal — RFC 5321 max email length
+  if (email.length > 320) {                                                                            // RFC 5321 max email length
     throw new MailCryptoError("mail-crypto/pgp/bad-email",
       "wkd.computeUrl: email length " + email.length + " exceeds RFC 5321 max 320 octets");
   }
@@ -1214,11 +1222,11 @@ function wkdComputeUrl(email, opts) {
     throw new MailCryptoError("mail-crypto/pgp/bad-domain",
       "wkd.computeUrl: domain must not contain empty labels");
   }
-  if (domain.length > 253) {                                                                           // allow:raw-byte-literal — RFC 1035 §2.3.4 max domain length
+  if (domain.length > 253) {                                                                           // RFC 1035 §2.3.4 max domain length
     throw new MailCryptoError("mail-crypto/pgp/bad-domain",
       "wkd.computeUrl: domain length " + domain.length + " exceeds RFC 1035 max 253 octets");
   }
-  var hashed = bCrypto.kdf(Buffer.from(localLower, "utf8"), 20);                                      // allow:raw-byte-literal — 20-byte hash per draft-koch §3.1
+  var hashed = bCrypto.kdf(Buffer.from(localLower, "utf8"), 20);                                      // 20-byte hash per draft-koch §3.1
   var encoded = _zbase32Encode(hashed);
   var advancedHost = opts.advancedHost || ("openpgpkey." + domain);
   var encodedLocal = encodeURIComponent(localRaw);
@@ -1238,15 +1246,15 @@ function _zbase32Encode(buf) {
   var bitCount = 0;
   var out = "";
   for (var i = 0; i < buf.length; i += 1) {
-    bits = (bits << 8) | buf[i];                                                                      // allow:raw-byte-literal — 8 bits per input byte
-    bitCount += 8;                                                                                    // allow:raw-byte-literal — 8 bits per input byte
-    while (bitCount >= 5) {                                                                           // allow:raw-byte-literal — 5 bits per zbase32 char
-      bitCount -= 5;                                                                                  // allow:raw-byte-literal — 5 bits per zbase32 char
-      out += ZBASE32_ALPHABET.charAt((bits >> bitCount) & 0x1f);                                      // allow:raw-byte-literal — 5-bit mask
+    bits = (bits << 8) | buf[i];                                                                      // 8 bits per input byte
+    bitCount += 8;                                                                                    // 8 bits per input byte
+    while (bitCount >= 5) {                                                                           // 5 bits per zbase32 char
+      bitCount -= 5;                                                                                  // 5 bits per zbase32 char
+      out += ZBASE32_ALPHABET.charAt((bits >> bitCount) & 0x1f);                                      // 5-bit mask
     }
   }
   if (bitCount > 0) {
-    out += ZBASE32_ALPHABET.charAt((bits << (5 - bitCount)) & 0x1f);                                  // allow:raw-byte-literal — final partial char
+    out += ZBASE32_ALPHABET.charAt((bits << (5 - bitCount)) & 0x1f);                                  // final partial char
   }
   return out;
 }

package/lib/mail-crypto-smime.js

@@ -109,9 +109,9 @@ var MailCryptoError = defineClass("MailCryptoError", { alwaysPermanent: true });
 // Constant posture values exported so operators reading this module
 // from configuration code can pin to them by reference rather than
 // hand-copying strings. These reflect RFC 8551 §2.5 + RFC 8301 floors.
-var RSA_MIN_BITS = 2048;                                                          // allow:raw-byte-literal — RFC 8301 §3.1
+var RSA_MIN_BITS = 2048;                                                          // RFC 8301 §3.1
 var ALLOWED_HASHES = ["sha256", "sha384", "sha512"];
-var REFUSED_HASHES = ["md5", "sha1"];                                             // allow:raw-byte-literal — SHAttered / RFC 8551 §2.5
+var REFUSED_HASHES = ["md5", "sha1"];                                             // SHAttered / RFC 8551 §2.5
 
 // PROFILES + COMPLIANCE_POSTURES — the framework's standard cross-
 // primitive contract. sign() and verify() read these to determine which
@@ -207,7 +207,7 @@ function sign(opts) {
       "smime.sign: " + ((e && e.message) || String(e)));
   }
   var boundary = opts.boundary ||
-    "blamejs-smime-" + bCrypto.generateToken(32);                                                     // allow:raw-byte-literal — 32-hex-char boundary token
+    "blamejs-smime-" + bCrypto.generateToken(32);                                                     // 32-hex-char boundary token
   var sigBase64 = _wrapBase64(sd.toString("base64"));
   var multipart =
     "Content-Type: multipart/signed; protocol=\"application/pkcs7-signature\"; " +
@@ -679,8 +679,8 @@ function _oidToDigest(oid) {
 function _wrapBase64(s) {
   // 64-char lines per RFC 2045 §6.8.
   var out = [];
-  for (var i = 0; i < s.length; i += 64) {                                                            // allow:raw-byte-literal — RFC 2045 §6.8 line length
-    out.push(s.slice(i, i + 64));                                                                     // allow:raw-byte-literal — RFC 2045 §6.8 line length
+  for (var i = 0; i < s.length; i += 64) {                                                            // RFC 2045 §6.8 line length
+    out.push(s.slice(i, i + 64));                                                                     // RFC 2045 §6.8 line length
   }
   return out.join("\r\n");
 }

package/lib/mail-dav.js

@@ -244,7 +244,7 @@ function create(opts) {
     var qIdx = reqUrl.indexOf("?");
     var path = qIdx >= 0 ? reqUrl.slice(0, qIdx) : reqUrl;
     // Refuse path traversal / null bytes before decoding.
-    if (path.indexOf("\0") >= 0 ||                                                                       // allow:raw-byte-literal — NUL byte refusal
+    if (path.indexOf("\0") >= 0 ||                                                                       // NUL byte refusal
         /(?:^|\/)\.\.(?:\/|$)/.test(path) ||
         /%2e%2e/i.test(path) ||
         /%00/i.test(path)) {