@awacloud/pdf 0.0.0-stage → 1.0.0

package/src/sig/timestamp.js

@@ -0,0 +1,236 @@
+// Copyright (c) 2026 AwaCloud SAS
+// Author: Matthieu Bouilloux
+// SPDX-License-Identifier: AGPL-3.0-only
+// Dual-licensed; see the NOTICE file for licensing and any additional terms.
+
+/**
+ * @fileoverview RFC 3161 / PAdES B-T timestamp token parser.
+ *
+ * A document-level timestamp token (PAdES B-T, ISO/TS 32001 §5.4) is a
+ * RFC 3161 `TimeStampToken`, i.e. a CMS `SignedData` whose
+ * `encapContentInfo` carries `id-ct-TSTInfo`
+ * (`1.2.840.113549.1.9.16.1.4`). Inside `TSTInfo` (RFC 3161 §2.4.2)
+ * we recover the policy, `messageImprint`, serial number, generation
+ * time and optional nonce / TSA identity.
+ *
+ * @module pdf/sig/timestamp
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfSigOids } from './oids.js';
+import { asn1 } from '@awacloud/fw/crypto/utils/asn1.js';
+import { rsa } from '@awacloud/fw/crypto/pkc/rsa.js';
+import { ecc } from '@awacloud/fw/crypto/pkc/ecc.js';
+import { ed25519 } from '@awacloud/fw/crypto/pkc/ed25519.js';
+import { sha256 } from '@awacloud/fw/crypto/hash/sha256.js';
+import { sha384 } from '@awacloud/fw/crypto/hash/sha384.js';
+import { sha512 } from '@awacloud/fw/crypto/hash/sha512.js';
+
+export const pdfTimestamp = {
+    name: 'pdfTimestamp',
+    dependencies: ['pdfErrors', 'pdfSigOids',
+                   'asn1', 'rsa', 'ecc', 'ed25519',
+                   'sha256', 'sha384', 'sha512'],
+    deps: [pdfErrors, pdfSigOids, asn1, rsa, ecc, ed25519, sha256, sha384, sha512],
+    factory(errors, sigOids, asn1, rsa, ecc, ed25519,
+            sha256, sha384, sha512) {
+        const { EncryptionError, ParseError } = errors;
+        const {
+            DIGEST_OIDS,
+            SIG_DISPATCH_OIDS: SIG_OIDS,
+            OID_TST_INFO,
+            OID_AA_TIMESTAMP
+        } = sigOids;
+        const bundle = { asn1, rsa, ecc, ed25519, sha256, sha384, sha512 };
+
+        function _parseGeneralizedTime(bytes) {
+            if (!bytes || bytes.length < 14) return null;
+            const s = String.fromCharCode.apply(null, Array.from(bytes));
+            const m = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/.exec(s);
+            if (!m) return null;
+            const d = new Date(Date.UTC(
+                +m[1], +m[2] - 1, +m[3], +m[4], +m[5], +m[6]));
+            return isNaN(d.getTime()) ? null : d;
+        }
+
+        function _sliceTLV(buf) {
+            if (!buf || buf.length < 2) return null;
+            let lenLen = 1;
+            let len = buf[1];
+            if (len & 0x80) {
+                const n = len & 0x7F;
+                len = 0;
+                for (let i = 0; i < n; i++) len = (len << 8) | buf[2 + i];
+                lenLen = 1 + n;
+            }
+            return buf.subarray(0, 1 + lenLen + len);
+        }
+
+        function parseTimestampToken(blob, asn1Mod) {
+            const a1 = asn1Mod || asn1;
+            if (!(blob instanceof Uint8Array)) {
+                throw new ParseError('pdf/ts/bad-input',
+                    'parseTimestampToken expects a Uint8Array');
+            }
+            if (!a1 || typeof a1.parseOne !== 'function') {
+                throw new EncryptionError('pdf/ts/missing-fw',
+                    'parseTimestampToken requires the fw asn1 module');
+            }
+            const ci = a1.parseOne(blob, 0);
+            if (!ci) {
+                throw new ParseError('pdf/ts/malformed',
+                    'ContentInfo parse failed');
+            }
+            const ciChildren = a1.parseChildren(ci.value);
+            if (!ciChildren || ciChildren.length < 2) {
+                throw new ParseError('pdf/ts/malformed',
+                    'ContentInfo missing signedData');
+            }
+            const sdNode = a1.parseOne(ciChildren[1].value, 0);
+            if (!sdNode) {
+                throw new ParseError('pdf/ts/malformed',
+                    'SignedData parse failed');
+            }
+            const sd = a1.parseChildren(sdNode.value);
+            if (!sd) {
+                throw new ParseError('pdf/ts/malformed',
+                    'SignedData children parse failed');
+            }
+            const eci = sd[2] && a1.parseChildren(sd[2].value);
+            if (!eci || eci.length < 2) {
+                throw new ParseError('pdf/ts/no-econtent',
+                    'TSTInfo encapContentInfo missing');
+            }
+            const eciTypeOid = a1.readOid(eci[0]);
+            if (eciTypeOid !== OID_TST_INFO) {
+                throw new ParseError('pdf/ts/wrong-econtent',
+                    'eContentType is not id-ct-TSTInfo',
+                    { context: { oid: eciTypeOid } });
+            }
+            const inner = a1.parseOne(eci[1].value, 0);
+            if (!inner) {
+                throw new ParseError('pdf/ts/no-tstinfo',
+                    'TSTInfo OCTET STRING missing');
+            }
+            const tst = a1.parseOne(inner.value, 0);
+            if (!tst) {
+                throw new ParseError('pdf/ts/bad-tstinfo',
+                    'TSTInfo parse failed');
+            }
+            const tstChildren = a1.parseChildren(tst.value);
+            if (!tstChildren || tstChildren.length < 4) {
+                throw new ParseError('pdf/ts/bad-tstinfo',
+                    'TSTInfo too short');
+            }
+            const out = {
+                version:      tstChildren[0].value[0] || 1,
+                policy:       a1.readOid(tstChildren[1]),
+                serialNumber: tstChildren[3].value,
+                genTime:      null,
+                messageImprint: null
+            };
+            const mi = a1.parseChildren(tstChildren[2].value);
+            if (mi && mi.length >= 2) {
+                const algChildren = a1.parseChildren(mi[0].value);
+                const algOid = algChildren && algChildren[0]
+                    ? a1.readOid(algChildren[0]) : null;
+                out.messageImprint = {
+                    hashAlg:      DIGEST_OIDS[algOid] || algOid,
+                    hashedMessage: mi[1].value
+                };
+            }
+            if (tstChildren[4]) {
+                out.genTime = _parseGeneralizedTime(tstChildren[4].value);
+            }
+            for (let i = 5; i < tstChildren.length; i++) {
+                const n = tstChildren[i];
+                if (n.tag === 0x02) {
+                    out.nonce = n.value;
+                } else if (n.tag === 0xA0) {
+                    out.tsa = n.value;
+                }
+            }
+            return out;
+        }
+
+        function verifyTimestamp(tokenBlob, fwBundle) {
+            const fb = fwBundle || bundle;
+            if (!fb || !fb.asn1) {
+                throw new EncryptionError('pdf/ts/missing-fw',
+                    'verifyTimestamp requires fwBundle.asn1');
+            }
+            const errs = [];
+            let parsed;
+            try {
+                parsed = parseTimestampToken(tokenBlob, fb.asn1);
+            } catch (e) {
+                errs.push({ code: e.code || 'pdf/ts/parse',
+                            message: e.message,
+                            cause: e });
+                return { valid: false, errors: errs, tstInfo: null,
+                         hashAlg: null, signatureAlg: null };
+            }
+            const ci = fb.asn1.parseOne(tokenBlob, 0);
+            const ciKids = ci ? fb.asn1.parseChildren(ci.value) : null;
+            const sdNode = ciKids && ciKids[1]
+                ? fb.asn1.parseOne(ciKids[1].value, 0) : null;
+            const sd = sdNode ? fb.asn1.parseChildren(sdNode.value) : null;
+            let signatureAlg = null;
+            if (sd) {
+                let siSet = null;
+                for (let i = sd.length - 1; i >= 0; i--) {
+                    if (sd[i].tag === 0x31) { siSet = sd[i]; break; }
+                }
+                if (siSet) {
+                    const signers = fb.asn1.parseChildren(siSet.value);
+                    const si = signers && signers[0]
+                        ? fb.asn1.parseChildren(signers[0].value) : null;
+                    if (si) {
+                        for (let i = 0; i < si.length - 1; i++) {
+                            if (si[i].tag === 0x30 && si[i + 1].tag === 0x04) {
+                                const algChildren =
+                                    fb.asn1.parseChildren(si[i].value);
+                                if (algChildren && algChildren[0]) {
+                                    const oid = fb.asn1.readOid(algChildren[0]);
+                                    signatureAlg = SIG_OIDS[oid] || null;
+                                }
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            return {
+                valid: errs.length === 0,
+                errors: errs, tstInfo: parsed,
+                hashAlg: parsed.messageImprint && parsed.messageImprint.hashAlg,
+                signatureAlg
+            };
+        }
+
+        function extractTimestampFromUnsignedAttrs(signedAttrs, asn1Mod) {
+            const a1 = asn1Mod || asn1;
+            if (!Array.isArray(signedAttrs)) return null;
+            for (let i = 0; i < signedAttrs.length; i++) {
+                const attr = a1.parseChildren(signedAttrs[i].value);
+                if (!attr || attr.length < 2) continue;
+                const oid = a1.readOid(attr[0]);
+                if (oid !== OID_AA_TIMESTAMP) continue;
+                const set = a1.parseChildren(attr[1].value);
+                if (!set || !set.length) continue;
+                return _sliceTLV(attr[1].value);
+            }
+            return null;
+        }
+
+        return {
+            parseTimestampToken,
+            verifyTimestamp,
+            extractTimestampFromUnsignedAttrs,
+            OID_TST_INFO, OID_AA_TIMESTAMP
+        };
+    }
+};

package/src/syntax/crossRefStream.js

@@ -0,0 +1,133 @@
+// Copyright (c) 2026 AwaCloud SAS
+// Author: Matthieu Bouilloux
+// SPDX-License-Identifier: AGPL-3.0-only
+// Dual-licensed; see the NOTICE file for licensing and any additional terms.
+
+/**
+ * @fileoverview Cross-reference stream parser per ISO 32000-2:2020 §7.5.8.
+ *
+ * @module pdf/syntax/crossRefStream
+ */
+
+/**
+ * Module factory — worker-safe, self-contained.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParserObj } from './parser-obj.js';
+
+export const pdfCrossRefStream = {
+    name: 'pdfCrossRefStream',
+    dependencies: ['pdfErrors', 'pdfParserObj'],
+    deps: [pdfErrors, pdfParserObj],
+    factory(errors, parserObj) {
+        const { ParseError } = errors;
+        const { isType } = parserObj;
+
+        function readBE(bytes, off, len) {
+            let v = 0;
+            for (let i = 0; i < len; i++) v = (v * 256) + bytes[off + i];
+            return v;
+        }
+
+        function readInt(entry, label) {
+            if (!entry || entry.type !== 'int') {
+                throw new ParseError('pdf/xrefstm/missing-int',
+                    `XRef stream dict missing required /${label}`,
+                    { context: { label } });
+            }
+            return entry.value;
+        }
+
+        function parseCrossRefStream(decoded, dict) {
+            if (!(decoded instanceof Uint8Array)) {
+                throw new ParseError('pdf/xrefstm/bad-input',
+                    'parseCrossRefStream expects Uint8Array');
+            }
+            if (!isType(dict, 'dict')) {
+                throw new ParseError('pdf/xrefstm/bad-dict',
+                    'XRef stream dict must be a typed dict');
+            }
+            const e = dict.entries;
+            if (!e.Type || e.Type.type !== 'name' || e.Type.value !== 'XRef') {
+                throw new ParseError('pdf/xrefstm/wrong-type',
+                    '/Type must be /XRef',
+                    { context: { actual: e.Type && e.Type.value } });
+            }
+
+            const W = e.W;
+            if (!W || W.type !== 'array' || W.items.length !== 3) {
+                throw new ParseError('pdf/xrefstm/bad-W',
+                    '/W must be a 3-element array', { context: { items: W && W.items && W.items.length } });
+            }
+            const w = W.items.map(it => {
+                if (it.type !== 'int' || it.value < 0) {
+                    throw new ParseError('pdf/xrefstm/bad-W-entry',
+                        '/W entries must be non-negative ints');
+                }
+                return it.value;
+            });
+            const recordSize = w[0] + w[1] + w[2];
+            if (recordSize <= 0) {
+                throw new ParseError('pdf/xrefstm/bad-W-zero',
+                    '/W must yield at least one non-zero field');
+            }
+
+            let index;
+            if (e.Index) {
+                if (e.Index.type !== 'array' || (e.Index.items.length & 1) !== 0) {
+                    throw new ParseError('pdf/xrefstm/bad-Index',
+                        '/Index must be an array of (first, count) pairs');
+                }
+                index = [];
+                for (let i = 0; i < e.Index.items.length; i += 2) {
+                    const f = e.Index.items[i], c = e.Index.items[i + 1];
+                    if (f.type !== 'int' || c.type !== 'int') {
+                        throw new ParseError('pdf/xrefstm/bad-Index-entry',
+                            '/Index entries must be ints');
+                    }
+                    index.push([f.value, c.value]);
+                }
+            } else {
+                const size = readInt(e.Size, 'Size');
+                index = [[0, size]];
+            }
+
+            const entries = {};
+            let pos = 0;
+            for (const [first, count] of index) {
+                for (let k = 0; k < count; k++) {
+                    if (pos + recordSize > decoded.length) {
+                        throw new ParseError('pdf/xrefstm/truncated',
+                            'truncated xref stream payload',
+                            { context: { pos, recordSize, length: decoded.length } });
+                    }
+                    const t  = w[0] > 0 ? readBE(decoded, pos,         w[0]) : 1;
+                    const f2 = w[1] > 0 ? readBE(decoded, pos + w[0],  w[1]) : 0;
+                    const f3 = w[2] > 0 ? readBE(decoded, pos + w[0] + w[1], w[2]) : 0;
+                    pos += recordSize;
+                    const num = first + k;
+                    if (t === 0) {
+                        entries[num] = { type: 0, offset: f2, gen: f3, free: true };
+                    } else if (t === 1) {
+                        entries[num] = { type: 1, offset: f2, gen: f3, free: false };
+                    } else if (t === 2) {
+                        entries[num] = {
+                            type: 2, objStm: f2, index: f3,
+                            free: false, offset: 0, gen: 0
+                        };
+                    } else {
+                        entries[num] = { type: t, offset: 0, gen: 0, free: true };
+                    }
+                }
+            }
+
+            return {
+                entries,
+                size: e.Size && e.Size.type === 'int' ? e.Size.value : Object.keys(entries).length,
+                trailer: dict
+            };
+        }
+
+        return { parseCrossRefStream };
+    }
+};

package/src/syntax/filters/ascii85.js

@@ -0,0 +1,122 @@
+// Copyright (c) 2026 AwaCloud SAS
+// Author: Matthieu Bouilloux
+// SPDX-License-Identifier: AGPL-3.0-only
+// Dual-licensed; see the NOTICE file for licensing and any additional terms.
+
+/**
+ * @fileoverview ASCII85Decode filter per ISO 32000-2:2020 §7.4.3.
+ *
+ * 5 ASCII characters in the range `!`..`u` decode to 4 binary bytes
+ * encoding a 32-bit big-endian integer (base-85). The special
+ * character `z` represents 4 zero bytes. The stream is terminated by
+ * `~>`. The final group may be 2..4 characters, decoding to 1..3
+ * trailing bytes.
+ *
+ * @module pdf/syntax/filters/ascii85
+ */
+
+/**
+ * Module factory — worker-safe, self-contained.
+ */
+import { pdfErrors } from '../../errors.js';
+
+export const pdfAscii85 = {
+    name: 'pdfAscii85',
+    dependencies: ['pdfErrors'],
+    deps: [pdfErrors],
+    factory(errors) {
+        const { ParseError } = errors;
+        const TILDE = 0x7E, GT = 0x3E, Z = 0x7A, BANG = 0x21, U = 0x75;
+        const SP = 0x20, HT = 0x09, LF = 0x0A, CR = 0x0D, FF = 0x0C, NUL = 0x00;
+        function isWs(b) {
+            return b === SP || b === HT || b === LF || b === CR || b === FF || b === NUL;
+        }
+
+        function decode(bytes) {
+            if (!(bytes instanceof Uint8Array)) {
+                throw new ParseError('pdf/ascii85/bad-input',
+                    'ASCII85Decode expects Uint8Array');
+            }
+            const out = [];
+            let group = 0, count = 0;
+            for (let i = 0; i < bytes.length; i++) {
+                const b = bytes[i];
+                if (isWs(b)) continue;
+                if (b === TILDE) {
+                    if (i + 1 < bytes.length && bytes[i + 1] === GT) break;
+                    throw new ParseError('pdf/ascii85/bad-eod',
+                        '~ not followed by >', { context: { offset: i } });
+                }
+                if (b === Z) {
+                    if (count !== 0) {
+                        throw new ParseError('pdf/ascii85/bad-z',
+                            'z must appear at group boundary', { context: { offset: i } });
+                    }
+                    out.push(0, 0, 0, 0);
+                    continue;
+                }
+                if (b < BANG || b > U) {
+                    throw new ParseError('pdf/ascii85/bad-digit',
+                        'character outside ! .. u',
+                        { context: { offset: i, byte: b } });
+                }
+                group = group * 85 + (b - BANG);
+                count++;
+                if (count === 5) {
+                    out.push((group >>> 24) & 0xFF, (group >>> 16) & 0xFF,
+                             (group >>>  8) & 0xFF,  group         & 0xFF);
+                    group = 0; count = 0;
+                }
+            }
+            if (count > 0) {
+                for (let k = count; k < 5; k++) group = group * 85 + 84;
+                const decoded = [
+                    (group >>> 24) & 0xFF, (group >>> 16) & 0xFF,
+                    (group >>>  8) & 0xFF,  group         & 0xFF
+                ];
+                for (let k = 0; k < count - 1; k++) out.push(decoded[k]);
+            }
+            return Uint8Array.from(out);
+        }
+
+        function encode(bytes) {
+            if (!(bytes instanceof Uint8Array)) {
+                throw new ParseError('pdf/ascii85/bad-input',
+                    'ASCII85Encode expects Uint8Array');
+            }
+            const chars = [];
+            let i = 0;
+            while (i + 4 <= bytes.length) {
+                const v = (bytes[i] * 0x1000000) + (bytes[i + 1] << 16)
+                        + (bytes[i + 2] << 8) + bytes[i + 3];
+                if (v === 0) chars.push(Z);
+                else {
+                    const g = [0, 0, 0, 0, 0];
+                    let n = v;
+                    for (let k = 4; k >= 0; k--) {
+                        g[k] = (n % 85) + BANG; n = Math.floor(n / 85);
+                    }
+                    chars.push(g[0], g[1], g[2], g[3], g[4]);
+                }
+                i += 4;
+            }
+            const rem = bytes.length - i;
+            if (rem > 0) {
+                const padded = new Uint8Array(4);
+                padded.set(bytes.subarray(i));
+                const v = (padded[0] * 0x1000000) + (padded[1] << 16)
+                        + (padded[2] << 8) + padded[3];
+                const g = [0, 0, 0, 0, 0];
+                let n = v;
+                for (let k = 4; k >= 0; k--) {
+                    g[k] = (n % 85) + BANG; n = Math.floor(n / 85);
+                }
+                for (let k = 0; k < rem + 1; k++) chars.push(g[k]);
+            }
+            chars.push(TILDE, GT);
+            return Uint8Array.from(chars);
+        }
+
+        return { decode, encode };
+    }
+};

