fad-checker 2.4.1 → 2.4.2

package/lib/certs/analyze.js

@@ -0,0 +1,305 @@
+/**
+ * lib/certs/analyze.js — classify committed crypto material and derive findings.
+ *
+ * Pure: takes a file's bytes + name (+ a `now` for testability) and returns a flat
+ * list of items. One file can yield several items (a .pem bundling a cert chain and
+ * a private key produces one item per certificate plus one for the key).
+ *
+ * Each item is one of four kinds:
+ *   - "certificate" — an X.509 cert (PEM or DER), fully parsed via the built-in
+ *     crypto.X509Certificate (NO external library, works air-gapped).
+ *   - "private-key" / "public-key" — key material, ALWAYS labelled with its
+ *     visibility (the headline ask): PEM (PKCS#1/PKCS#8/SEC1), OpenSSH (every
+ *     algorithm), PuTTY (.ppk), PGP, and one-line SSH public keys.
+ *   - "keystore" — a Java keystore / PKCS#12 (content is password-protected, so we
+ *     inventory + hash it rather than decrypt).
+ *
+ * Findings (item.issues[]): cert-expired, cert-expiring, cert-weak-key,
+ * cert-weak-signature, cert-self-signed, private-key-committed,
+ * public-key-committed, keystore-committed. No network, no decryption.
+ *
+ * @author: N.BRAUN
+ * @email: pp9ping@gmail.com
+ */
+const crypto = require("crypto");
+
+const DAY = 86_400_000;
+const SEV_RANK = { critical: 4, high: 3, medium: 2, low: 1, info: 0 };
+
+function worstSeverity(issues) {
+	let s = "info";
+	for (const i of issues) if ((SEV_RANK[i.severity] || 0) > SEV_RANK[s]) s = i.severity;
+	return s;
+}
+
+// ---- PEM block handling --------------------------------------------------
+
+const PEM_BLOCK_RE = /-----BEGIN ([A-Z0-9 ]+?)-----\r?\n([\s\S]*?)-----END \1-----/g;
+
+function pemBlocks(text) {
+	const out = [];
+	let m;
+	PEM_BLOCK_RE.lastIndex = 0;
+	while ((m = PEM_BLOCK_RE.exec(text)) !== null) {
+		out.push({ label: m[1].trim(), body: m[2], full: m[0] });
+	}
+	return out;
+}
+
+// ---- SSH public-key line + OpenSSH private-key blob ----------------------
+
+const SSH_PUB_RE = /^(ssh-rsa|ssh-dss|ssh-ed25519|ecdsa-sha2-[a-z0-9-]+|sk-ssh-ed25519@openssh\.com|sk-ecdsa-sha2-nistp256@openssh\.com)\s+[A-Za-z0-9+/=]+/;
+
+// Map an SSH key-type token to a human algorithm label.
+function sshAlgo(type) {
+	if (type === "ssh-rsa") return "RSA";
+	if (type === "ssh-dss") return "DSA";
+	if (type === "ssh-ed25519") return "Ed25519";
+	if (type === "sk-ssh-ed25519@openssh.com") return "Ed25519-SK";
+	if (type === "sk-ecdsa-sha2-nistp256@openssh.com") return "ECDSA-SK";
+	if (type && type.startsWith("ecdsa-sha2-")) return "ECDSA (" + type.slice("ecdsa-sha2-".length) + ")";
+	return type || null;
+}
+
+// Parse an OpenSSH private-key blob → { algorithm, encrypted }. Format:
+// "openssh-key-v1\0" cipher kdf kdfopts uint32(numkeys) sshstring(pubkey) ...
+function parseOpensshPrivate(body) {
+	try {
+		const buf = Buffer.from(body.replace(/[^A-Za-z0-9+/=]/g, ""), "base64");
+		const MAGIC = "openssh-key-v1\0";
+		if (buf.subarray(0, MAGIC.length).toString("latin1") !== MAGIC) return null;
+		let off = MAGIC.length;
+		const readStr = () => { const len = buf.readUInt32BE(off); off += 4; const s = buf.subarray(off, off + len); off += len; return s; };
+		const cipher = readStr().toString("latin1");
+		readStr();                 // kdf name
+		readStr();                 // kdf options
+		off += 4;                  // numKeys (uint32)
+		const pub = readStr();     // first public-key blob
+		const tlen = pub.readUInt32BE(0);
+		const keyType = pub.subarray(4, 4 + tlen).toString("latin1");
+		return { algorithm: sshAlgo(keyType), encrypted: cipher !== "none" };
+	} catch { return null; }
+}
+
+// ---- weak signature-algorithm detection (OID byte-scan over DER) ---------
+
+// Signature-algorithm OIDs we consider weak, as their DER value bytes.
+const WEAK_SIG_OIDS = [
+	{ name: "MD2withRSA", bytes: [0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x02] },
+	{ name: "MD5withRSA", bytes: [0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x04] },
+	{ name: "SHA1withRSA", bytes: [0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05] },
+	{ name: "ECDSAwithSHA1", bytes: [0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x01] },
+	{ name: "DSAwithSHA1", bytes: [0x2a, 0x86, 0x48, 0xce, 0x38, 0x04, 0x03] },
+];
+
+function detectWeakSig(raw) {
+	if (!raw || !raw.length) return null;
+	for (const oid of WEAK_SIG_OIDS) {
+		if (raw.indexOf(Buffer.from(oid.bytes)) !== -1) return oid.name;
+	}
+	return null;
+}
+
+// EC curves below the ~128-bit security floor (i.e. < 256-bit field).
+const WEAK_CURVES = new Set(["prime192v1", "secp192r1", "secp192k1", "secp224r1", "secp224k1", "prime239v1"]);
+
+function cnOf(dn) {
+	if (!dn) return null;
+	const m = /(?:^|\n)CN=([^\n]+)/.exec(dn);
+	return m ? m[1].trim() : dn.split("\n")[0].trim();
+}
+
+// ---- certificate item ----------------------------------------------------
+
+function certItem({ path, file, x509, now, expiryDays }) {
+	const issues = [];
+	const notAfterMs = Date.parse(x509.validTo);
+	const notBeforeMs = Date.parse(x509.validFrom);
+	const daysUntilExpiry = Number.isFinite(notAfterMs) ? Math.floor((notAfterMs - now) / DAY) : null;
+
+	let algorithm = null, bits = null;
+	try {
+		const pk = x509.publicKey;
+		algorithm = (pk.asymmetricKeyType || "").toUpperCase() || null;
+		const d = pk.asymmetricKeyDetails || {};
+		if (d.modulusLength) bits = d.modulusLength;
+		else if (d.namedCurve) bits = d.namedCurve;
+		if (algorithm === "RSA" && bits && bits < 2048)
+			issues.push({ type: "cert-weak-key", severity: "high", message: `RSA ${bits}-bit key (below 2048-bit minimum)` });
+		if ((algorithm === "EC" || algorithm === "ECDSA") && typeof bits === "string" && WEAK_CURVES.has(bits))
+			issues.push({ type: "cert-weak-key", severity: "high", message: `weak EC curve ${bits}` });
+	} catch { /* publicKey unreadable — leave algorithm null */ }
+
+	if (Number.isFinite(notAfterMs)) {
+		if (notAfterMs < now)
+			issues.push({ type: "cert-expired", severity: "high", message: `expired on ${x509.validTo} (${-daysUntilExpiry} days ago)` });
+		else if (daysUntilExpiry <= expiryDays)
+			issues.push({ type: "cert-expiring", severity: "medium", message: `expires in ${daysUntilExpiry} days (${x509.validTo})` });
+	}
+
+	const weakSig = detectWeakSig(x509.raw);
+	if (weakSig)
+		issues.push({ type: "cert-weak-signature", severity: "high", message: `weak signature algorithm ${weakSig}` });
+
+	const selfSigned = x509.subject === x509.issuer;
+	if (selfSigned)
+		issues.push({ type: "cert-self-signed", severity: "low", message: "self-signed certificate" });
+
+	return {
+		path, file, kind: "certificate", format: "x509",
+		algorithm, bits, keyVisibility: null,
+		subject: cnOf(x509.subject), issuer: cnOf(x509.issuer),
+		serialNumber: x509.serialNumber || null,
+		notBefore: Number.isFinite(notBeforeMs) ? new Date(notBeforeMs).toISOString() : null,
+		notAfter: Number.isFinite(notAfterMs) ? new Date(notAfterMs).toISOString() : null,
+		daysUntilExpiry, selfSigned, ca: !!x509.ca,
+		signatureAlgorithm: weakSig || null,
+		fingerprint256: x509.fingerprint256 || null,
+		issues, severity: worstSeverity(issues),
+	};
+}
+
+function tryX509(buf) {
+	try { return new crypto.X509Certificate(buf); } catch { return null; }
+}
+
+// ---- key items -----------------------------------------------------------
+
+function privateKeyItem({ path, file, format, algorithm, encrypted }) {
+	const enc = encrypted ? " (encrypted)" : " (UNENCRYPTED)";
+	const issues = [{
+		type: "private-key-committed", severity: "critical",
+		message: `committed ${algorithm || ""} private key${enc} [${format}]`.replace(/\s+/g, " ").trim(),
+	}];
+	return {
+		path, file, kind: "private-key", format, algorithm: algorithm || null,
+		keyVisibility: "private", encrypted: !!encrypted,
+		issues, severity: "critical",
+	};
+}
+
+function publicKeyItem({ path, file, format, algorithm, count }) {
+	const issues = [{
+		type: "public-key-committed", severity: "low",
+		message: `committed ${algorithm || ""} public key${count > 1 ? ` (${count} keys)` : ""} [${format}]`.replace(/\s+/g, " ").trim(),
+	}];
+	return {
+		path, file, kind: "public-key", format, algorithm: algorithm || null,
+		keyVisibility: "public", count: count || 1,
+		issues, severity: "low",
+	};
+}
+
+// Classify one PEM private-key block → { algorithm, encrypted }.
+function pemPrivateInfo(block) {
+	if (block.label === "OPENSSH PRIVATE KEY") {
+		const r = parseOpensshPrivate(block.body);
+		return { algorithm: r?.algorithm || null, encrypted: r ? r.encrypted : false, format: "openssh" };
+	}
+	const encrypted = /ENCRYPTED/.test(block.label) || /Proc-Type:\s*4,ENCRYPTED/.test(block.body);
+	let algorithm = null;
+	if (/^RSA /.test(block.label)) algorithm = "RSA";
+	else if (/^EC /.test(block.label)) algorithm = "EC";
+	else if (/^DSA /.test(block.label)) algorithm = "DSA";
+	if (!encrypted && !algorithm) {
+		try {
+			const k = crypto.createPrivateKey({ key: block.full });
+			algorithm = (k.asymmetricKeyType || "").toUpperCase() || null;
+		} catch { /* unparseable → leave null */ }
+	}
+	return { algorithm, encrypted, format: "pem" };
+}
+
+function pemPublicAlgo(block) {
+	try {
+		const k = crypto.createPublicKey({ key: block.full });
+		return (k.asymmetricKeyType || "").toUpperCase() || null;
+	} catch { return /^RSA /.test(block.label) ? "RSA" : null; }
+}
+
+// ---- top-level dispatch --------------------------------------------------
+
+/**
+ * Analyze one candidate file. Returns an array of items (possibly empty).
+ * @param {{name, path, buf, now?, expiryDays?}} args
+ */
+function analyzeBuffer({ name, path, buf, now = Date.now(), expiryDays = 90 } = {}) {
+	if (!buf || !buf.length) return [];
+	const items = [];
+	// latin1 keeps binary bytes 1:1 while still letting us substring-match ASCII headers.
+	const text = buf.subarray(0, Math.min(buf.length, 8 * 1024 * 1024)).toString("latin1");
+
+	// 1. PEM container — may hold certs AND keys; emit one item per block of interest.
+	if (text.includes("-----BEGIN ")) {
+		for (const block of pemBlocks(text)) {
+			const L = block.label;
+			if (/CERTIFICATE$/.test(L) && L !== "CERTIFICATE REQUEST" && L !== "NEW CERTIFICATE REQUEST") {
+				const x = tryX509(block.full);
+				if (x) items.push(certItem({ path, file: name, x509: x, now, expiryDays }));
+			} else if (/PRIVATE KEY$/.test(L)) {
+				const info = pemPrivateInfo(block);
+				items.push(privateKeyItem({ path, file: name, ...info }));
+			} else if (L === "PGP PRIVATE KEY BLOCK") {
+				items.push(privateKeyItem({ path, file: name, format: "pgp", algorithm: "PGP", encrypted: true }));
+			} else if (/PUBLIC KEY$/.test(L)) {
+				items.push(publicKeyItem({ path, file: name, format: "pem", algorithm: pemPublicAlgo(block) }));
+			} else if (L === "PGP PUBLIC KEY BLOCK") {
+				items.push(publicKeyItem({ path, file: name, format: "pgp", algorithm: "PGP" }));
+			}
+		}
+		if (items.length) return items;
+	}
+
+	// 2. PuTTY private key (.ppk).
+	if (/^PuTTY-User-Key-File-\d+:\s*(\S+)/m.test(text)) {
+		const algo = /^PuTTY-User-Key-File-\d+:\s*(\S+)/m.exec(text)[1];
+		const encrypted = !/^Encryption:\s*none/m.test(text);
+		items.push(privateKeyItem({ path, file: name, format: "putty", algorithm: sshAlgo(algo) || algo, encrypted }));
+		return items;
+	}
+
+	// 3. One-line SSH public keys (authorized_keys / known_hosts / *.pub).
+	const lines = text.split(/\r?\n/).map(l => l.trim()).filter(Boolean).filter(l => !l.startsWith("#"));
+	const pubLines = lines.filter(l => {
+		// known_hosts lines are "<host> <type> <b64>"; strip a leading host token.
+		const t = l.replace(/^\S+\s+/, "");
+		return SSH_PUB_RE.test(l) || SSH_PUB_RE.test(t);
+	});
+	if (pubLines.length) {
+		const first = pubLines[0];
+		const m = SSH_PUB_RE.exec(first) || SSH_PUB_RE.exec(first.replace(/^\S+\s+/, ""));
+		items.push(publicKeyItem({ path, file: name, format: "ssh", algorithm: sshAlgo(m ? m[1] : null), count: pubLines.length }));
+		return items;
+	}
+
+	// 4. Binary: DER certificate, else Java keystore / PKCS#12.
+	const x = tryX509(buf);
+	if (x) { items.push(certItem({ path, file: name, x509: x, now, expiryDays })); return items; }
+
+	const ks = keystoreFormat(buf, name);
+	if (ks) {
+		items.push({
+			path, file: name, kind: "keystore", format: ks, algorithm: null, keyVisibility: null,
+			issues: [{ type: "keystore-committed", severity: "medium", message: `committed ${ks.toUpperCase()} keystore (encrypted contents not inspected)` }],
+			severity: "medium",
+		});
+	}
+	return items;
+}
+
+// Java keystore magic + PKCS#12 by extension (DER SEQUENCE is ambiguous by magic).
+function keystoreFormat(buf, name) {
+	if (buf && buf.length >= 4) {
+		if (buf[0] === 0xfe && buf[1] === 0xed && buf[2] === 0xfe && buf[3] === 0xed) return "jks";
+		if (buf[0] === 0xce && buf[1] === 0xce && buf[2] === 0xce && buf[3] === 0xce) return "jceks";
+	}
+	if (/\.(p12|pfx)$/i.test(name)) return "pkcs12";
+	if (/\.(jks|keystore)$/i.test(name)) return "jks";
+	return null;
+}
+
+module.exports = {
+	analyzeBuffer, worstSeverity,
+	// exported for unit tests:
+	pemBlocks, detectWeakSig, sshAlgo, parseOpensshPrivate, keystoreFormat, SSH_PUB_RE,
+};

