@file-viewer/renderer-signature 3.0.0

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,10 @@
+# Third-party notices
+
+`@file-viewer/renderer-signature` contains two optional third-party runtime closures:
+
+- rPGP / Rust crate `pgp` 0.20.0 and its locked Cargo dependencies, compiled to WebAssembly. rPGP is MIT OR Apache-2.0; this distribution selects permissive license branches only.
+- JSZip 3.10.1 and its npm runtime dependencies for bounded ASiC extraction after the package's own central-directory preflight. JSZip declares MIT OR GPL-3.0-or-later; this distribution uses it under the MIT option.
+
+`THIRD_PARTY_LICENSES.json` records every exact Cargo and npm dependency version, declared expression, selected permissive branch, source/repository metadata, and deduplicated license text. The verification gate rejects a closure that has no permissive choice.
+
+No LGPL, AGPL, or GPL-only runtime source is used. OpenPGP.js and GnuPG are not bundled or invoked.

package/dist/container.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/container.worker.js

@@ -0,0 +1,39 @@
+/// <reference lib="webworker" />
+import { inspectAsicContainer } from './structured/asic.js';
+import { normalizeSignatureContainerLimits } from './structured/limits.js';
+const scope = self;
+const errorResponse = (id, error) => ({
+    id,
+    ok: false,
+    error: {
+        code: error instanceof Error &&
+            /unsafe|limit|exceed|zip|path|entry|crc|compression/iu.test(error.message)
+            ? 'unsafe-archive'
+            : error instanceof Error
+                ? 'invalid-input'
+                : 'internal-parser-error',
+        message: error instanceof Error ? error.message : String(error)
+    }
+});
+scope.addEventListener('message', async (event) => {
+    const request = event.data;
+    if (!request ||
+        typeof request.id !== 'string' ||
+        request.type !== 'inspect-asic' ||
+        !(request.input instanceof ArrayBuffer)) {
+        scope.postMessage(errorResponse(typeof (request === null || request === void 0 ? void 0 : request.id) === 'string' ? request.id : 'unknown', new Error('Invalid ASiC Worker request.')));
+        return;
+    }
+    try {
+        const result = await inspectAsicContainer(request.input, normalizeSignatureContainerLimits(request.limits));
+        const transfers = [];
+        for (const member of [...result.documents, ...result.signatures]) {
+            if (member.data)
+                transfers.push(member.data.buffer);
+        }
+        scope.postMessage({ id: request.id, ok: true, result }, transfers);
+    }
+    catch (error) {
+        scope.postMessage(errorResponse(request.id, error));
+    }
+});

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import type { FileRenderHandler, FileViewerRenderedInstance, FileViewerRendererPlugin, RendererDefinition } from '@file-viewer/core';
+export declare const signatureRendererDefinition: RendererDefinition;
+export declare const renderFileViewerSignature: FileRenderHandler<FileViewerRenderedInstance, HTMLDivElement>;
+export declare const signatureRenderer: FileViewerRendererPlugin<FileRenderHandler<FileViewerRenderedInstance, HTMLDivElement>>;
+export { inspectSignatureContainer, inspectEvidenceRecord, DEFAULT_SIGNATURE_ASN1_LIMITS, signatureOidLabels, type InspectSignatureOptions, type SignatureAsn1Limits, type SignatureCertificateSummary, type SignatureContainerKind, type SignatureInspection, type SignatureSignerSummary, type TimestampInfoSummary, type TimestampResponseSummary } from './signatureAsn1.js';
+export { inspectAsicContainer, inspectJws, isProbablyJws, DEFAULT_SIGNATURE_CONTAINER_LIMITS, normalizeSignatureContainerLimits } from './inspect.js';
+export type { FileViewerSignatureOptions } from './signature.js';
+export default signatureRenderer;
+export { OpenPgpWorkerClient, DEFAULT_SIGNATURE_PARSE_LIMITS, normalizeSignatureParseLimits } from './openpgp/client.js';
+export { isProbablyOpenPgp, detectOpenPgpArmorType } from './openpgp/formatDetection.js';
+export type { SignatureParseLimits, OpenPgpInspectionResult, OpenPgpVerificationResult, OpenPgpKeySummary, OpenPgpSignatureSummary, ExtractedLiteralData } from './openpgp/types.js';

