@patrickdk77/archive-defuse 0.0.0-stage → 0.1.1

package/dist/rules.js

@@ -0,0 +1,403 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nameDetails = nameDetails;
+exports.applyRules = applyRules;
+const names_1 = require("./names");
+const types_1 = require("./types");
+const SEPARATOR = /[/\\]/;
+/** A ".." part, also with the dots and spaces Windows drops from the end of a name. */
+const DOTDOT = /^\.\.[. ]*$/;
+const DRIVE = /^(?:[/\\]{2}[?.][/\\])?[A-Za-z]:/;
+const ABSOLUTE = /^[/\\]/;
+const CONTROL_TEST = new RegExp(names_1.CONTROL.source, 'u');
+const utf8Length = (s) => Buffer.byteLength(s, 'utf8');
+/** The most parts a link target may have and still be followed. */
+const MAX_LINK_PARTS = 4096;
+/** `s` without the characters in `chars` at its start. */
+function trimStart(s, chars) {
+    let start = 0;
+    while (start < s.length && chars.includes(s[start]))
+        start++;
+    return s.slice(start);
+}
+/** The parts of a name between separators. A folder's name ends in "/", which is not an empty part. */
+const partsOf = (name) => (/[/\\]$/.test(name) ? name.slice(0, -1) : name).split(SEPARATOR);
+/** A name without the slashes that end a folder's name. */
+const exactKey = (n) => (0, names_1.trimEnd)(n, '/');
+/** Equal for names a file system that normalizes Unicode, including compatibility forms such as ligatures, takes as one. */
+const normalKey = (n) => exactKey(n).normalize('NFKD');
+/** Equal for names a file system that ignores case takes as one. Upper-casing first turns a sharp s into "SS". */
+const foldKey = (n) => normalKey(n).toUpperCase().toLowerCase();
+/** Applies every name rule whose action is strip, in a fixed order, to `name`. Each one changes only what it reports. */
+function fixName(name, dir, strips) {
+    // The drive letter is set aside, so the other rules fix the rest of the name, and comes back unless DRIVE_LETTER strips.
+    const drive = DRIVE.exec(name)?.[0] ?? '';
+    let n = name.slice(drive.length);
+    if (strips(types_1.ArchiveDetail.Absolute))
+        n = trimStart(n, '/\\');
+    // Split into parts with the separator after each, so a rule that keeps backslashes keeps them where they were.
+    const tokens = n.split(/([/\\])/);
+    const parts = [];
+    for (let i = 0; i < tokens.length; i += 2)
+        parts.push({ part: tokens[i], sep: tokens[i + 1] ?? '' });
+    const lead = Math.max(0, parts.findIndex(p => p.part !== ''));
+    let kept = parts.filter((p, i) => {
+        if (strips(types_1.ArchiveDetail.Traversal) && DOTDOT.test(p.part))
+            return false;
+        // A leading empty part is the absolute path's, which ABSOLUTE decides, and a trailing one a folder's slash.
+        if (strips(types_1.ArchiveDetail.EmptySegment) && (p.part === '.' || (p.part === '' && i > lead && i < parts.length - 1)))
+            return false;
+        return true;
+    });
+    if (strips(types_1.ArchiveDetail.ControlCharacter))
+        kept = kept.map(p => ({ ...p, part: p.part.replace(new RegExp(names_1.CONTROL.source, 'gu'), '_') }));
+    if (strips(types_1.ArchiveDetail.WindowsReserved))
+        kept = kept.map(p => (DOTDOT.test(p.part) ? p : { ...p, part: (0, names_1.windowsSafe)(p.part) }));
+    n = kept.map((p, i) => p.part + (i < kept.length - 1 ? p.sep || '/' : '')).join('');
+    if (!strips(types_1.ArchiveDetail.DriveLetter))
+        n = drive + n;
+    if (strips(types_1.ArchiveDetail.Backslash))
+        n = n.replace(/\\/g, '/');
+    // A name the rewrite ends in "/" is a folder to every reader, so only a folder keeps its slash.
+    n = (0, names_1.trimEnd)(n, '/');
+    if (n === '')
+        return '';
+    return dir ? `${n}/` : n;
+}
+/**
+ * The name rules a name breaks, in the order they report. `applyRules` reports these, and `createArchive` refuses a
+ * name that breaks any but TOO_LONG. A ".." part is TRAVERSAL's alone, and empty parts at the start belong to an
+ * absolute or UNC path, which ABSOLUTE reports.
+ */
+function nameDetails(name, backslashIsSeparator) {
+    const parts = partsOf(name.replace(DRIVE, ''));
+    const found = [];
+    if (name === '' || name === '/')
+        found.push(types_1.ArchiveDetail.Empty);
+    if (DRIVE.test(name))
+        found.push(types_1.ArchiveDetail.DriveLetter);
+    if (ABSOLUTE.test(name) || ABSOLUTE.test(name.replace(DRIVE, '')))
+        found.push(types_1.ArchiveDetail.Absolute);
+    if (parts.some(p => DOTDOT.test(p)))
+        found.push(types_1.ArchiveDetail.Traversal);
+    const lead = parts.findIndex(p => p !== '');
+    if (parts.some((p, j) => p === '.' || (p === '' && j > lead && lead >= 0)))
+        found.push(types_1.ArchiveDetail.EmptySegment);
+    if (backslashIsSeparator && name.includes('\\'))
+        found.push(types_1.ArchiveDetail.Backslash);
+    if (CONTROL_TEST.test(name))
+        found.push(types_1.ArchiveDetail.ControlCharacter);
+    if (parts.some(p => (0, names_1.windowsReserved)(p) && !DOTDOT.test(p)))
+        found.push(types_1.ArchiveDetail.WindowsReserved);
+    if (utf8Length(name) > 4096 || parts.some(p => utf8Length(p) > 255))
+        found.push(types_1.ArchiveDetail.TooLong);
+    return found;
+}
+/** A tree of path parts. Maps, not objects, so a part named "__proto__" is only a name. */
+class PathTree {
+    children = new Map();
+    /** A symbolic link's target, at the node the link names. */
+    link;
+    explicitDir = false;
+    /** The long names in this folder, by the 8.3 alias they could get. */
+    aliases;
+    child(part, create) {
+        let c = this.children.get(part);
+        if (!c && create) {
+            c = new PathTree();
+            this.children.set(part, c);
+        }
+        return c;
+    }
+}
+/** The node for `parts`, created when `create` is set. */
+function walk(root, parts, create) {
+    let node = root;
+    for (const p of parts) {
+        node = node.child(p, create);
+        if (!node)
+            return undefined;
+    }
+    return node;
+}
+/**
+ * Where a symbolic link's target leads, from the folder the link sits in, following the archive's other links by their
+ * case-folded names. Undefined when it leaves the extraction folder, when it is too long to follow, or when links lead
+ * to each other more than 40 times in all.
+ */
+function resolveLink(from, target, links, budget) {
+    if (ABSOLUTE.test(target) || DRIVE.test(target))
+        return undefined;
+    const parts = target.split(SEPARATOR);
+    if (parts.length > MAX_LINK_PARTS)
+        return undefined;
+    // The path so far, and the tree node of each prefix of it, so a ".." steps back without walking from the root.
+    const path = [...from];
+    const nodesOf = (p) => {
+        const nodes = [links];
+        for (const x of p)
+            nodes.push(nodes[nodes.length - 1]?.child(x, false));
+        return nodes;
+    };
+    let nodes = nodesOf(path);
+    for (const part of parts) {
+        if (part === '' || part === '.')
+            continue;
+        if (DOTDOT.test(part)) {
+            if (!path.length)
+                return undefined;
+            path.pop();
+            nodes.pop();
+            continue;
+        }
+        const key = foldKey(part);
+        path.push(key);
+        const node = nodes[nodes.length - 1]?.child(key, false);
+        nodes.push(node);
+        if (node?.link === undefined)
+            continue;
+        if (--budget.hops < 0)
+            return undefined;
+        const resolved = resolveLink(path.slice(0, -1), node.link, links, budget);
+        if (resolved === undefined)
+            return undefined;
+        path.length = 0;
+        path.push(...resolved);
+        nodes = nodesOf(path);
+    }
+    return path;
+}
+/** The parts of the 8.3 alias Windows could give a long name: the first six characters of its base and three of its extension. */
+function aliasKey(name) {
+    const dot = name.lastIndexOf('.');
+    const rawBase = dot > 0 ? name.slice(0, dot) : name;
+    const rawExt = dot > 0 ? name.slice(dot + 1) : '';
+    // A name that already fits 8.3 is its own short name and gets no alias.
+    if (rawBase.length <= 8 && rawExt.length <= 3 && /^[A-Za-z0-9_^$~!#%&{}@`'()-]*$/.test(rawBase + rawExt))
+        return undefined;
+    const clean = (s) => s
+        .toUpperCase()
+        .replace(/[ .]/g, '')
+        .replace(/[+,;=[\]]/g, '_');
+    return `${clean(rawBase).slice(0, 6)}|${clean(rawExt).slice(0, 3)}`;
+}
+/** The prefix and extension of a name in the form of an alias, such as PROGRA~1. */
+const ALIAS = /^([^~.\\/]{1,6})~[1-9][0-9]{0,5}(?:\.([^.\\/]{0,3}))?$/;
+/** Runs the rules over the entries of an archive. Single-file formats with no name skip the name rules. */
+function applyRules(entries, factory, emit, options) {
+    const strips = (d, c = types_1.ArchiveCategory.Name) => factory.strips(c, d);
+    const decisions = entries.map(e => ({ remove: false, name: e.name, mode: e.mode, dropCapabilities: false }));
+    // Names, each rule on the name as the archive gives it.
+    if (options.names) {
+        for (const [i, e] of entries.entries()) {
+            const name = e.name;
+            const found = nameDetails(name, options.backslashIsSeparator);
+            const tooLong = found.includes(types_1.ArchiveDetail.TooLong);
+            // A drive letter is DRIVE_LETTER's. The rest of the name, "..\\x" in "C:..\\x", is what the other rules read.
+            for (const detail of found) {
+                if (detail === types_1.ArchiveDetail.Empty)
+                    emit(types_1.ArchiveCategory.Name, detail, e);
+                else if (detail === types_1.ArchiveDetail.TooLong)
+                    emit(types_1.ArchiveCategory.Name, detail, e, { name, bytes: utf8Length(name), parts: partsOf(name.replace(DRIVE, '')).length });
+                else
+                    emit(types_1.ArchiveCategory.Name, detail, e, { name });
+            }
+            const d = decisions[i];
+            d.name = fixName(name, e.kind === 'directory', x => (x === types_1.ArchiveDetail.Backslash && !options.backslashIsSeparator ? false : strips(x)));
+            if (d.name === '' && (name !== '' || strips(types_1.ArchiveDetail.Empty)))
+                d.remove = true;
+            if (tooLong && strips(types_1.ArchiveDetail.TooLong))
+                d.remove = true;
+        }
+    }
+    // Collisions, on the names the output would have.
+    const groups = (key) => {
+        const m = new Map();
+        for (const [i, d] of decisions.entries()) {
+            if (d.name === '')
+                continue;
+            const k = key(d.name);
+            const list = m.get(k);
+            if (list)
+                list.push(i);
+            else
+                m.set(k, [i]);
+        }
+        return m;
+    };
+    const notDir = (i) => entries[i].kind !== 'directory';
+    for (const list of groups(exactKey).values()) {
+        const files = list.filter(notDir);
+        if (files.length < 2)
+            continue;
+        // Readers that overwrite keep the last copy, and that is the one the rewrite keeps.
+        for (const i of files.slice(0, -1)) {
+            emit(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.Duplicate, entries[i], { name: entries[i].name });
+            if (strips(types_1.ArchiveDetail.Duplicate))
+                decisions[i].remove = true;
+        }
+    }
+    const collide = (key, inner, detail) => {
+        for (const list of groups(key).values()) {
+            if (list.length < 2 || list.every(i => !notDir(i)))
+                continue;
+            const last = list[list.length - 1];
+            for (const i of list) {
+                if (inner(decisions[i].name) === inner(decisions[last].name))
+                    continue;
+                emit(types_1.ArchiveCategory.Name, detail, entries[i], { name: entries[i].name, other: entries[last].name });
+                if (strips(detail))
+                    decisions[i].remove = true;
+            }
+        }
+    };
+    collide(normalKey, exactKey, types_1.ArchiveDetail.NormalizationCollision);
+    collide(foldKey, normalKey, types_1.ArchiveDetail.CaseCollision);
+    // The tree of the output's names, as written and case-folded: the folders the archive lists, every folder a name
+    // needs, and the symbolic links.
+    const tree = new PathTree();
+    const folded = new PathTree();
+    const finalParts = decisions.map(d => (d.name === '' ? [] : exactKey(d.name).split('/')));
+    for (const [i, parts] of finalParts.entries()) {
+        if (!parts.length)
+            continue;
+        const node = walk(tree, parts, true);
+        if (node && entries[i].kind === 'directory')
+            node.explicitDir = true;
+        const f = walk(folded, parts.map(p => foldKey(p)), true);
+        if (f && entries[i].kind === 'symlink' && entries[i].linkTarget !== undefined)
+            f.link = entries[i].linkTarget;
+    }
+    // A file where a folder is needed: a folder the archive lists under the same name, or a folder some other entry
+    // sits in. A link counts when the archive lists a folder of its name; a link other entries sit under is THROUGH_LINK's.
+    for (const [i, parts] of finalParts.entries()) {
+        const e = entries[i];
+        if (!parts.length || e.kind === 'directory')
+            continue;
+        const node = walk(tree, parts, false);
+        if (!node || !(node.explicitDir || (node.children.size > 0 && e.kind !== 'symlink')))
+            continue;
+        emit(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.FileDirectoryClash, e, { name: e.name });
+        if (strips(types_1.ArchiveDetail.FileDirectoryClash))
+            decisions[i].remove = true;
+    }
+    // A name in the form of an 8.3 alias that Windows could give a long name in the same folder. Each folder node of the
+    // case-folded tree keeps the long names in it by the alias they could get.
+    for (const parts of finalParts) {
+        let node = folded;
+        for (const part of parts) {
+            if (!node)
+                break;
+            const k = aliasKey(part);
+            if (k !== undefined) {
+                node.aliases ??= new Map();
+                const names = node.aliases.get(k) ?? new Set();
+                node.aliases.set(k, names);
+                names.add(part.toUpperCase());
+            }
+            node = node.child(foldKey(part), false);
+        }
+    }
+    for (const [i, parts] of finalParts.entries()) {
+        let node = folded;
+        for (const part of parts) {
+            if (!node)
+                break;
+            const m = ALIAS.exec(part);
+            const longNames = m ? node.aliases?.get(`${m[1].toUpperCase()}|${(m[2] ?? '').toUpperCase()}`) : undefined;
+            if (longNames && [...longNames].some(n => n !== part.toUpperCase())) {
+                emit(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.ShortNameCollision, entries[i], { name: entries[i].name, alias: part });
+                if (strips(types_1.ArchiveDetail.ShortNameCollision))
+                    decisions[i].remove = true;
+                break;
+            }
+            node = node.child(foldKey(part), false);
+        }
+    }
+    // Links.
+    const byName = new Map();
+    for (const [i, e] of entries.entries()) {
+        const d = decisions[i];
+        if (e.kind === 'symlink') {
+            emit(types_1.ArchiveCategory.Link, types_1.ArchiveDetail.Symlink, e, { name: e.name, target: e.linkTarget ?? '' });
+            if (strips(types_1.ArchiveDetail.Symlink, types_1.ArchiveCategory.Link))
+                d.remove = true;
+            const from = finalParts[i].slice(0, -1).map(p => foldKey(p));
+            if (e.linkTarget === undefined || resolveLink(from, e.linkTarget, folded, { hops: 40 }) === undefined) {
+                emit(types_1.ArchiveCategory.Link, types_1.ArchiveDetail.Outside, e, { name: e.name, target: e.linkTarget ?? '' });
+                if (strips(types_1.ArchiveDetail.Outside, types_1.ArchiveCategory.Link))
+                    d.remove = true;
+            }
+        }
+        else if (e.kind === 'hardlink') {
+            // A tar hard link names its target from the top of the archive, not from the folder the link sits in.
+            const target = e.linkTarget ?? '';
+            emit(types_1.ArchiveCategory.Link, types_1.ArchiveDetail.Hardlink, e, { name: e.name, target });
+            if (strips(types_1.ArchiveDetail.Hardlink, types_1.ArchiveCategory.Link))
+                d.remove = true;
+            if (ABSOLUTE.test(target) || DRIVE.test(target) || target.split(SEPARATOR).some(p => DOTDOT.test(p))) {
+                emit(types_1.ArchiveCategory.Link, types_1.ArchiveDetail.Outside, e, { name: e.name, target });
+                if (strips(types_1.ArchiveDetail.Outside, types_1.ArchiveCategory.Link))
+                    d.remove = true;
+            }
+            const to = byName.get(target);
+            if (to === undefined || entries[to].kind === 'directory') {
+                emit(types_1.ArchiveCategory.Link, types_1.ArchiveDetail.Dangling, e, { name: e.name, target });
+                if (strips(types_1.ArchiveDetail.Dangling, types_1.ArchiveCategory.Link))
+                    d.remove = true;
+            }
+            else
+                d.linkIndex = to;
+        }
+        byName.set(e.name, i);
+    }
+    // An entry under a symbolic link is written wherever the link points.
+    for (const [i, parts] of finalParts.entries()) {
+        let node = folded;
+        for (let j = 0; j < parts.length - 1 && node; j++) {
+            node = node.child(foldKey(parts[j]), false);
+            if (node?.link === undefined)
+                continue;
+            emit(types_1.ArchiveCategory.Link, types_1.ArchiveDetail.ThroughLink, entries[i], { name: entries[i].name, link: parts.slice(0, j + 1).join('/') });
+            if (strips(types_1.ArchiveDetail.ThroughLink, types_1.ArchiveCategory.Link))
+                decisions[i].remove = true;
+            break;
+        }
+    }
+    // Special files.
+    for (const [i, e] of entries.entries()) {
+        if (e.anti) {
+            emit(types_1.ArchiveCategory.Special, types_1.ArchiveDetail.AntiItem, e, { name: e.name });
+            if (strips(types_1.ArchiveDetail.AntiItem, types_1.ArchiveCategory.Special))
+                decisions[i].remove = true;
+        }
+        const detail = e.kind === 'device' ? types_1.ArchiveDetail.Device : e.kind === 'fifo' ? types_1.ArchiveDetail.Fifo : e.kind === 'socket' ? types_1.ArchiveDetail.Socket : e.kind === 'other' ? types_1.ArchiveDetail.UnknownType : undefined;
+        if (detail === undefined)
+            continue;
+        emit(types_1.ArchiveCategory.Special, detail, e, { name: e.name, ...(e.typeCode ? { type: e.typeCode } : {}) });
+        if (strips(detail, types_1.ArchiveCategory.Special))
+            decisions[i].remove = true;
+    }
+    // Permissions: setuid, setgid and sticky bits on any entry, folders included.
+    const bits = [
+        [0o4000, types_1.ArchiveDetail.Setuid],
+        [0o2000, types_1.ArchiveDetail.Setgid],
+        [0o1000, types_1.ArchiveDetail.Sticky],
+    ];
+    for (const [i, e] of entries.entries()) {
+        const d = decisions[i];
+        for (const [bit, detail] of bits) {
+            if (e.mode === undefined || !(e.mode & bit))
+                continue;
+            emit(types_1.ArchiveCategory.Permissions, detail, e, { name: e.name, mode: `0${e.mode.toString(8)}` });
+            if (strips(detail, types_1.ArchiveCategory.Permissions))
+                d.mode = (d.mode ?? 0) & ~bit;
+        }
+        if (e.capabilities?.length) {
+            emit(types_1.ArchiveCategory.Permissions, types_1.ArchiveDetail.Capability, e, { name: e.name, attribute: e.capabilities.join(', ') });
+            if (strips(types_1.ArchiveDetail.Capability, types_1.ArchiveCategory.Permissions))
+                d.dropCapabilities = true;
+        }
+    }
+    return decisions;
+}

package/dist/score.d.ts

@@ -0,0 +1,17 @@
+import { type ArchiveOptions, ArchiveRisk, type ArchiveScoreBands, ArchiveCategory as C, ArchiveDetail as D, type DefuseFinding } from './types';
+export declare const DEFAULT_BANDS: ArchiveScoreBands;
+interface Combination {
+    name: string;
+    weight: number;
+    test(has: (c: C, d?: D) => boolean): boolean;
+}
+export declare const COMBINATIONS: Combination[];
+/** The caller's weights first, then the built-in table. A kind from another package scores at the weight it carries. */
+export declare function weightOf(f: DefuseFinding, options: ArchiveOptions): number;
+/** Highest weight in full, a quarter of each other kind's weight, plus combinations, capped at 100. */
+export declare function scoreFindings(findings: DefuseFinding[], options: ArchiveOptions): {
+    score: number;
+    risk: ArchiveRisk;
+};
+export declare function riskFor(score: number, bands: ArchiveScoreBands): ArchiveRisk;
+export {};

package/dist/score.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMBINATIONS = exports.DEFAULT_BANDS = void 0;
+exports.weightOf = weightOf;
+exports.scoreFindings = scoreFindings;
+exports.riskFor = riskFor;
+// Scoring as pdf-defuse src/score.ts does it, with archive-defuse's own combinations.
+const findings_1 = require("./findings");
+const types_1 = require("./types");
+exports.DEFAULT_BANDS = { low: 1, medium: 25, high: 50, critical: 80 };
+exports.COMBINATIONS = [
+    {
+        name: 'a name that leaves the folder with a link that leaves it',
+        weight: 20,
+        test: has => (has(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.Traversal) || has(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.Absolute) || has(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.DriveLetter)) && (has(types_1.ArchiveCategory.Link, types_1.ArchiveDetail.Outside) || has(types_1.ArchiveCategory.Link, types_1.ArchiveDetail.ThroughLink)),
+    },
+    { name: 'setuid or setgid with a link out of the folder', weight: 15, test: has => (has(types_1.ArchiveCategory.Permissions, types_1.ArchiveDetail.Setuid) || has(types_1.ArchiveCategory.Permissions, types_1.ArchiveDetail.Setgid)) && has(types_1.ArchiveCategory.Link, types_1.ArchiveDetail.Outside) },
+    { name: 'a polyglot with data hidden inside', weight: 10, test: has => has(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.Polyglot) && (has(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.HiddenData) || has(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.Overlap)) },
+];
+/** The caller's weights first, then the built-in table. A kind from another package scores at the weight it carries. */
+function weightOf(f, options) {
+    const w = options.scoreWeights ?? [];
+    const exact = w.find(x => x.category === f.category && x.detail === f.detail);
+    if (exact)
+        return exact.weight;
+    const cat = w.find(x => x.category === f.category && x.detail === undefined);
+    if (cat)
+        return cat.weight;
+    return (0, findings_1.findingSpec)(f.category, f.detail)?.weight ?? f.weight ?? 0;
+}
+/** Highest weight in full, a quarter of each other kind's weight, plus combinations, capped at 100. */
+function scoreFindings(findings, options) {
+    // Each kind of finding counts once, so twenty copies of one minor finding do not add up to a critical file.
+    const byKind = new Map();
+    for (const f of findings) {
+        const k = `${f.category}/${f.detail}`;
+        byKind.set(k, Math.max(byKind.get(k) ?? 0, weightOf(f, options)));
+    }
+    const weights = [...byKind.values()].sort((a, b) => b - a);
+    let score = weights.length ? weights[0] + weights.slice(1).reduce((s, w) => s + w / 4, 0) : 0;
+    const has = (c, d) => findings.some(f => f.category === c && (d === undefined || f.detail === d) && weightOf(f, options) > 0);
+    for (const combo of exports.COMBINATIONS)
+        if (combo.test(has))
+            score += combo.weight;
+    score = Math.min(100, Math.round(score));
+    return { score, risk: riskFor(score, options.scoreBands ?? exports.DEFAULT_BANDS) };
+}
+function riskFor(score, bands) {
+    if (score >= bands.critical)
+        return types_1.ArchiveRisk.Critical;
+    if (score >= bands.high)
+        return types_1.ArchiveRisk.High;
+    if (score >= bands.medium)
+        return types_1.ArchiveRisk.Medium;
+    if (score >= bands.low)
+        return types_1.ArchiveRisk.Low;
+    return types_1.ArchiveRisk.None;
+}

package/dist/seven.d.ts

@@ -0,0 +1,75 @@
+import type { Reader } from './io';
+import type { Note } from './model';
+import { type FileInfo, type StreamsInfo } from './sevenzip';
+import type { Limits, Totals } from './stream-meter';
+import { type ByteSource } from './types';
+/** What kind of thing an entry is. */
+export type EntryKind = 'file' | 'dir' | 'symlink' | 'device' | 'fifo' | 'socket';
+/** One entry of a 7z archive. */
+export interface SevenEntry {
+    index: number;
+    info: FileInfo;
+    kind: EntryKind;
+    /** Decoded size the header declares. */
+    size: number;
+    crc?: number;
+    /** The folder the entry's data sits in, if it has data. */
+    folder?: number;
+    /** Where the entry's data starts in its folder's output. */
+    start: number;
+}
+export interface SevenArchive {
+    /** Where the signature header starts: above 0 when other data comes first. */
+    offset: number;
+    entries: SevenEntry[];
+    streams?: StreamsInfo;
+    notes: Note[];
+    /** The header was encrypted and a password opened it. */
+    headerEncrypted: boolean;
+    /** Offset of the first byte after the last structure, when the file goes on past it. */
+    trailingAt?: number;
+    /** Absolute offset of each packed stream. */
+    packOffsets: number[];
+    /** Index of each folder's first packed stream. */
+    folderPack: number[];
+}
+export interface SevenEnv {
+    source: ByteSource;
+    reader: Reader;
+    size: number;
+    limits: Limits;
+    totals: Totals;
+    deadline?: number;
+    /** Passwords to try, in order. */
+    passwords: string[];
+}
+/** The Unix mode stored in the high 16 bits of the attributes, when the low bits say one is there. */
+export declare function unixMode(attrib: number | undefined): number | undefined;
+/**
+ * Reads a 7z archive's signature and headers, decoding an encoded header, and checks that its structures fit the file
+ * and each other. `offset` is where the signature was found.
+ */
+export declare function openSevenZip(env: SevenEnv, offset: number): Promise<SevenArchive>;
+/**
+ * The content of each entry, decoded folder by folder. Entries of one folder read in order share one decode; an entry
+ * before the last one read starts the folder again.
+ */
+export declare class SevenReader {
+    private readonly env;
+    private readonly archive;
+    private open?;
+    /**
+     * The password that opened each encrypted folder. A folder opens with one password, the first the engine tries that
+     * opens it, so an entry that fails its CRC never sends the reader back to the start of the folder with another.
+     */
+    private readonly chosen;
+    /** Passwords that did not open a folder, by folder and password. */
+    private readonly refused;
+    constructor(env: SevenEnv, archive: SevenArchive);
+    /** True when the folder of `entry` is not encrypted, or `password` opens it. */
+    unlock(entry: SevenEntry, password: string): Promise<boolean>;
+    private folder;
+    /** The decoded content of an entry with data. It throws when the folder cannot decode it or its CRC does not match. */
+    content(entry: SevenEntry, password?: string): AsyncGenerator<Uint8Array>;
+    close(): Promise<void>;
+}