package/lib/certs/index.js

@@ -0,0 +1,17 @@
+/**
+ * lib/certs/index.js — public entrypoint for the certificate / key-material scanner.
+ *
+ * Not a codec (crypto material has no version/registry/CVE/EOL, so it doesn't fit
+ * the codec contract). It's a standalone scanner, wired into runReportFlow like the
+ * native-binary scan: discovers committed certificates, private/public keys (PEM,
+ * OpenSSH every algorithm, PuTTY, PGP, SSH one-liners) and Java/PKCS#12 keystores,
+ * then derives crypto-hygiene findings. 100% offline.
+ *
+ * @author: N.BRAUN
+ * @email: pp9ping@gmail.com
+ */
+const { scanCertificates } = require("./scan");
+const { analyzeBuffer, worstSeverity } = require("./analyze");
+const { isCandidate } = require("./sniff");
+
+module.exports = { scanCertificates, analyzeBuffer, worstSeverity, isCandidate };

package/lib/certs/scan.js

@@ -0,0 +1,67 @@
+/**
+ * lib/certs/scan.js — walk a source tree for committed crypto material.
+ *
+ * Reuses the shared prune policy (lib/path-filter) so the cert scan honours the
+ * same --exclude-path / --no-default-excludes rules as every other walker. Each
+ * candidate file (sniff.js) is read, hashed (sha256), and handed to analyze.js;
+ * the resulting items are returned flat. Pure I/O wrapper — no network, ever.
+ *
+ * @author: N.BRAUN
+ * @email: pp9ping@gmail.com
+ */
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { isCandidate } = require("./sniff");
+const { analyzeBuffer } = require("./analyze");
+
+// Same default-skip set the other file walkers use.
+const SKIP = new Set([
+	".git", ".idea", ".vscode", "node_modules", "dist", "build", "out",
+	"target", "vendor", "testdata", ".svn", ".hg", ".gradle", ".cache",
+]);
+
+const MAX_FILE = 8 * 1024 * 1024;   // crypto material is small; skip anything huge
+
+/**
+ * Walk `dir`, return a flat array of cert/key/keystore items (analyze.js shape),
+ * each stamped with `sha256` of the file.
+ * @param {string} dir
+ * @param {{srcRoot?, excludePath?, defaultExcludes?, now?, expiryDays?, onProgress?}} opts
+ */
+function scanCertificates(dir, opts = {}) {
+	if (!dir) return [];
+	const { makeDirFilter } = require("../path-filter");
+	const skipDir = makeDirFilter({
+		srcRoot: opts.srcRoot || dir, defaultSkip: SKIP,
+		excludePath: opts.excludePath, useDefaults: opts.defaultExcludes !== false,
+	});
+	const now = opts.now || Date.now();
+	const expiryDays = opts.expiryDays != null ? opts.expiryDays : 90;
+	const out = [];
+	const stack = [dir];
+	while (stack.length) {
+		const cur = stack.pop();
+		let entries; try { entries = fs.readdirSync(cur, { withFileTypes: true }); } catch { continue; }
+		for (const e of entries) {
+			const fp = path.join(cur, e.name);
+			if (e.isDirectory()) { if (!skipDir(fp, e.name)) stack.push(fp); continue; }
+			if (!e.isFile()) continue;
+			if (!isCandidate(e.name)) continue;
+			let st; try { st = fs.statSync(fp); } catch { continue; }
+			if (st.size > MAX_FILE || st.size === 0) continue;
+			let buf; try { buf = fs.readFileSync(fp); } catch { continue; }
+			if (opts.onProgress) opts.onProgress(fp);
+			const items = analyzeBuffer({ name: e.name, path: fp, buf, now, expiryDays });
+			if (!items.length) continue;
+			const sha256 = crypto.createHash("sha256").update(buf).digest("hex");
+			for (const it of items) { it.sha256 = sha256; out.push(it); }
+		}
+	}
+	// Worst severity first, then path — matches the report's priority-led ordering.
+	const RANK = { critical: 4, high: 3, medium: 2, low: 1, info: 0 };
+	out.sort((a, b) => (RANK[b.severity] || 0) - (RANK[a.severity] || 0) || String(a.path).localeCompare(String(b.path)));
+	return out;
+}
+
+module.exports = { scanCertificates, SKIP };