package/dist/index.js

@@ -0,0 +1,53 @@
+export const signatureRendererDefinition = {
+    id: 'signature',
+    label: 'Digital signature, timestamp and evidence container',
+    category: 'document',
+    extensions: [
+        'p7m',
+        'p7s',
+        'p7b',
+        'p7c',
+        'pkcs7',
+        'cms',
+        'cmsc',
+        'tsq',
+        'tsr',
+        'tst',
+        'tsd',
+        'asics',
+        'scs',
+        'asice',
+        'sce',
+        'ers',
+        'asc',
+        'sig',
+        'pgp',
+        'gpg',
+        'jws'
+    ],
+    async: true,
+    supportLevel: 'experimental',
+    status: 'experimental',
+    packageName: '@file-viewer/renderer-signature',
+    presets: [],
+    knownLimits: [
+        'Supports bounded CMS/PKCS#7, selected CAdES attributes, RFC 3161, RFC 5544, ASiC, RFC 4998, JWS and OpenPGP inspection.',
+        'Certificate trust, policy compliance, qualified status, and legal validity are not established.',
+        'ASiC XML signature references and RFC 4998 renewal chains are structurally inspected; full XAdES and archival-policy validation are not claimed.',
+        'OpenPGP inspection plus detached, cleartext and embedded signature verification use a lazy rPGP WebAssembly Worker; private-key operations and automatic decryption are intentionally excluded.',
+        'JAdES properties are reported as metadata only. PAdES, full XMLDSig/XAdES/JAdES validation, S/MIME and PGP/MIME remain outside this renderer because they require host integration with their existing document and message renderers.'
+    ],
+    capabilities: { download: true }
+};
+export const renderFileViewerSignature = (buffer, target, type, context) => import('./signature.js').then(({ default: renderSignature }) => renderSignature(buffer, target, type, context));
+export const signatureRenderer = {
+    id: 'file-viewer-renderer-signature',
+    label: 'Flyfish File Viewer signature renderer',
+    definitions: [signatureRendererDefinition],
+    handlers: [{ rendererId: signatureRendererDefinition.id, handler: renderFileViewerSignature }]
+};
+export { inspectSignatureContainer, inspectEvidenceRecord, DEFAULT_SIGNATURE_ASN1_LIMITS, signatureOidLabels } from './signatureAsn1.js';
+export { inspectAsicContainer, inspectJws, isProbablyJws, DEFAULT_SIGNATURE_CONTAINER_LIMITS, normalizeSignatureContainerLimits } from './inspect.js';
+export default signatureRenderer;
+export { OpenPgpWorkerClient, DEFAULT_SIGNATURE_PARSE_LIMITS, normalizeSignatureParseLimits } from './openpgp/client.js';
+export { isProbablyOpenPgp, detectOpenPgpArmorType } from './openpgp/formatDetection.js';

package/dist/inspect.d.ts

@@ -0,0 +1,7 @@
+export { inspectAsicContainer } from './structured/asic.js';
+export { inspectJws, isProbablyJws } from './structured/jws.js';
+export { DEFAULT_SIGNATURE_ASN1_LIMITS, inspectEvidenceRecord, inspectSignatureContainer, signatureOidLabels } from './signatureAsn1.js';
+export { DEFAULT_SIGNATURE_CONTAINER_LIMITS, normalizeSignatureContainerLimits } from './structured/limits.js';
+export type { AsicArchiveMember, AsicInspection, AsicKind, AsicSignatureMember, InspectJwsOptions, JwsInspection, JwsSignatureInspection, JwsVerificationKey } from './structured/types.js';
+export type { SignatureContainerLimits } from './structured/limits.js';
+export type { EvidenceArchiveTimestampSummary, EvidenceRecordInspection, InspectEvidenceRecordOptions, InspectSignatureOptions, SignatureAsn1Limits, SignatureCertificateSummary, SignatureContainerKind, SignatureInspection, SignatureSignerSummary, TimestampInfoSummary, TimestampResponseSummary } from './signatureAsn1.js';

