aboutsummaryrefslogtreecommitdiff
path: root/src/shared/hash.js
diff options
context:
space:
mode:
authorSoccera1 <[email protected]>2026-07-18 09:27:17 +1000
committerSoccera1 <[email protected]>2026-07-18 09:27:17 +1000
commit6f5241afb5bd1d6a1a8724bf06cc6f205c279402 (patch)
tree2aa852e968f6b89f2c8458333ce3e7c38b3c2450 /src/shared/hash.js
parenta753f669c9bedfccb9f7f400da018bb487dca5d0 (diff)
downloadbnu-6f5241afb5bd1d6a1a8724bf06cc6f205c279402.tar.gz
bnu-6f5241afb5bd1d6a1a8724bf06cc6f205c279402.zip
Refactor to single call
Diffstat (limited to 'src/shared/hash.js')
-rw-r--r--src/shared/hash.js680
1 files changed, 680 insertions, 0 deletions
diff --git a/src/shared/hash.js b/src/shared/hash.js
new file mode 100644
index 0000000..c850f90
--- /dev/null
+++ b/src/shared/hash.js
@@ -0,0 +1,680 @@
+import { createHash } from "node:crypto";
+import { fstatSync } from "node:fs";
+import { forEachInputChunk } from "./checksum.js";
+import { createFdRecordReader, decodeSurrogateEscapedBytes, hasSurrogateEscapedBytes, isWriteError, localeQuotedDiagnostic, localeQuotedEscapedDiagnostic, nodeErrorMessage, normalizeLongOptionByPrefix, normalizeLongOptionsByPrefix, parseOptions, pathDisplayName, readAll, systemErrorMessage, textInputDiagnosticName } from "./common.js";
+import { UsageError, VERSION, encodeSurrogateEscapedString, stderr, stdout } from "./diagnostics.js";
+
+export const CKSUM_LONG_OPTIONS = ["algorithm", "base64", "check", "length", "raw", "tag", "untagged", "zero", "ignore-missing", "quiet", "status", "strict", "warn", "debug", "binary", "text", "help", "version"];
+
+export const HASH_LONG_OPTIONS = ["check", "binary", "text", "tag", "length", "status", "quiet", "warn", "strict", "ignore-missing", "zero", "help", "version"];
+
+export function hashMetaOption(program, args) {
+ const supportsLength = program === "b2sum";
+ const longOptions = supportsLength ? HASH_LONG_OPTIONS : HASH_LONG_OPTIONS.filter((option) => option !== "length");
+ return checksumMetaOption(args, longOptions, normalizeHashLongOption, supportsLength ? new Set(["length"]) : new Set(), supportsLength ? new Set(["l"]) : new Set(), supportsLength ? new Set(["b", "c", "l", "t", "w", "z"]) : new Set(["b", "c", "t", "w", "z"]));
+}
+
+export function checksumMetaOption(args, longOptions, normalizeLongOption, longValueOptions, shortValueOptions, shortKnownOptions) {
+ for (let i = 0; i < args.length; i++) {
+ const arg = args[i];
+ if (arg === "--") return null;
+ if (arg.startsWith("--")) {
+ const option = normalizeLongOption(arg);
+ const [name, inlineValue] = option.slice(2).split(/=(.*)/s, 2);
+ if (!longOptions.includes(name)) return null;
+ if ((option === "--help" || option === "--version") && inlineValue == null) return option;
+ if (longOptions === CKSUM_LONG_OPTIONS && name === "algorithm" && inlineValue != null) validateCksumAlgorithmOption(inlineValue);
+ const value = inlineValue ?? (longValueOptions.has(name) ? args[i + 1] : undefined);
+ if (name === "length" && value !== undefined) validateShaDigestLengthSyntax(value);
+ if (inlineValue == null && longValueOptions.has(name)) i++;
+ continue;
+ }
+ if (!arg.startsWith("-") || arg === "-") continue;
+ for (let j = 1; j < arg.length; j++) {
+ const ch = arg[j];
+ if (!shortKnownOptions.has(ch)) return null;
+ if (shortValueOptions.has(ch)) {
+ const inlineValue = arg.slice(j + 1);
+ const value = inlineValue === "" ? args[i + 1] : inlineValue;
+ validateChecksumMetaShortValue(ch, value, longOptions);
+ if (inlineValue === "") i++;
+ break;
+ }
+ }
+ }
+ return null;
+}
+
+export function validateChecksumMetaShortValue(ch, value, longOptions) {
+ if (value === undefined) return;
+ if (ch === "a" && longOptions === CKSUM_LONG_OPTIONS) validateCksumAlgorithmOption(value);
+ if (ch === "l") validateShaDigestLengthSyntax(value);
+}
+
+export async function fileDigest(file, algorithm) {
+ if (algorithm === "sm3") return sm3DigestFile(file);
+ const hash = createHash(algorithm);
+ await forEachInputChunk(file, (chunk) => hash.update(chunk));
+ return hash.digest();
+}
+
+export async function sm3DigestFile(file) {
+ const state = {
+ h: [0x7380166f, 0x4914b2b9, 0x172442d7, 0xda8a0600, 0xa96f30bc, 0x163138aa, 0xe38dee4d, 0xb0fb0e4e],
+ buffer: Buffer.alloc(0),
+ length: 0n,
+ };
+ await forEachInputChunk(file, (chunk) => sm3Update(state, chunk));
+ return sm3Final(state);
+}
+
+export function sm3Update(state, chunk) {
+ state.length += BigInt(chunk.length);
+ let data = Buffer.concat([state.buffer, chunk]);
+ let offset = 0;
+ while (offset + 64 <= data.length) {
+ sm3Compress(state.h, data.subarray(offset, offset + 64));
+ offset += 64;
+ }
+ state.buffer = data.subarray(offset);
+}
+
+export function sm3Final(state) {
+ const bitLength = state.length * 8n;
+ const padLength = Number((56n - ((state.length + 1n) % 64n) + 64n) % 64n);
+ const padding = Buffer.alloc(1 + padLength + 8);
+ padding[0] = 0x80;
+ padding.writeBigUInt64BE(bitLength, 1 + padLength);
+ sm3Update(state, padding);
+ const out = Buffer.alloc(32);
+ state.h.forEach((word, index) => out.writeUInt32BE(word >>> 0, index * 4));
+ return out;
+}
+
+export function sm3Compress(h, block) {
+ const w = new Array(68);
+ const w1 = new Array(64);
+ for (let i = 0; i < 16; i++) w[i] = block.readUInt32BE(i * 4);
+ for (let j = 16; j < 68; j++) w[j] = (sm3P1((w[j - 16] ^ w[j - 9] ^ rotl32(w[j - 3], 15)) >>> 0) ^ rotl32(w[j - 13], 7) ^ w[j - 6]) >>> 0;
+ for (let j = 0; j < 64; j++) w1[j] = (w[j] ^ w[j + 4]) >>> 0;
+ let [a, b, c, d, e, f, g, hh] = h;
+ for (let j = 0; j < 64; j++) {
+ const t = j < 16 ? 0x79cc4519 : 0x7a879d8a;
+ const ss1 = rotl32((rotl32(a, 12) + e + rotl32(t, j % 32)) >>> 0, 7);
+ const ss2 = (ss1 ^ rotl32(a, 12)) >>> 0;
+ const tt1 = (sm3FF(a, b, c, j) + d + ss2 + w1[j]) >>> 0;
+ const tt2 = (sm3GG(e, f, g, j) + hh + ss1 + w[j]) >>> 0;
+ d = c;
+ c = rotl32(b, 9);
+ b = a;
+ a = tt1;
+ hh = g;
+ g = rotl32(f, 19);
+ f = e;
+ e = sm3P0(tt2);
+ }
+ for (let i = 0, values = [a, b, c, d, e, f, g, hh]; i < 8; i++) h[i] = (h[i] ^ values[i]) >>> 0;
+}
+
+export function rotl32(value, bits) {
+ return ((value << bits) | (value >>> (32 - bits))) >>> 0;
+}
+
+export function sm3P0(x) {
+ return (x ^ rotl32(x, 9) ^ rotl32(x, 17)) >>> 0;
+}
+
+export function sm3P1(x) {
+ return (x ^ rotl32(x, 15) ^ rotl32(x, 23)) >>> 0;
+}
+
+export function sm3FF(x, y, z, j) {
+ return j < 16 ? (x ^ y ^ z) >>> 0 : ((x & y) | (x & z) | (y & z)) >>> 0;
+}
+
+export function sm3GG(x, y, z, j) {
+ return j < 16 ? (x ^ y ^ z) >>> 0 : ((x & y) | (~x & z)) >>> 0;
+}
+
+export const BLAKE2B_IV = [
+ 0x6a09e667f3bcc908n, 0xbb67ae8584caa73bn, 0x3c6ef372fe94f82bn, 0xa54ff53a5f1d36f1n,
+ 0x510e527fade682d1n, 0x9b05688c2b3e6c1fn, 0x1f83d9abfb41bd6bn, 0x5be0cd19137e2179n,
+];
+
+export const BLAKE2B_SIGMA = [
+ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+ [14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3],
+ [11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4],
+ [7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8],
+ [9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13],
+ [2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9],
+ [12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11],
+ [13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10],
+ [6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5],
+ [10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0],
+ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+ [14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3],
+];
+
+export const MASK64 = 0xffffffffffffffffn;
+
+export async function blake2bDigestFile(file, outBytes = 64) {
+ const state = {
+ h: [...BLAKE2B_IV],
+ buffer: Buffer.alloc(0),
+ length: 0n,
+ outBytes,
+ };
+ state.h[0] ^= 0x01010000n ^ BigInt(outBytes);
+ await forEachInputChunk(file, (chunk) => blake2bUpdate(state, chunk));
+ return blake2bFinal(state);
+}
+
+export function blake2bUpdate(state, chunk) {
+ let data = Buffer.concat([state.buffer, chunk]);
+ let offset = 0;
+ while (offset + 128 < data.length) {
+ state.length += 128n;
+ blake2bCompress(state.h, data.subarray(offset, offset + 128), state.length, false);
+ offset += 128;
+ }
+ state.buffer = data.subarray(offset);
+}
+
+export function blake2bFinal(state) {
+ state.length += BigInt(state.buffer.length);
+ const block = Buffer.alloc(128);
+ state.buffer.copy(block);
+ blake2bCompress(state.h, block, state.length, true);
+ const out = Buffer.alloc(64);
+ state.h.forEach((word, index) => out.writeBigUInt64LE(word, index * 8));
+ return out.subarray(0, state.outBytes);
+}
+
+export function blake2bCompress(h, block, count, last) {
+ const m = Array.from({ length: 16 }, (_, i) => block.readBigUInt64LE(i * 8));
+ const v = [...h, ...BLAKE2B_IV];
+ v[12] ^= count & MASK64;
+ v[13] ^= count >> 64n;
+ if (last) v[14] ^= MASK64;
+ const mix = (a, b, c, d, x, y) => {
+ v[a] = (v[a] + v[b] + x) & MASK64;
+ v[d] = rotr64(v[d] ^ v[a], 32n);
+ v[c] = (v[c] + v[d]) & MASK64;
+ v[b] = rotr64(v[b] ^ v[c], 24n);
+ v[a] = (v[a] + v[b] + y) & MASK64;
+ v[d] = rotr64(v[d] ^ v[a], 16n);
+ v[c] = (v[c] + v[d]) & MASK64;
+ v[b] = rotr64(v[b] ^ v[c], 63n);
+ };
+ for (const s of BLAKE2B_SIGMA) {
+ mix(0, 4, 8, 12, m[s[0]], m[s[1]]);
+ mix(1, 5, 9, 13, m[s[2]], m[s[3]]);
+ mix(2, 6, 10, 14, m[s[4]], m[s[5]]);
+ mix(3, 7, 11, 15, m[s[6]], m[s[7]]);
+ mix(0, 5, 10, 15, m[s[8]], m[s[9]]);
+ mix(1, 6, 11, 12, m[s[10]], m[s[11]]);
+ mix(2, 7, 8, 13, m[s[12]], m[s[13]]);
+ mix(3, 4, 9, 14, m[s[14]], m[s[15]]);
+ }
+ for (let i = 0; i < 8; i++) h[i] = (h[i] ^ v[i] ^ v[i + 8]) & MASK64;
+}
+
+export function rotr64(value, bits) {
+ return ((value >> bits) | (value << (64n - bits))) & MASK64;
+}
+
+export const CKSUM_ALGORITHMS = ["bsd", "sysv", "crc", "crc32b", "md5", "sha1", "sha224", "sha256", "sha384", "sha512", "sha2", "sha3", "blake2b", "sm3"];
+
+export function validateCksumAlgorithmOption(value) {
+ if (CKSUM_ALGORITHMS.includes(value)) return;
+ throw new UsageError(`invalid argument ${localeQuotedEscapedDiagnostic(value)} for ${localeQuotedDiagnostic("--algorithm")}\nValid arguments are:\n${CKSUM_ALGORITHMS.map((algorithm) => ` - ${localeQuotedDiagnostic(algorithm)}`).join("\n")}`, true);
+}
+
+export function optionAppearsAfter(args, later, earlier) {
+ const laterIndex = args.lastIndexOf(later);
+ const earlierIndex = args.lastIndexOf(earlier);
+ return laterIndex !== -1 && earlierIndex !== -1 && laterIndex > earlierIndex;
+}
+
+export function cksumHashAlgorithm(name, opts = {}) {
+ const length = opts.l ?? opts.length;
+ if (name === "md5") return "md5";
+ if (name === "sha1") return "sha1";
+ if (["sha224", "sha256", "sha384", "sha512"].includes(name)) return name;
+ if (name === "sha2") {
+ validateShaDigestLengthSyntax(length);
+ if (!["224", "256", "384", "512"].includes(String(length))) throw invalidDigestLengthError("cksum", "SHA2", length, "digest length for 'SHA2' must be 224, 256, 384, or 512");
+ return `sha${length}`;
+ }
+ if (name === "sha3") {
+ validateShaDigestLengthSyntax(length);
+ if (!["224", "256", "384", "512"].includes(String(length))) throw invalidDigestLengthError("cksum", "SHA3", length, "digest length for 'SHA3' must be 224, 256, 384, or 512");
+ return `sha3-${length}`;
+ }
+ if (name === "blake2b") {
+ if (length != null) validateBlake2bLength(opts.program ?? "cksum", length);
+ return "blake2b512";
+ }
+ if (name === "sm3") return "sm3";
+ throw new UsageError(`invalid checksum algorithm: ${name}`);
+}
+
+export function validateShaDigestLengthSyntax(length) {
+ const text = String(length);
+ if (/^\d+$/.test(text)) return;
+ if (/^-\d+$/.test(text)) throw new UsageError(`invalid length: ${localeQuotedEscapedDiagnostic(length)}: Value too large for defined data type`, false);
+ throw new UsageError(`invalid length: ${localeQuotedEscapedDiagnostic(length)}`, false);
+}
+
+export function cksumAlgorithmForDigest(name, digestBytes, opts = {}) {
+ const length = opts.l ?? opts.length;
+ if (name === "sha2") {
+ const bits = length ?? String(digestBytes * 8);
+ return cksumHashAlgorithm(name, { ...opts, l: bits });
+ }
+ if (name === "sha3") {
+ const bits = length ?? String(digestBytes * 8);
+ return cksumHashAlgorithm(name, { ...opts, l: bits });
+ }
+ return cksumHashAlgorithm(name, opts);
+}
+
+export function checksumDiagnosticName(file) {
+ return textInputDiagnosticName(file);
+}
+
+export function hashCommand(algorithm) {
+ return async (args) => {
+ if (algorithm !== "blake2b512") rejectHashLengthOption(args);
+ args = normalizeHashLongOptions(args);
+ if (args.length === 1 && args[0] === "--version") {
+ stdout(`${VERSION}\n`);
+ return 0;
+ }
+ const { opts, operands } = parseOptions(args, { short: { c: false, b: false, t: false, l: "value", w: false, z: false }, long: { check: false, binary: false, text: false, tag: false, length: "value", status: false, quiet: false, warn: false, strict: false, "ignore-missing": false, zero: false, help: false, version: false } });
+ if (opts.w) opts.warn = true;
+ opts.warnAfterStatus = optionAppearsAfter(args, "--warn", "--status") || optionAppearsAfter(args, "-w", "--status");
+ const digestBytes = hashDigestBytes(algorithm, opts);
+ validateChecksumCheckOnlyOptions(opts);
+ if (opts.c || opts.check) {
+ if (opts.tag) throw new UsageError("the --tag option is meaningless when verifying checksums");
+ return checkHashes(algorithm, operands.length ? operands : ["-"], { ...opts, program: hashProgramName(algorithm) });
+ }
+ if (opts.tag && (opts.t || opts.text)) throw new UsageError("--tag does not support --text mode");
+ const files = operands.length ? operands : ["-"];
+ let failed = false;
+ for (const file of files) {
+ let digest;
+ try {
+ digest = (digestBytes ? await blake2bDigestFile(file, digestBytes) : await fileDigest(file, algorithm)).toString("hex");
+ } catch (error) {
+ const program = hashProgramName(algorithm);
+ stderr(file === "-" ? `${program}: ${nodeErrorMessage(error)}\n` : `${program}: ${checksumDiagnosticName(file)}: ${systemErrorMessage(error)}\n`);
+ failed = true;
+ continue;
+ }
+ const sep = opts.z || opts.zero ? "\0" : "\n";
+ const displayFile = file === "-" ? "-" : file;
+ const renderedFile = opts.z || opts.zero ? displayFile : escapeChecksumFilename(displayFile);
+ const escapePrefix = !(opts.z || opts.zero) && shouldEscapeChecksumFilename(displayFile) ? "\\" : "";
+ if (opts.tag) stdout(`${escapePrefix}${hashTagName(algorithm, opts)} (${renderedFile}) = ${digest}${sep}`);
+ else stdout(`${escapePrefix}${digest}${opts.b || opts.binary ? " *" : " "}${renderedFile}${sep}`);
+ }
+ return failed ? 1 : 0;
+ };
+}
+
+export function rejectHashLengthOption(args) {
+ for (const arg of args) {
+ if (arg === "--") return;
+ if (arg.startsWith("--")) {
+ const name = arg.slice(2).split("=", 1)[0];
+ if ("length".startsWith(name)) throw new UsageError(`unrecognized option '${arg}'`, true);
+ continue;
+ }
+ if (!arg.startsWith("-") || arg === "-") continue;
+ for (const ch of arg.slice(1)) {
+ if (ch === "l") throw new UsageError("invalid option -- 'l'", true);
+ if (ch === "b" || ch === "c" || ch === "t" || ch === "w" || ch === "z") continue;
+ break;
+ }
+ }
+}
+
+export function validateChecksumCheckOnlyOptions(opts) {
+ if (opts.c || opts.check) return;
+ for (const option of ["ignore-missing", "status", "quiet", "strict", "warn"]) {
+ if (opts[option]) throw new UsageError(`the --${option} option is meaningful only when verifying checksums`, true);
+ }
+}
+
+export function hashDigestBytes(algorithm, opts = {}) {
+ if (algorithm !== "blake2b512") return null;
+ const length = opts.l ?? opts.length ?? "512";
+ validateBlake2bLength("b2sum", length);
+ return Number(length) === 0 ? 64 : Number(length) / 8;
+}
+
+export function hashProgramName(algorithm) {
+ if (algorithm === "md5") return "md5sum";
+ if (algorithm === "blake2b512") return "b2sum";
+ return `${algorithm}sum`;
+}
+
+export function normalizeHashLongOptions(args) {
+ return normalizeLongOptionsByPrefix(args, HASH_LONG_OPTIONS);
+}
+
+export function normalizeHashLongOption(arg) {
+ return normalizeLongOptionByPrefix(arg, HASH_LONG_OPTIONS);
+}
+
+export function hashTagName(algorithm, opts = {}) {
+ if (algorithm === "md5") return "MD5";
+ if (algorithm === "blake2b512") {
+ const length = opts.l ?? opts.length;
+ return length != null && !["0", "512"].includes(String(length)) ? `BLAKE2b-${length}` : "BLAKE2b";
+ }
+ return algorithm.toUpperCase();
+}
+
+export async function checkHashes(algorithm, files, opts = {}) {
+ if (files.length === 1 && files[0] === "-" && !fstatSync(0).isFile()) {
+ return checkHashesStream(algorithm, opts);
+ }
+ let checksumFailures = 0;
+ let readFailures = 0;
+ let malformed = 0;
+ let properLines = 0;
+ let verified = 0;
+ let emptyLists = 0;
+ const checksumName = algorithm.toUpperCase();
+ let lastChecksumName = checksumName;
+ let checksumLineStyle = null;
+ for (const listFile of files) {
+ let text;
+ try {
+ text = decodeSurrogateEscapedBytes(await readAll(listFile));
+ } catch (error) {
+ readFailures++;
+ stderr(`${diagnosticPrefix(opts)}${listFile}: ${fileReadErrorMessage(error)}\n`);
+ continue;
+ }
+ let fileProperLines = 0;
+ let lineNo = 0;
+ for (const raw of text.split(/\n/)) {
+ lineNo++;
+ const line = raw.replace(/\r$/, "").replace(/^[ \t]*\\/, "");
+ if (!line || line.startsWith("#") || line.startsWith("-----BEGIN ") || line.startsWith("-----END ") || /^Hash: /.test(line)) continue;
+ const parsedLine = parseChecksumLine(line, algorithm, checksumLineStyle);
+ if (parsedLine?.skip) continue;
+ if (!parsedLine) {
+ malformed++;
+ if (opts.warn && (!opts.status || opts.warnAfterStatus)) stderr(`${diagnosticPrefix(opts)}${listFile}: ${lineNo}: improperly formatted ${lastChecksumName} checksum line\n`);
+ continue;
+ }
+ const parsed = parseExpectedChecksum(parsedLine.token, parsedLine.algorithm, { ...opts, ...(parsedLine.opts ?? {}) });
+ if (!parsed) {
+ malformed++;
+ if (opts.warn && (!opts.status || opts.warnAfterStatus)) stderr(`${diagnosticPrefix(opts)}${listFile}: ${lineNo}: improperly formatted ${checksumDisplayName(parsedLine.algorithm, parsedLine.opts)} checksum line\n`);
+ continue;
+ }
+ if (parsedLine.style && checksumLineStyle == null) checksumLineStyle = parsedLine.style;
+ lastChecksumName = checksumDisplayName(parsedLine.algorithm, parsedLine.opts);
+ const { expected, hashAlgorithm, blake2bBytes } = parsed;
+ const file = checksumPathFromFilename(unescapeChecksumFilename(parsedLine.file));
+ properLines++;
+ fileProperLines++;
+ try {
+ const actualDigest = blake2bBytes ? await blake2bDigestFile(file, blake2bBytes) : await fileDigest(file, hashAlgorithm);
+ const actual = actualDigest.slice(0, expected.length / 2).toString("hex");
+ const ok = actual === expected;
+ verified++;
+ if (!ok) checksumFailures++;
+ if (!(opts.status || (opts.quiet && ok))) stdout(`${checksumDisplayFile(file)}: ${ok ? "OK" : "FAILED"}\n`);
+ } catch (error) {
+ if (opts["ignore-missing"]) continue;
+ readFailures++;
+ if (!opts.status) stderr(`${diagnosticPrefix(opts)}${pathDisplayName(file)}: ${fileReadErrorMessage(error)}\n`);
+ if (!opts.status) stdout(`${checksumDisplayFile(file)}: FAILED open or read\n`);
+ }
+ }
+ if (fileProperLines === 0) {
+ emptyLists++;
+ if (!opts.status) stderr(`${diagnosticPrefix(opts)}${listFile}: no properly formatted checksum lines found\n`);
+ }
+ }
+ if (properLines === 0) {
+ return 1;
+ }
+ const showStatusWarnings = !opts.status || opts.warnAfterStatus;
+ if (malformed && showStatusWarnings && !opts.quiet) stderr(`${diagnosticPrefix(opts)}WARNING: ${malformed} line${malformed === 1 ? " is" : "s are"} improperly formatted\n`);
+ if (readFailures && showStatusWarnings) stderr(`${diagnosticPrefix(opts)}WARNING: ${readFailures} listed file${readFailures === 1 ? "" : "s"} could not be read\n`);
+ if (checksumFailures && showStatusWarnings) stderr(`${diagnosticPrefix(opts)}WARNING: ${checksumFailures} computed checksum${checksumFailures === 1 ? "" : "s"} did NOT match\n`);
+ if (verified === 0 && readFailures === 0) {
+ if (showStatusWarnings) stderr(`${diagnosticPrefix(opts)}${files[0]}: no file was verified\n`);
+ return 1;
+ }
+ return checksumFailures || readFailures || emptyLists || (opts.strict && malformed) ? 1 : 0;
+}
+
+export async function checkHashesStream(requestedAlgorithm, opts = {}) {
+ const reader = createFdRecordReader(0, 10);
+ let checksumFailures = 0;
+ let readFailures = 0;
+ let malformed = 0;
+ let properLines = 0;
+ let verified = 0;
+ let lineNo = 0;
+ let checksumLineStyle = null;
+ let lastChecksumName = requestedAlgorithm.toUpperCase();
+ while (true) {
+ const bytes = reader.next();
+ if (bytes == null) break;
+ lineNo++;
+ const raw = decodeSurrogateEscapedBytes(bytes);
+ const line = raw.replace(/\r$/, "").replace(/^[ \t]*\\/, "");
+ if (!line || line.startsWith("#") || line.startsWith("-----BEGIN ") || line.startsWith("-----END ") || /^Hash: /.test(line)) continue;
+ const parsedLine = parseChecksumLine(line, requestedAlgorithm, checksumLineStyle);
+ if (parsedLine?.skip) continue;
+ if (!parsedLine) {
+ malformed++;
+ if (opts.warn && (!opts.status || opts.warnAfterStatus)) stderr(`${diagnosticPrefix(opts)}-: ${lineNo}: improperly formatted ${lastChecksumName} checksum line\n`);
+ continue;
+ }
+ const parsed = parseExpectedChecksum(parsedLine.token, parsedLine.algorithm, { ...opts, ...(parsedLine.opts ?? {}) });
+ if (!parsed) {
+ malformed++;
+ if (opts.warn && (!opts.status || opts.warnAfterStatus)) stderr(`${diagnosticPrefix(opts)}-: ${lineNo}: improperly formatted ${checksumDisplayName(parsedLine.algorithm, parsedLine.opts)} checksum line\n`);
+ continue;
+ }
+ if (parsedLine.style && checksumLineStyle == null) checksumLineStyle = parsedLine.style;
+ lastChecksumName = checksumDisplayName(parsedLine.algorithm, parsedLine.opts);
+ properLines++;
+ const file = checksumPathFromFilename(unescapeChecksumFilename(parsedLine.file));
+ const { expected, hashAlgorithm, blake2bBytes } = parsed;
+ try {
+ const digest = blake2bBytes ? await blake2bDigestFile(file, blake2bBytes) : await fileDigest(file, hashAlgorithm);
+ const actual = digest.slice(0, expected.length / 2).toString("hex");
+ const ok = actual === expected;
+ verified++;
+ if (!ok) checksumFailures++;
+ if (!(opts.status || (opts.quiet && ok))) stdout(`${checksumDisplayFile(file)}: ${ok ? "OK" : "FAILED"}\n`);
+ } catch (error) {
+ if (isWriteError(error)) throw error;
+ if (opts["ignore-missing"]) continue;
+ readFailures++;
+ if (!opts.status) stderr(`${diagnosticPrefix(opts)}${pathDisplayName(file)}: ${fileReadErrorMessage(error)}\n`);
+ if (!opts.status) stdout(`${checksumDisplayFile(file)}: FAILED open or read\n`);
+ }
+ }
+ if (properLines === 0) {
+ if (!opts.status) stderr(`${diagnosticPrefix(opts)}-: no properly formatted checksum lines found\n`);
+ return 1;
+ }
+ const showStatusWarnings = !opts.status || opts.warnAfterStatus;
+ if (malformed && showStatusWarnings && !opts.quiet) stderr(`${diagnosticPrefix(opts)}WARNING: ${malformed} line${malformed === 1 ? " is" : "s are"} improperly formatted\n`);
+ if (readFailures && showStatusWarnings) stderr(`${diagnosticPrefix(opts)}WARNING: ${readFailures} listed file${readFailures === 1 ? "" : "s"} could not be read\n`);
+ if (checksumFailures && showStatusWarnings) stderr(`${diagnosticPrefix(opts)}WARNING: ${checksumFailures} computed checksum${checksumFailures === 1 ? "" : "s"} did NOT match\n`);
+ if (verified === 0 && readFailures === 0) {
+ if (showStatusWarnings) stderr(`${diagnosticPrefix(opts)}-: no file was verified\n`);
+ return 1;
+ }
+ return checksumFailures || readFailures || (opts.strict && malformed) ? 1 : 0;
+}
+
+export function parseChecksumLine(line, requestedAlgorithm, style = null) {
+ const tag = line.match(/^([A-Za-z0-9-]+) \((.*)\) = (\S+)$/) ?? line.match(/^([A-Za-z0-9-]+)\((.*)\)= (\S+)$/);
+ if (tag) {
+ const algorithm = checksumAlgorithmFromTag(tag[1]);
+ if (!algorithm) return null;
+ if (requestedAlgorithm !== "auto" && !checksumAlgorithmMatches(requestedAlgorithm, algorithm)) return { skip: true };
+ return { algorithm: algorithm.name, token: tag[3], file: tag[2], opts: algorithm.opts };
+ }
+ const token = line.match(/^(\S+)/)?.[1];
+ if (!token || line.length <= token.length || line[token.length] !== " ") return null;
+ const rest = line.slice(token.length);
+ const algorithm = requestedAlgorithm === "auto" ? "auto" : requestedAlgorithm;
+ if (style === "bsd-alternate") return { algorithm, token, file: rest.slice(1), style: "bsd-alternate" };
+ if (rest.startsWith(" ")) return { algorithm, token, file: rest.slice(2), style: "gnu" };
+ if (rest.startsWith(" *")) return { algorithm, token, file: rest.slice(2), style: "gnu" };
+ if (style == null && requestedAlgorithm !== "auto") return { algorithm, token, file: rest.slice(1), style: "bsd-alternate" };
+ return null;
+}
+
+export function shouldEscapeChecksumFilename(file) {
+ return String(file).includes("\\") || String(file).includes("\n") || String(file).includes("\r");
+}
+
+export function escapeChecksumFilename(file) {
+ return String(file).replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+}
+
+export function unescapeChecksumFilename(file) {
+ return String(file).replace(/\\([\\nr])/g, (_, ch) => ch === "n" ? "\n" : ch === "r" ? "\r" : "\\");
+}
+
+export function checksumPathFromFilename(file) {
+ return hasSurrogateEscapedBytes(file) ? Buffer.from(encodeSurrogateEscapedString(file)) : file;
+}
+
+export function checksumDisplayFile(file) {
+ const text = pathDisplayName(file);
+ return /[\\\n\r\t]/.test(text) || hasSurrogateEscapedBytes(text) ? checksumShellQuote(text) : text;
+}
+
+export function checksumShellQuote(file) {
+ let out = "";
+ let plain = "";
+ const flush = () => {
+ if (!plain) return;
+ out += `'${plain.replace(/'/g, "'\\''")}'`;
+ plain = "";
+ };
+ for (const ch of String(file)) {
+ const code = ch.charCodeAt(0);
+ if (ch === "\n" || ch === "\t" || ch === "\r") {
+ flush();
+ out += `$'\\${ch === "\n" ? "n" : ch === "\t" ? "t" : "r"}'`;
+ } else if (code >= 0xdc80 && code <= 0xdcff) {
+ flush();
+ out += `$'\\${(code - 0xdc00).toString(8).padStart(3, "0")}'`;
+ } else {
+ plain += ch;
+ }
+ }
+ flush();
+ return out;
+}
+
+export function checksumAlgorithmMatches(requested, tagged) {
+ if (requested === tagged.name) return true;
+ if (requested === "blake2b512" && tagged.name === "blake2b") return true;
+ if (requested === "sha2" && /^sha(224|256|384|512)$/.test(tagged.name)) return true;
+ return false;
+}
+
+export function checksumAlgorithmFromTag(tag) {
+ const upper = tag.toUpperCase();
+ if (upper === "MD5") return { name: "md5" };
+ if (upper === "SHA1") return { name: "sha1" };
+ const sha = upper.match(/^SHA(224|256|384|512)$/);
+ if (sha) return { name: `sha${sha[1]}` };
+ const sha2 = upper.match(/^SHA2-(224|256|384|512)$/);
+ if (sha2) return { name: "sha2", opts: { l: sha2[1] } };
+ const sha3 = upper.match(/^SHA3-(224|256|384|512)$/);
+ if (sha3) return { name: "sha3", opts: { l: sha3[1] } };
+ const blake = tag.match(/^BLAKE2b(?:-(\d+))?$/);
+ if (blake) return { name: "blake2b", opts: blake[1] ? { l: blake[1], tagged: true } : { tagged: true } };
+ if (upper === "SM3") return { name: "sm3", opts: { tagged: true } };
+ return null;
+}
+
+export function diagnosticPrefix(opts = {}) {
+ return opts.program ? `${opts.program}: ` : "";
+}
+
+export function checksumDisplayName(algorithm, opts = {}) {
+ if (algorithm === "blake2b") return "BLAKE2b";
+ if (algorithm === "sha2") return `SHA2-${opts?.l ?? opts?.length ?? ""}`.replace(/-$/, "");
+ if (algorithm === "sha3") return `SHA3-${opts?.l ?? opts?.length ?? ""}`.replace(/-$/, "");
+ return String(algorithm).toUpperCase();
+}
+
+export function invalidDigestLengthError(program, algorithm, length, message) {
+ const quotedMessage = message.replaceAll(`'${algorithm}'`, localeQuotedDiagnostic(algorithm));
+ const error = new UsageError(`invalid length: ${localeQuotedDiagnostic(length)}\n${program}: ${quotedMessage}`, false);
+ return error;
+}
+
+export function validateBlake2bLength(program, length) {
+ const text = String(length);
+ if (!/^\d+$/.test(text)) {
+ if (/^-\d+$/.test(text)) throw new UsageError(`invalid length: ${localeQuotedEscapedDiagnostic(length)}: Value too large for defined data type`, false);
+ throw new UsageError(`invalid length: ${localeQuotedEscapedDiagnostic(length)}`, false);
+ }
+ const n = Number(text);
+ if (!Number.isSafeInteger(n) || n > 512) throw invalidDigestLengthError(program, "BLAKE2b", length, "maximum digest length for 'BLAKE2b' is 512 bits");
+ if (n % 8 !== 0) throw invalidDigestLengthError(program, "BLAKE2b", length, "length is not a multiple of 8");
+}
+
+export function parseExpectedChecksum(token, algorithm, opts = {}) {
+ if (/^[0-9a-fA-F]+$/.test(token) && token.length % 2 === 0) {
+ const digestBytes = token.length / 2;
+ if (!validChecksumDigestLength(algorithm, digestBytes, opts)) return null;
+ if (algorithm === "blake2b" || algorithm === "blake2b512") return { expected: token.toLowerCase(), hashAlgorithm: "blake2b512", blake2bBytes: digestBytes };
+ return { expected: token.toLowerCase(), hashAlgorithm: cksumAlgorithmForDigest(algorithm, digestBytes, opts) };
+ }
+ if (!/^[A-Za-z0-9+/]+={0,2}$/.test(token) || token.length % 4 !== 0) return null;
+ let digest;
+ try {
+ digest = Buffer.from(token, "base64");
+ } catch {
+ return null;
+ }
+ if (digest.length === 0) return null;
+ try {
+ if (!validChecksumDigestLength(algorithm, digest.length, opts)) return null;
+ if (algorithm === "blake2b" || algorithm === "blake2b512") return { expected: digest.toString("hex"), hashAlgorithm: "blake2b512", blake2bBytes: digest.length };
+ return { expected: digest.toString("hex"), hashAlgorithm: cksumAlgorithmForDigest(algorithm, digest.length, opts) };
+ } catch {
+ return null;
+ }
+}
+
+export function validChecksumDigestLength(algorithm, digestBytes, opts = {}) {
+ const fixed = { md5: 16, sha1: 20, sha224: 28, sha256: 32, sha384: 48, sha512: 64, sm3: 32 };
+ if (fixed[algorithm] != null) return digestBytes === fixed[algorithm];
+ if (algorithm === "sha2" || algorithm === "sha3") return [28, 32, 48, 64].includes(digestBytes);
+ if (algorithm === "blake2b" || algorithm === "blake2b512") {
+ if (opts.tagged && opts.l == null && opts.length == null) return digestBytes === 64;
+ return digestBytes >= 1 && digestBytes <= 64;
+ }
+ if (algorithm === "auto") return false;
+ return true;
+}
+
+export function fileReadErrorMessage(error) {
+ return systemErrorMessage(error);
+}