package/lib/certs/sniff.js

@@ -0,0 +1,29 @@
+/**
+ * lib/certs/sniff.js — cheap candidacy gate for the certificate / key-material scanner.
+ *
+ * Decides which files are worth opening, by extension OR conventional basename
+ * (SSH key files like `id_rsa` / `authorized_keys` / `known_hosts` carry no
+ * extension). The actual classification (cert vs private vs public vs keystore)
+ * is content-based and lives in analyze.js — this module only narrows the walk.
+ *
+ * @author: N.BRAUN
+ * @email: pp9ping@gmail.com
+ */
+
+// Extensions worth opening: X.509 (pem/crt/cer/der), key material (key/pub),
+// keystores (p12/pfx/jks/keystore), PuTTY (ppk), PGP (asc/gpg/pgp).
+const EXT_RE = /\.(pem|crt|cer|der|key|pub|p12|pfx|jks|keystore|ppk|asc|gpg|pgp)$/i;
+
+// Conventional SSH key files that carry NO extension. Covers every algorithm
+// (rsa/dsa/ecdsa/ed25519 + FIDO `_sk` variants) plus the agent/host files.
+const NAME_SET = new Set([
+	"id_rsa", "id_dsa", "id_ecdsa", "id_ed25519", "id_ecdsa_sk", "id_ed25519_sk",
+	"authorized_keys", "authorized_keys2", "known_hosts",
+]);
+
+/** True if `name` is worth opening for cert/key analysis. */
+function isCandidate(name) {
+	return EXT_RE.test(name) || NAME_SET.has(name);
+}
+
+module.exports = { isCandidate, EXT_RE, NAME_SET };