package/dist/inspect.js

@@ -0,0 +1,4 @@
+export { inspectAsicContainer } from './structured/asic.js';
+export { inspectJws, isProbablyJws } from './structured/jws.js';
+export { DEFAULT_SIGNATURE_ASN1_LIMITS, inspectEvidenceRecord, inspectSignatureContainer, signatureOidLabels } from './signatureAsn1.js';
+export { DEFAULT_SIGNATURE_CONTAINER_LIMITS, normalizeSignatureContainerLimits } from './structured/limits.js';

package/dist/openpgp/client.d.ts

@@ -0,0 +1,16 @@
+import type { OpenPgpInspectionResult, OpenPgpVerificationResult, SignatureParseLimits } from './types.js';
+export declare const DEFAULT_SIGNATURE_PARSE_LIMITS: SignatureParseLimits;
+export declare const normalizeSignatureParseLimits: (limits?: Partial<SignatureParseLimits>) => SignatureParseLimits;
+export declare class OpenPgpWorkerClient {
+    private readonly workerFactory?;
+    private worker?;
+    private readonly pending;
+    constructor(workerFactory?: (() => Worker) | undefined);
+    private ensureWorker;
+    private failWorker;
+    private request;
+    inspect(input: ArrayBuffer, limits?: Partial<SignatureParseLimits>, publicKeys?: ArrayBuffer[]): Promise<OpenPgpInspectionResult>;
+    classify(input: ArrayBuffer, limits?: Partial<SignatureParseLimits>): Promise<OpenPgpInspectionResult>;
+    verifyDetached(content: ArrayBuffer, signature: ArrayBuffer, publicKeys: ArrayBuffer[], limits?: Partial<SignatureParseLimits>): Promise<OpenPgpVerificationResult>;
+    dispose(): void;
+}

package/dist/openpgp/client.js