package/src/syntax/filters/asciiHex.js

@@ -0,0 +1,83 @@
+// Copyright (c) 2026 AwaCloud SAS
+// Author: Matthieu Bouilloux
+// SPDX-License-Identifier: AGPL-3.0-only
+// Dual-licensed; see the NOTICE file for licensing and any additional terms.
+
+/**
+ * @fileoverview ASCIIHexDecode filter per ISO 32000-2:2020 §7.4.2.
+ *
+ * Each pair of ASCII hex digits decodes to one byte. Whitespace is
+ * ignored. The terminator `>` ends the stream ; an odd number of hex
+ * digits is treated as if a trailing `0` were present.
+ *
+ * @module pdf/syntax/filters/asciiHex
+ */
+
+/**
+ * Module factory — worker-safe, self-contained.
+ */
+import { pdfErrors } from '../../errors.js';
+
+export const pdfAsciiHex = {
+    name: 'pdfAsciiHex',
+    dependencies: ['pdfErrors'],
+    deps: [pdfErrors],
+    factory(errors) {
+        const { ParseError } = errors;
+        const HEX_LO = [
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+             0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
+            -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+            -1, 10, 11, 12, 13, 14, 15, -1
+        ];
+        const SP = 0x20, HT = 0x09, LF = 0x0A, CR = 0x0D, FF = 0x0C, NUL = 0x00;
+        function isWs(b) {
+            return b === SP || b === HT || b === LF || b === CR || b === FF || b === NUL;
+        }
+
+        function decode(bytes) {
+            if (!(bytes instanceof Uint8Array)) {
+                throw new ParseError('pdf/asciiHex/bad-input',
+                    'ASCIIHexDecode expects Uint8Array');
+            }
+            const out = [];
+            let pending = -1;
+            for (let i = 0; i < bytes.length; i++) {
+                const b = bytes[i];
+                if (b === 0x3E) break;
+                if (isWs(b)) continue;
+                const v = b < HEX_LO.length ? HEX_LO[b] : -1;
+                if (v < 0) {
+                    throw new ParseError('pdf/asciiHex/bad-digit',
+                        'invalid hex digit',
+                        { context: { offset: i, byte: b } });
+                }
+                if (pending < 0) pending = v;
+                else { out.push((pending << 4) | v); pending = -1; }
+            }
+            if (pending >= 0) out.push(pending << 4);
+            return Uint8Array.from(out);
+        }
+
+        function encode(bytes) {
+            if (!(bytes instanceof Uint8Array)) {
+                throw new ParseError('pdf/asciiHex/bad-input',
+                    'ASCIIHexEncode expects Uint8Array');
+            }
+            const H = '0123456789ABCDEF';
+            let s = '';
+            for (let i = 0; i < bytes.length; i++) {
+                if (i > 0 && (i & 31) === 0) s += '\n';
+                const b = bytes[i];
+                s += H[b >> 4] + H[b & 0xF];
+            }
+            s += '>';
+            return new TextEncoder().encode(s);
+        }
+
+        return { decode, encode };
+    }
+};