package/lib/codecs/go/parse.js

@@ -13,33 +13,75 @@ const { compareMavenVersions } = require("../../maven-version");
 
 function stripV(v) { return String(v || "").replace(/^v/, ""); }
 
-/** Parse go.mod → { module, deps: [{ name, version, scope, isDev }] }. */
+// "old [vX] => new vY" (module replace) or "old [vX] => ../dir" (directory
+// replace — per spec a replacement WITHOUT a version must be a directory path).
+function parseReplaceLine(s) {
+	const m = s.match(/^(\S+)(?:\s+(v\S+))?\s+=>\s+(\S+)(?:\s+(v\S+))?$/);
+	if (!m) return null;
+	return { oldName: m[1], oldVer: m[2] ? stripV(m[2]) : null, newName: m[3], newVer: m[4] ? stripV(m[4]) : null };
+}
+
+/**
+ * Parse go.mod → { module, goVersion, deps, dropped }.
+ * `replace` directives are APPLIED: the effective build uses the replacement
+ * module/version, so scanning the raw require line would miss a downgrade
+ * (false negative) or flag an already-redirected module (false positive).
+ * Directory replaces have no scannable version — the dep is dropped and
+ * surfaced in `dropped` so the codec can emit a chapter-0 warning.
+ */
 function parseGoMod(text) {
-	const out = { module: null, deps: [] };
+	const out = { module: null, goVersion: null, deps: [], dropped: [] };
 	const lines = String(text || "").split(/\r?\n/);
 	let inRequire = false;
-	const seen = new Set();
+	let inReplace = false;
+	const replaces = [];
 	const addReq = (name, ver, indirect) => {
 		if (!name || !ver) return;
-		const key = `${name}@${ver}`;
-		if (seen.has(key)) return;
-		seen.add(key);
 		out.deps.push({ name, version: stripV(ver), scope: indirect ? "transitive" : "compile", isDev: false });
 	};
 	for (let raw of lines) {
 		const noComment = raw.split("//")[0].trim();
 		const indirect = /\/\/\s*indirect/.test(raw);
 		if (noComment.startsWith("module ")) { out.module = noComment.slice(7).trim(); continue; }
+		if (noComment.startsWith("go ")) { out.goVersion = noComment.slice(3).trim(); continue; }
 		if (noComment === "require (") { inRequire = true; continue; }
-		if (inRequire && noComment === ")") { inRequire = false; continue; }
+		if (noComment === "replace (") { inReplace = true; continue; }
+		if ((inRequire || inReplace) && noComment === ")") { inRequire = inReplace = false; continue; }
+		if (inReplace) {
+			const r = parseReplaceLine(noComment);
+			if (r) replaces.push(r);
+			continue;
+		}
 		if (inRequire) {
 			const m = noComment.match(/^(\S+)\s+(\S+)/);
 			if (m) addReq(m[1], m[2], indirect);
 			continue;
 		}
 		const single = noComment.match(/^require\s+(\S+)\s+(\S+)/);
-		if (single) addReq(single[1], single[2], indirect);
+		if (single) { addReq(single[1], single[2], indirect); continue; }
+		const rep = noComment.startsWith("replace ") ? parseReplaceLine(noComment.slice(8).trim()) : null;
+		if (rep) replaces.push(rep);
 	}
+	// Apply replaces: versioned old matches that exact version only; versionless
+	// old matches every version of the module.
+	if (replaces.length) {
+		const kept = [];
+		for (const dep of out.deps) {
+			const r = replaces.find(x => x.oldName === dep.name && (!x.oldVer || x.oldVer === dep.version));
+			if (!r) { kept.push(dep); continue; }
+			if (r.newVer) kept.push({ ...dep, name: r.newName, version: r.newVer, replaced: true });
+			else out.dropped.push({ name: dep.name, version: dep.version, path: r.newName });
+		}
+		out.deps = kept;
+	}
+	// Dedupe by name@version (a replace can converge two requires onto one coord).
+	const seen = new Set();
+	out.deps = out.deps.filter(d => {
+		const k = `${d.name}@${d.version}`;
+		if (seen.has(k)) return false;
+		seen.add(k);
+		return true;
+	});
 	return out;
 }
 