@@ -0,0 +1,148 @@
+export const DEFAULT_SIGNATURE_PARSE_LIMITS = {
+    maxInputBytes: 32 * 1024 * 1024,
+    maxOutputBytes: 16 * 1024 * 1024,
+    maxPacketCount: 4096,
+    maxNestingDepth: 16,
+    maxUserIds: 128,
+    maxSubkeys: 128,
+    maxSignatures: 256
+};
+const ABSOLUTE_SIGNATURE_PARSE_LIMITS = {
+    maxInputBytes: 64 * 1024 * 1024,
+    maxOutputBytes: 32 * 1024 * 1024,
+    maxPacketCount: 8192,
+    maxNestingDepth: 32,
+    maxUserIds: 256,
+    maxSubkeys: 256,
+    maxSignatures: 512
+};
+let nextRequestId = 0;
+const boundedInteger = (value, fallback, ceiling) => typeof value === 'number' && Number.isSafeInteger(value) && value > 0
+    ? Math.min(value, ceiling)
+    : fallback;
+export const normalizeSignatureParseLimits = (limits) => {
+    const result = Object.fromEntries(Object.entries(DEFAULT_SIGNATURE_PARSE_LIMITS).map(([key, fallback]) => [
+        key,
+        boundedInteger(limits === null || limits === void 0 ? void 0 : limits[key], fallback, ABSOLUTE_SIGNATURE_PARSE_LIMITS[key])
+    ]));
+    result.maxOutputBytes = Math.min(result.maxOutputBytes, result.maxInputBytes);
+    return result;
+};
+export class OpenPgpWorkerClient {
+    constructor(workerFactory) {
+        this.workerFactory = workerFactory;
+        this.pending = new Map();
+    }
+    ensureWorker() {
+        if (this.worker)
+            return this.worker;
+        if (typeof Worker === 'undefined') {
+            throw new Error('OpenPGP inspection requires Web Worker support.');
+        }
+        const worker = this.workerFactory
+            ? this.workerFactory()
+            : new Worker(new URL('../signature.worker.js', import.meta.url), {
+                type: 'module',
+                name: 'file-viewer-signature-openpgp'
+            });
+        worker.addEventListener('message', (event) => {
+            const pending = this.pending.get(event.data.id);
+            if (!pending)
+                return;
+            clearTimeout(pending.timer);
+            this.pending.delete(event.data.id);
+            if (event.data.ok)
+                pending.resolve(event.data.result);
+            else
+                pending.reject(Object.assign(new Error(event.data.error.message), { code: event.data.error.code }));
+        });
+        worker.addEventListener('error', (event) => {
+            this.failWorker(new Error(event.message || 'Signature Worker failed.'));
+        });
+        worker.addEventListener('messageerror', () => this.failWorker(new Error('Signature Worker returned an unreadable response.')));
+        this.worker = worker;
+        return worker;
+    }
+    failWorker(error) {
+        var _a;
+        (_a = this.worker) === null || _a === void 0 ? void 0 : _a.terminate();
+        this.worker = undefined;
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+    request(request, transfers) {
+        if (this.pending.size >= 2)
+            return Promise.reject(new Error('Signature Worker request limit exceeded.'));
+        const worker = this.ensureWorker();
+        const id = `signature-${++nextRequestId}`;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.failWorker(new DOMException('Signature Worker request timed out.', 'TimeoutError'));
+            }, 20000);
+            this.pending.set(id, { resolve: (value) => resolve(value), reject, timer });
+            try {
+                worker.postMessage({ ...request, id }, transfers);
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(error);
+            }
+        });
+    }
+    inspect(input, limits, publicKeys = []) {
+        const normalized = normalizeSignatureParseLimits(limits);
+        if (input.byteLength === 0 || input.byteLength > normalized.maxInputBytes) {
+            return Promise.reject(new Error(`OpenPGP input exceeds the ${normalized.maxInputBytes}-byte boundary.`));
+        }
+        if (publicKeys.length > 64) {
+            return Promise.reject(new Error('At most 64 OpenPGP verification keys may be supplied.'));
+        }
+        const keyBytes = publicKeys.reduce((sum, key) => sum + key.byteLength, 0);
+        if (!Number.isSafeInteger(keyBytes) || keyBytes > normalized.maxInputBytes) {
+            return Promise.reject(new Error(`OpenPGP public keys exceed the aggregate ${normalized.maxInputBytes}-byte boundary.`));
+        }
+        const transferable = input.slice(0);
+        const keyTransfers = publicKeys.map((key) => key.slice(0));
+        return this.request({ type: 'inspect', input: transferable, publicKeys: keyTransfers, limits: normalized }, [transferable, ...keyTransfers]);
+    }
+    classify(input, limits) {
+        const normalized = normalizeSignatureParseLimits(limits);
+        if (input.byteLength === 0 || input.byteLength > normalized.maxInputBytes) {
+            return Promise.reject(new Error(`OpenPGP input exceeds the ${normalized.maxInputBytes}-byte boundary.`));
+        }
+        const transferable = input.slice(0);
+        return this.request({ type: 'classify', input: transferable, limits: normalized }, [transferable]);
+    }
+    verifyDetached(content, signature, publicKeys, limits) {
+        const normalized = normalizeSignatureParseLimits(limits);
+        if (signature.byteLength === 0 ||
+            signature.byteLength > normalized.maxInputBytes ||
+            content.byteLength > normalized.maxInputBytes) {
+            return Promise.reject(new Error(`OpenPGP verification input exceeds the ${normalized.maxInputBytes}-byte boundary.`));
+        }
+        if (publicKeys.length === 0 || publicKeys.length > 64) {
+            return Promise.reject(new Error('OpenPGP verification requires between 1 and 64 public-key files.'));
+        }
+        const keyBytes = publicKeys.reduce((sum, key) => sum + key.byteLength, 0);
+        if (!Number.isSafeInteger(keyBytes) || keyBytes > normalized.maxInputBytes) {
+            return Promise.reject(new Error(`OpenPGP public keys exceed the aggregate ${normalized.maxInputBytes}-byte boundary.`));
+        }
+        const contentTransfer = content.slice(0);
+        const signatureTransfer = signature.slice(0);
+        const keyTransfers = publicKeys.map((key) => key.slice(0));
+        return this.request({
+            type: 'verify-detached',
+            content: contentTransfer,
+            signature: signatureTransfer,
+            publicKeys: keyTransfers,
+            limits: normalized
+        }, [contentTransfer, signatureTransfer, ...keyTransfers]);
+    }
+    dispose() {
+        this.failWorker(new DOMException('Signature Worker was terminated.', 'AbortError'));
+    }
+}

package/dist/openpgp/formatDetection.d.ts

@@ -0,0 +1,3 @@
+export declare const detectOpenPgpArmorType: (bytes: Uint8Array) => "signature" | "message" | "cleartext-signed-message" | "public-key" | "private-key" | undefined;
+export declare const hasPlausibleOpenPgpPacketHeader: (bytes: Uint8Array) => boolean;
+export declare const isProbablyOpenPgp: (bytes: Uint8Array, filename?: string, typeHint?: string) => boolean;

package/dist/openpgp/formatDetection.js

@@ -0,0 +1,45 @@
+const ARMOR_MARKERS = [
+    ['-----BEGIN PGP MESSAGE-----', 'message'],
+    ['-----BEGIN PGP SIGNATURE-----', 'signature'],
+    ['-----BEGIN PGP SIGNED MESSAGE-----', 'cleartext-signed-message'],
+    ['-----BEGIN PGP PUBLIC KEY BLOCK-----', 'public-key'],
+    ['-----BEGIN PGP PRIVATE KEY BLOCK-----', 'private-key']
+];
+const OPENPGP_EXTENSIONS = new Set(['asc', 'sig', 'pgp', 'gpg']);
+const extensionOf = (filename) => {
+    if (!filename)
+        return '';
+    const base = filename.split(/[\\/]/).pop() || filename;
+    const dot = base.lastIndexOf('.');
+    return dot >= 0 ? base.slice(dot + 1).toLowerCase() : '';
+};
+export const detectOpenPgpArmorType = (bytes) => {
+    var _a;
+    const head = new TextDecoder('utf-8', { fatal: false })
+        .decode(bytes.subarray(0, Math.min(bytes.byteLength, 512)))
+        .trimStart();
+    return (_a = ARMOR_MARKERS.find(([marker]) => head.startsWith(marker))) === null || _a === void 0 ? void 0 : _a[1];
+};
+export const hasPlausibleOpenPgpPacketHeader = (bytes) => {
+    var _a;
+    if (!bytes.byteLength)
+        return false;
+    const first = (_a = bytes[0]) !== null && _a !== void 0 ? _a : 0;
+    if ((first & 0x80) === 0)
+        return false;
+    if ((first & 0x40) !== 0) {
+        const tag = first & 0x3f;
+        return tag > 0 && tag < 64;
+    }
+    const tag = (first >> 2) & 0x0f;
+    return tag > 0 && tag < 16;
+};
+export const isProbablyOpenPgp = (bytes, filename, typeHint) => {
+    if (detectOpenPgpArmorType(bytes))
+        return true;
+    const type = (typeHint || '').replace(/^\./, '').toLowerCase();
+    if (OPENPGP_EXTENSIONS.has(type) || OPENPGP_EXTENSIONS.has(extensionOf(filename))) {
+        return true;
+    }
+    return hasPlausibleOpenPgpPacketHeader(bytes);
+};