package/lib/codecs/go/registry.js

@@ -74,7 +74,9 @@ async function checkGoRegistryDeps(deps, opts = {}) {
 			if (verbose) process.stdout.write(`  outdated: ${t.name} ${t.version} → ${ex.latest}\n`);
 		}
 	})));
-	cache.meta = { fetchedAt: Date.now() };
+	// Offline reads must not re-stamp freshness — a stale cache would then look
+	// fresh to the next ONLINE run and skip its refetch.
+	if (!offline) cache.meta = { fetchedAt: Date.now() };
 	saveCache(cache);
 	return result;
 }

package/lib/codecs/go.codec.js

@@ -50,19 +50,37 @@ module.exports = {
 			out.set(coordKeyFor("go", "", d.name), makeDepRecord({ ecosystem: "go", namespace: "", name: d.name, version: d.version, manifestPath, scope: d.scope, isDev: false }));
 		};
 		for (const g of findGoDirs(dir, dirFilter(dir, opts))) {
+			let modHadDeps = false;
+			let goMinor = null;
 			if (g.names.has("go.mod")) {
 				const fp = path.join(g.dir, "go.mod");
 				parsedManifests.push(fp);
 				try {
 					const r = G.parseGoModFile(fp);
-					if (r.deps.length) { for (const d of r.deps) add(d, fp); continue; }
-					// go.mod with no require list (rare / very old) → fall through to go.sum.
+					const gm = /^1\.(\d+)/.exec(r.goVersion || "");
+					goMinor = gm ? Number(gm[1]) : null;
+					for (const d of r.dropped) {
+						warnings.push({ type: "local-replace", manifestPath: fp, message: `${d.name}@${d.version} is replaced by local path ${d.path} — replacement version unknown, not scanned` });
+					}
+					if (r.deps.length) { for (const d of r.deps) add(d, fp); modHadDeps = true; }
+					// else: go.mod with no require list (rare / very old) → fall through to go.sum.
 				} catch (e) { warnings.push({ type: "parse-error", manifestPath: fp, message: `go.mod parse failed: ${e.message}` }); }
 			}
-			if (g.names.has("go.sum")) {
+			// go.mod lists the FULL pruned graph only from `go 1.17` on. For older
+			// (or unversioned) modules it lists direct deps only, so merge the
+			// go.sum graph for anything go.mod didn't select — skipping it silently
+			// dropped every transitive dep of a pre-1.17 module.
+			const needSum = !modHadDeps || goMinor == null || goMinor < 17;
+			if (needSum && g.names.has("go.sum")) {
 				const fp = path.join(g.dir, "go.sum");
 				parsedManifests.push(fp);
-				try { const r = G.parseGoSumFile(fp); for (const d of r.deps) add(d, fp); }
+				try {
+					const r = G.parseGoSumFile(fp);
+					for (const d of r.deps) {
+						if (out.has(coordKeyFor("go", "", d.name))) continue; // go.mod's selected version wins
+						add(d, fp);
+					}
+				}
 				catch (e) { warnings.push({ type: "parse-error", manifestPath: fp, message: `go.sum parse failed: ${e.message}` }); }
 			}
 		}

package/lib/codecs/nuget/parse.js

@@ -20,6 +20,15 @@ const xml2js = require("xml2js");
 // range "[1.0,2.0)", and wildcard/comma/bracket specifiers.
 function isConcrete(v) { const s = String(v || ""); return /^\d/.test(s) && /^[\w.+-]+$/.test(s); }
 
+// "[1.2.3]" is NuGet's EXACT-version pin (a single-version range, common in
+// csproj) — unwrap it to the inner concrete version instead of rejecting it.
+function concreteVersion(v) {
+	let s = String(v || "").trim();
+	const exact = /^\[\s*([^,\[\]]+)\s*\]$/.exec(s);
+	if (exact) s = exact[1].trim();
+	return isConcrete(s) ? s : null;
+}
+
 async function parsePackagesLockJson(filePath) {
 	const json = JSON.parse(fs.readFileSync(filePath, "utf8"));
 	const deps = [];
@@ -56,9 +65,15 @@ async function parseCsproj(filePath, cpm = {}) {
 	for (const ig of xml.Project?.ItemGroup || []) {
 		for (const pr of ig.PackageReference || []) {
 			const name = pr.$?.Include; if (!name) continue;
-			// Version: attribute, child element, or (CPM) resolved from Directory.Packages.props.
-			const version = pr.$?.Version || (Array.isArray(pr.Version) ? pr.Version[0] : null) || cpm[name.toLowerCase()] || null;
-			if (version && isConcrete(version)) deps.push({ name, version, scope: "prod", isDev: false });
+			// Version: VersionOverride (CPM per-project override) wins, then the
+			// attribute, then a child element, then the Directory.Packages.props pin.
+			const raw = pr.$?.VersionOverride
+				|| (Array.isArray(pr.VersionOverride) ? pr.VersionOverride[0] : null)
+				|| pr.$?.Version
+				|| (Array.isArray(pr.Version) ? pr.Version[0] : null)
+				|| cpm[name.toLowerCase()] || null;
+			const version = concreteVersion(raw);
+			if (version) deps.push({ name, version, scope: "prod", isDev: false });
 			else skipped++;
 		}
 	}
@@ -69,10 +84,10 @@ async function parsePackagesConfig(filePath) {
 	const xml = await xml2js.parseStringPromise(fs.readFileSync(filePath, "utf8"));
 	const deps = [];
 	for (const p of xml.packages?.package || []) {
-		const name = p.$?.id; const version = p.$?.version;
-		if (name && version && isConcrete(version)) deps.push({ name, version, scope: "prod", isDev: false });
+		const name = p.$?.id; const version = concreteVersion(p.$?.version);
+		if (name && version) deps.push({ name, version, scope: "prod", isDev: false });
 	}
 	return { manifestPath: filePath, manifestType: "packages.config", deps };
 }
 
-module.exports = { isConcrete, parsePackagesLockJson, parseDirectoryPackagesProps, parseCsproj, parsePackagesConfig };
+module.exports = { isConcrete, concreteVersion, parsePackagesLockJson, parseDirectoryPackagesProps, parseCsproj, parsePackagesConfig };