package/dist/openpgp/types.d.ts

@@ -0,0 +1,72 @@
+export type OpenPgpClassification = 'message' | 'encrypted-message' | 'detached-signature' | 'cleartext-signed-message' | 'signed-message' | 'public-key' | 'private-key' | 'literal-data' | 'compressed-data' | 'unknown-openpgp' | 'invalid-openpgp';
+export interface SignatureParseLimits {
+    maxInputBytes: number;
+    maxOutputBytes: number;
+    maxPacketCount: number;
+    maxNestingDepth: number;
+    maxUserIds: number;
+    maxSubkeys: number;
+    maxSignatures: number;
+}
+export interface OpenPgpKeySummary {
+    kind: 'public' | 'private';
+    version?: string;
+    fingerprint?: string;
+    keyId?: string;
+    algorithm?: string;
+    createdAt?: string;
+    userIds: string[];
+    subkeys: Array<{
+        fingerprint?: string;
+        keyId?: string;
+        algorithm?: string;
+        createdAt?: string;
+    }>;
+}
+export interface OpenPgpSignatureSummary {
+    signatureType?: string;
+    hashAlgorithm?: string;
+    publicKeyAlgorithm?: string;
+    createdAt?: string;
+    expiresAt?: string;
+    issuerKeyIds: string[];
+    issuerFingerprints: string[];
+    cryptographicValid?: boolean;
+    verificationKeyFingerprint?: string;
+    verificationKeyId?: string;
+    verificationError?: string;
+}
+export interface ExtractedLiteralData {
+    filename?: string;
+    format?: string;
+    mediaType?: string;
+    data: Uint8Array;
+}
+export interface OpenPgpInspectionResult {
+    classification: OpenPgpClassification;
+    armored: boolean;
+    armorType?: string;
+    packetTypes: string[];
+    packetCount: number;
+    encrypted: boolean;
+    integrityProtected?: boolean;
+    symmetricAlgorithm?: string;
+    aeadMode?: string;
+    compressed: boolean;
+    keys: OpenPgpKeySummary[];
+    signatures: OpenPgpSignatureSummary[];
+    recipients: string[];
+    literalData?: ExtractedLiteralData;
+    warnings: string[];
+}
+export interface OpenPgpVerificationResult {
+    status: 'signature-valid' | 'signature-invalid' | 'public-key-required' | 'original-content-required' | 'unsupported-algorithm';
+    valid?: boolean;
+    keyFingerprint?: string;
+    keyId?: string;
+    error?: string;
+}
+export interface OpenPgpWorkerError {
+    code: 'invalid-input' | 'unsupported-format' | 'unsupported-algorithm' | 'input-too-large' | 'output-too-large' | 'packet-limit-exceeded' | 'nesting-limit-exceeded' | 'decompression-required' | 'encrypted-content' | 'public-key-required' | 'original-content-required' | 'malformed-packet' | 'wasm-initialization-failed' | 'internal-parser-error';
+    message: string;
+}

package/dist/openpgp/types.js

@@ -0,0 +1 @@
+export {};

package/dist/rpgp-wasm/rpgp_wrapper.d.ts

@@ -0,0 +1,43 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export function classify_openpgp(input: Uint8Array, limits: any): any;
+
+export function inspect_openpgp(input: Uint8Array, public_keys: any, limits: any): any;
+
+export function verify_detached_signature(content: Uint8Array, signature: Uint8Array, public_keys: any, limits: any): any;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly classify_openpgp: (a: number, b: number, c: number, d: number) => void;
+    readonly inspect_openpgp: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly verify_detached_signature: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_export3: (a: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;