@gerege-systems/eid-mongolia-sdk 0.20.1 → 0.22.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/pades.cjs CHANGED
@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
20
20
  // src/pades.ts
21
21
  var pades_exports = {};
22
22
  __export(pades_exports, {
23
+ CertificateRevokedError: () => CertificateRevokedError,
23
24
  PADES_ERROR_CODES: () => PADES_ERROR_CODES,
24
25
  PROFILE_VERSION: () => PROFILE_VERSION,
25
26
  PadesError: () => PadesError,
@@ -886,10 +887,210 @@ function isBrowser() {
886
887
  return typeof g.window !== "undefined" || typeof g.process?.versions?.node !== "string";
887
888
  }
888
889
 
890
+ // src/pades/validate/gofmt.ts
891
+ var ZERO_TIME = { nanos: 0 };
892
+ function fromPrecise(t) {
893
+ return { sec: Math.floor(t.date.getTime() / 1e3), nanos: t.nanos };
894
+ }
895
+ function fromDate(d) {
896
+ const ms = d.getTime();
897
+ const sec = Math.floor(ms / 1e3);
898
+ return { sec, nanos: (ms - sec * 1e3) * 1e6 };
899
+ }
900
+ var isZero = (t) => t.sec === void 0;
901
+ function before(a, b) {
902
+ return cmp(a, b) < 0;
903
+ }
904
+ function after(a, b) {
905
+ return cmp(a, b) > 0;
906
+ }
907
+ function cmp(a, b) {
908
+ const as = a.sec ?? -62135596800;
909
+ const bs = b.sec ?? -62135596800;
910
+ if (as !== bs) return as < bs ? -1 : 1;
911
+ return a.nanos === b.nanos ? 0 : a.nanos < b.nanos ? -1 : 1;
912
+ }
913
+ function addMs(t, ms) {
914
+ const total = (t.sec ?? -62135596800) * 1e3 + Math.floor(t.nanos / 1e6) + ms;
915
+ const sec = Math.floor(total / 1e3);
916
+ return { sec, nanos: (total - sec * 1e3) * 1e6 + t.nanos % 1e6 };
917
+ }
918
+ var NO_RUNE = -1;
919
+ var PDF_DOC = (() => {
920
+ const t = new Array(256).fill(NO_RUNE);
921
+ t[9] = 9;
922
+ t[10] = 10;
923
+ t[13] = 13;
924
+ [728, 711, 710, 729, 733, 731, 730, 732].forEach((r, i) => t[24 + i] = r);
925
+ for (let i = 32; i < 127; i++) t[i] = i;
926
+ [
927
+ 8226,
928
+ 8224,
929
+ 8225,
930
+ 8230,
931
+ 8212,
932
+ 8211,
933
+ 402,
934
+ 8260,
935
+ 8249,
936
+ 8250,
937
+ 8722,
938
+ 8240,
939
+ 8222,
940
+ 8220,
941
+ 8221,
942
+ 8216,
943
+ 8217,
944
+ 8218,
945
+ 8482,
946
+ 64257,
947
+ 64258,
948
+ 321,
949
+ 338,
950
+ 352,
951
+ 376,
952
+ 381,
953
+ 305,
954
+ 322,
955
+ 339,
956
+ 353,
957
+ 382,
958
+ NO_RUNE
959
+ ].forEach((r, i) => t[128 + i] = r);
960
+ t[160] = 8364;
961
+ for (let i = 161; i <= 255; i++) t[i] = i;
962
+ t[173] = NO_RUNE;
963
+ return t;
964
+ })();
965
+
966
+ // src/pades/revocation.ts
967
+ var REVOCATION_MAX_AGE_MS = 24 * 36e5;
968
+ var REVOCATION_CLOCK_SKEW_MS = 5 * 6e4;
969
+ function freshAt(thisUpdate, nextUpdate, at, now) {
970
+ if (isZero(thisUpdate) || after(thisUpdate, addMs(now, REVOCATION_CLOCK_SKEW_MS))) return false;
971
+ if (!isZero(nextUpdate) && before(nextUpdate, addMs(at, -REVOCATION_CLOCK_SKEW_MS))) return false;
972
+ if (!before(thisUpdate, addMs(at, -REVOCATION_MAX_AGE_MS))) return true;
973
+ return !isZero(nextUpdate) && !after(thisUpdate, at);
974
+ }
975
+ var OCSP_HASHES = {
976
+ "1.3.14.3.2.26": "SHA-1",
977
+ "2.16.840.1.101.3.4.2.1": "SHA-256",
978
+ "2.16.840.1.101.3.4.2.2": "SHA-384",
979
+ "2.16.840.1.101.3.4.2.3": "SHA-512"
980
+ };
981
+ async function ocspCertIDMatches(der2, cert, issuer) {
982
+ try {
983
+ const top = children(expect(readNode(der2), TAG.SEQUENCE, "OCSPResponse"));
984
+ const st = expect(top[0], TAG.ENUMERATED, "status");
985
+ if (st.value.length !== 1 || st.value[0] !== 0) return false;
986
+ const rb = children(expect(children(expect(top[1], 160, "responseBytes"))[0], TAG.SEQUENCE, "ResponseBytes"));
987
+ expect(rb[0], TAG.OID, "responseType");
988
+ const basic = children(expect(readNode(expect(rb[1], TAG.OCTET_STRING, "response").value), TAG.SEQUENCE, "BasicOCSPResponse"));
989
+ const tf = children(expect(basic[0], TAG.SEQUENCE, "tbsResponseData"));
990
+ let i = 0;
991
+ if (tf[i]?.tag === 160) i++;
992
+ if (!tf[i++]) return false;
993
+ expect(tf[i++], TAG.GeneralizedTime, "producedAt");
994
+ const singles = children(expect(tf[i], TAG.SEQUENCE, "responses"));
995
+ const serial = intValue(cert.serial);
996
+ let found = false;
997
+ for (const single of singles) {
998
+ const cid = children(expect(children(expect(single, TAG.SEQUENCE, "SingleResponse"))[0], TAG.SEQUENCE, "CertID"));
999
+ const alg = oidString(expect(children(expect(cid[0], TAG.SEQUENCE, "hashAlgorithm"))[0], TAG.OID, "hash").value);
1000
+ const nameHash = expect(cid[1], TAG.OCTET_STRING, "issuerNameHash").value;
1001
+ const keyHash = expect(cid[2], TAG.OCTET_STRING, "issuerKeyHash").value;
1002
+ if (intValue(expect(cid[3], TAG.INTEGER, "serial").value) !== serial) continue;
1003
+ const h = OCSP_HASHES[alg];
1004
+ if (!h) return false;
1005
+ if (!equal(nameHash, await digest(h, issuer.rawSubject)) || !equal(keyHash, await digest(h, issuer.publicKey))) return false;
1006
+ found = true;
1007
+ }
1008
+ return found;
1009
+ } catch {
1010
+ return false;
1011
+ }
1012
+ }
1013
+ var OID_AKI = "2.5.29.35";
1014
+ var isTime = (n) => n !== void 0 && (n.tag === TAG.UTCTime || n.tag === TAG.GeneralizedTime);
1015
+ function parseCRL(der2) {
1016
+ try {
1017
+ const top = children(expect(parseOne(der2), TAG.SEQUENCE, "CertificateList"));
1018
+ const tbs = expect(top[0], TAG.SEQUENCE, "TBSCertList");
1019
+ const sigAlg = expect(top[1], TAG.SEQUENCE, "sigAlg");
1020
+ const sigBits = expect(top[2], TAG.BIT_STRING, "sig");
1021
+ const f = children(tbs);
1022
+ let i = 0;
1023
+ if (f[i]?.tag === TAG.INTEGER) i++;
1024
+ expect(f[i++], TAG.SEQUENCE, "signature");
1025
+ const issuer = expect(f[i++], TAG.SEQUENCE, "issuer");
1026
+ const tu = f[i++];
1027
+ if (!isTime(tu)) return void 0;
1028
+ const thisUpdate = fromPrecise(parsePreciseTime(tu));
1029
+ let nextUpdate = { nanos: 0 };
1030
+ if (isTime(f[i])) nextUpdate = fromPrecise(parsePreciseTime(f[i++]));
1031
+ const revoked = [];
1032
+ if (f[i]?.tag === TAG.SEQUENCE) {
1033
+ for (const e of children(f[i++])) {
1034
+ const p = children(expect(e, TAG.SEQUENCE, "entry"));
1035
+ revoked.push({ serial: intValue(expect(p[0], TAG.INTEGER, "serial").value), time: fromPrecise(parsePreciseTime(p[1])) });
1036
+ }
1037
+ }
1038
+ let authorityKeyId = new Uint8Array();
1039
+ if (f[i]?.tag === 160) {
1040
+ for (const ext of children(expect(children(f[i])[0], TAG.SEQUENCE, "extensions"))) {
1041
+ const e = children(ext);
1042
+ if (oidString(expect(e[0], TAG.OID, "extnID").value) !== OID_AKI) continue;
1043
+ const k = children(parseOne(expect(e[e.length - 1], TAG.OCTET_STRING, "extnValue").value)).find((x) => x.tag === 128);
1044
+ if (k) authorityKeyId = k.value;
1045
+ }
1046
+ }
1047
+ return { rawIssuer: issuer.raw, tbs: tbs.raw, sigAlg, sig: sigBits.value.subarray(1), thisUpdate, nextUpdate, authorityKeyId, revoked };
1048
+ } catch {
1049
+ return void 0;
1050
+ }
1051
+ }
1052
+ var SHA1_SIG = /* @__PURE__ */ new Set(["1.2.840.113549.1.1.5", "1.2.840.10045.4.1", "1.2.840.10040.4.3", "1.2.840.113549.1.1.4"]);
1053
+ async function crlSignedBy(crl, issuer) {
1054
+ if (issuer.version === 3 && !issuer.basicConstraintsValid || issuer.basicConstraintsValid && !issuer.isCA) return false;
1055
+ if (issuer.keyUsage !== 0 && !(issuer.keyUsage & 1 << 6)) return false;
1056
+ if (SHA1_SIG.has(oidString(children(crl.sigAlg)[0].value))) return false;
1057
+ try {
1058
+ return await verifySignature(issuer, crl.sigAlg, crl.tbs, crl.sig);
1059
+ } catch {
1060
+ return false;
1061
+ }
1062
+ }
1063
+ function subjectKeyId(c) {
1064
+ const v = c.extensions.find((e) => e.oid === "2.5.29.14")?.value;
1065
+ if (!v) return new Uint8Array();
1066
+ try {
1067
+ const n = parseOne(v);
1068
+ return n.tag === TAG.OCTET_STRING ? n.value : new Uint8Array();
1069
+ } catch {
1070
+ return new Uint8Array();
1071
+ }
1072
+ }
1073
+ async function crlFor(crl, cert, issuer) {
1074
+ if (!equal(crl.rawIssuer, cert.rawIssuer) || !equal(crl.rawIssuer, issuer.rawSubject)) return false;
1075
+ const ski = subjectKeyId(issuer);
1076
+ if (crl.authorityKeyId.length > 0 && ski.length > 0 && !equal(crl.authorityKeyId, ski)) return false;
1077
+ return crlSignedBy(crl, issuer);
1078
+ }
1079
+ function crlListed(crl, cert) {
1080
+ const serial = intValue(cert.serial);
1081
+ return crl.revoked.find((e) => e.serial === serial)?.time;
1082
+ }
1083
+ var CertificateRevokedError = class extends Error {
1084
+ constructor() {
1085
+ super("\u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D \u0446\u0443\u0446\u043B\u0430\u0433\u0434\u0441\u0430\u043D");
1086
+ this.name = "CertificateRevokedError";
1087
+ }
1088
+ };
1089
+
889
1090
  // src/pades/ltv.ts
890
1091
  var MAX_TSA_SKEW_MS = 10 * 6e4;
891
1092
  var tsMs = (t) => t.date.getTime();
892
- function after(a, b) {
1093
+ function after2(a, b) {
893
1094
  const am = Math.floor(a.date.getTime() / 1e3);
894
1095
  const bm = Math.floor(b.date.getTime() / 1e3);
895
1096
  if (am !== bm) return am > bm;
@@ -999,9 +1200,9 @@ async function parseOCSP(der2, serial, issuer) {
999
1200
  if (!status) throw new Error("OCSP certStatus");
1000
1201
  const revokedAt = status === "revoked" ? parsePreciseTime(expect(children(st)[0], TAG.GeneralizedTime, "revocationTime")) : void 0;
1001
1202
  const thisUpdate = parsePreciseTime(expect(single[2], TAG.GeneralizedTime, "thisUpdate"));
1002
- let nextUpdate;
1203
+ let nextUpdatePrecise;
1003
1204
  for (const x of single.slice(3)) {
1004
- if (x.tag === 160) nextUpdate = parsePreciseTime(children(x)[0]).date;
1205
+ if (x.tag === 160) nextUpdatePrecise = parsePreciseTime(children(x)[0]);
1005
1206
  if (x.tag === 161) {
1006
1207
  for (const ext of children(children(x)[0])) {
1007
1208
  const e = children(ext);
@@ -1009,7 +1210,7 @@ async function parseOCSP(der2, serial, issuer) {
1009
1210
  }
1010
1211
  }
1011
1212
  }
1012
- return { status, serial: intValue(expect(cid[3], TAG.INTEGER, "serial").value), thisUpdate, nextUpdate, revokedAt, certificate };
1213
+ return { status, serial: intValue(expect(cid[3], TAG.INTEGER, "serial").value), thisUpdate, nextUpdate: nextUpdatePrecise?.date, nextUpdatePrecise, revokedAt, certificate };
1013
1214
  }
1014
1215
  function responderOK(resp, issuer) {
1015
1216
  if (!resp.certificate || equal(resp.certificate.raw, issuer.raw)) return true;
@@ -1017,45 +1218,26 @@ function responderOK(resp, issuer) {
1017
1218
  }
1018
1219
  var NotFresh = class extends Error {
1019
1220
  };
1221
+ function ocspFreshAt(resp, at, now) {
1222
+ return freshAt(fromPrecise(resp.thisUpdate), resp.nextUpdatePrecise ? fromPrecise(resp.nextUpdatePrecise) : ZERO_TIME, at, now);
1223
+ }
1020
1224
  async function fetchOCSP(f, url, c, issuer, now, fresh) {
1021
1225
  const der2 = await f.do("POST", url, "application/ocsp-request", await ocspRequest(c, issuer));
1022
1226
  const resp = await parseOCSPForCert(der2, c, issuer);
1023
1227
  if (!responderOK(resp, issuer)) throw new Error("OCSP responder-\u0438\u0439\u043D EKU OCSPSigning \u0431\u0438\u0448");
1024
- if (resp.status !== "good" || resp.nextUpdate && resp.nextUpdate.getTime() < now.getTime()) throw new Error(`OCSP ${c.subjectCN}: ${resp.status}`);
1025
- if (fresh && !after(resp.thisUpdate, fresh)) throw new NotFresh("OCSP thisUpdate \u043D\u044C timestamp-\u0430\u0430\u0441 \u0445\u043E\u0436\u0443\u0443 \u0431\u0438\u0448");
1228
+ if (!await ocspCertIDMatches(der2, c, issuer)) throw new Error("OCSP CertID \u044D\u043D\u044D \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D/\u043E\u043B\u0433\u043E\u0433\u0447\u0438\u0439\u043D\u0445 \u0431\u0438\u0448");
1229
+ if (resp.status === "revoked") throw new CertificateRevokedError();
1230
+ const n = fromDate(now);
1231
+ if (resp.status !== "good" || !ocspFreshAt(resp, n, n)) throw new Error(`OCSP status ${resp.status}`);
1232
+ if (fresh && !after2(resp.thisUpdate, fresh)) throw new NotFresh("OCSP thisUpdate \u043D\u044C timestamp-\u0430\u0430\u0441 \u0445\u043E\u0436\u0443\u0443 \u0431\u0438\u0448");
1026
1233
  return [der2, resp];
1027
1234
  }
1028
1235
  async function crlCovers(der2, c, issuer, now) {
1029
- try {
1030
- const top = children(expect(parseOne(der2), TAG.SEQUENCE, "CertificateList"));
1031
- const tbs = expect(top[0], TAG.SEQUENCE, "TBSCertList");
1032
- const sigAlg = expect(top[1], TAG.SEQUENCE, "sigAlg");
1033
- const sig = expect(top[2], TAG.BIT_STRING, "sig").value.subarray(1);
1034
- const f = children(tbs);
1035
- let i = 0;
1036
- if (f[0]?.tag === TAG.INTEGER) i++;
1037
- i++;
1038
- const iss = expect(f[i++], TAG.SEQUENCE, "issuer");
1039
- if (!equal(iss.raw, c.rawIssuer)) return false;
1040
- if (issuer.version === 3 && !issuer.basicConstraintsValid) return false;
1041
- if (issuer.keyUsage !== 0 && !(issuer.keyUsage & 1 << 6)) return false;
1042
- if (!await verifySignature(issuer, sigAlg, tbs.raw, sig)) return false;
1043
- i++;
1044
- const nu = f[i];
1045
- if (!nu || nu.tag !== TAG.UTCTime && nu.tag !== TAG.GeneralizedTime) return false;
1046
- if (parsePreciseTime(nu).date.getTime() < now.getTime()) return false;
1047
- i++;
1048
- const serial = intValue(c.serial);
1049
- const revoked = f[i];
1050
- if (revoked?.tag === TAG.SEQUENCE) {
1051
- for (const e of children(revoked)) {
1052
- if (intValue(expect(children(e)[0], TAG.INTEGER, "serial").value) === serial) return false;
1053
- }
1054
- }
1055
- return true;
1056
- } catch {
1057
- return false;
1058
- }
1236
+ const crl = parseCRL(der2);
1237
+ if (!crl || !await crlFor(crl, c, issuer)) return false;
1238
+ if (crlListed(crl, c)) throw new CertificateRevokedError();
1239
+ const n = fromDate(now);
1240
+ return !isZero(crl.nextUpdate) && freshAt(crl.thisUpdate, crl.nextUpdate, n, n);
1059
1241
  }
1060
1242
  async function collectLTV(f, now, fresh, roots, chains) {
1061
1243
  const d = { certs: [], ocsps: [], crls: [] };
@@ -1077,7 +1259,7 @@ async function collectLTV(f, now, fresh, roots, chains) {
1077
1259
  seen.add(k);
1078
1260
  addTo(d.certs, c.raw);
1079
1261
  const issuer = await issuerOf(c);
1080
- if (!issuer) throw new LTVError(`${c.subjectCN}-\u0438\u0439\u043D \u043E\u043B\u0433\u043E\u0433\u0447 \u043E\u043B\u0434\u0441\u043E\u043D\u0433\u04AF\u0439`);
1262
+ if (!issuer) throw new LTVError(`\u0433\u0438\u043D\u0436\u0438\u0439\u043D \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D\u043D\u0438\u0439 \u043E\u043B\u0433\u043E\u0433\u0447 \u043E\u043B\u0434\u0441\u043E\u043D\u0433\u04AF\u0439`);
1081
1263
  let ok = false;
1082
1264
  let freshErr;
1083
1265
  const fr = i === 0 ? fresh : void 0;
@@ -1089,6 +1271,7 @@ async function collectLTV(f, now, fresh, roots, chains) {
1089
1271
  ok = true;
1090
1272
  break;
1091
1273
  } catch (e) {
1274
+ if (e instanceof CertificateRevokedError) throw e;
1092
1275
  if (e instanceof NotFresh) freshErr = e;
1093
1276
  }
1094
1277
  }
@@ -1106,7 +1289,7 @@ async function collectLTV(f, now, fresh, roots, chains) {
1106
1289
  }
1107
1290
  if (!ok) {
1108
1291
  if (freshErr) throw freshErr;
1109
- throw new LTVError(`${c.subjectCN}-\u0434 \u0445\u04AF\u0447\u0438\u043D\u0442\u044D\u0439 OCSP/CRL \u0430\u043B\u0433\u0430`);
1292
+ throw new LTVError(`\u0433\u0438\u043D\u0436\u0438\u0439\u043D \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D\u043D\u0434 \u0445\u04AF\u0447\u0438\u043D\u0442\u044D\u0439 OCSP/CRL \u0430\u043B\u0433\u0430`);
1110
1293
  }
1111
1294
  if (i === 0 && freshErr && c.ocspServers.length > 0 && !await hasFreshOCSP(d.ocsps, c, issuer, fresh)) throw freshErr;
1112
1295
  }
@@ -1116,7 +1299,7 @@ async function collectLTV(f, now, fresh, roots, chains) {
1116
1299
  async function hasFreshOCSP(list, c, issuer, fresh) {
1117
1300
  for (const der2 of list) {
1118
1301
  try {
1119
- if (after((await parseOCSPForCert(der2, c, issuer)).thisUpdate, fresh)) return true;
1302
+ if (after2((await parseOCSPForCert(der2, c, issuer)).thisUpdate, fresh) && await ocspCertIDMatches(der2, c, issuer)) return true;
1120
1303
  } catch {
1121
1304
  }
1122
1305
  }
@@ -1145,9 +1328,6 @@ async function collectLTVWithWait(f, now, sleep, genTime, roots, chains) {
1145
1328
  }
1146
1329
  }
1147
1330
 
1148
- // src/pades/limits.ts
1149
- var MAX_INPUT_BYTES = (10 << 20) - (256 << 10);
1150
-
1151
1331
  // src/pades/pdf/inflate.ts
1152
1332
  var LEN_BASE = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
1153
1333
  var LEN_EXTRA = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
@@ -1213,23 +1393,25 @@ var InflateError = class extends Error {
1213
1393
  };
1214
1394
  var Truncated = class extends InflateError {
1215
1395
  };
1216
- function zlibInflate(src, limit = 64 << 20) {
1396
+ var InflateLimitError = class extends InflateError {
1397
+ };
1398
+ function zlibInflate(src, limit = 64 << 20, initial) {
1217
1399
  if (src.length < 2) throw new InflateError("zlib: header \u0430\u043B\u0433\u0430");
1218
1400
  const cmf = src[0];
1219
1401
  const flg = src[1];
1220
1402
  if ((cmf & 15) !== 8 || cmf >> 4 > 7 || (cmf << 8 | flg) % 31 !== 0) throw new InflateError("zlib: header \u0431\u0443\u0440\u0443\u0443");
1221
1403
  if (flg & 32) throw new InflateError("zlib: preset dictionary");
1222
- return inflateRaw(src.subarray(2), limit);
1404
+ return inflateRaw(src.subarray(2), limit, void 0, initial);
1223
1405
  }
1224
- function inflateRaw(src, limit = 64 << 20, info) {
1406
+ function inflateRaw(src, limit = 64 << 20, info, initial) {
1225
1407
  let pos = 0;
1226
1408
  let bitBuf = 0;
1227
1409
  let bitCnt = 0;
1228
- let out = new Uint8Array(Math.min(limit, Math.max(1024, src.length * 4)));
1410
+ let out = new Uint8Array(Math.min(limit, Math.max(1024, initial ?? src.length * 4)));
1229
1411
  let len = 0;
1230
1412
  const need = (n) => {
1231
1413
  if (len + n <= out.length) return;
1232
- if (len + n > limit) throw new InflateError("inflate: \u0445\u044D\u043C\u0436\u044D\u044D\u043D\u0438\u0439 \u0445\u044F\u0437\u0433\u0430\u0430\u0440");
1414
+ if (len + n > limit) throw new InflateLimitError("inflate: \u0445\u044D\u043C\u0436\u044D\u044D\u043D\u0438\u0439 \u0445\u044F\u0437\u0433\u0430\u0430\u0440");
1233
1415
  let cap = out.length * 2;
1234
1416
  while (cap < len + n) cap *= 2;
1235
1417
  const nb = new Uint8Array(Math.min(cap, limit));
@@ -2038,28 +2220,17 @@ var Reader = class {
2038
2220
  };
2039
2221
  function findStartXref(b) {
2040
2222
  const end = b.length;
2041
- let searchSize = 200;
2042
- let eofEnd = -1;
2043
- for (; ; ) {
2044
- const from = Math.max(0, end - searchSize);
2045
- if (end - searchSize >= 0) {
2046
- let hi = end;
2047
- while (hi > from && (b[hi - 1] === 10 || b[hi - 1] === 13)) hi--;
2048
- while (hi > from && (b[hi - 1] === 10 || b[hi - 1] === 13 || b[hi - 1] === 9 || b[hi - 1] === 32)) hi--;
2049
- for (; ; ) {
2050
- if (hi - from === 5) break;
2051
- if (hi - from >= 5 && fromLatin1(b, hi - 5, hi) === "%%EOF") {
2052
- eofEnd = hi;
2053
- break;
2054
- }
2055
- if (hi - from < 5) break;
2056
- hi--;
2057
- }
2058
- if (eofEnd >= 0) break;
2223
+ let hi = end;
2224
+ while (hi > 0 && (b[hi - 1] === 10 || b[hi - 1] === 13 || b[hi - 1] === 9 || b[hi - 1] === 32)) hi--;
2225
+ let idx = -1;
2226
+ for (let i2 = hi - 5; i2 >= 0; i2--) {
2227
+ if (b[i2] === 37 && b[i2 + 1] === 37 && b[i2 + 2] === 69 && b[i2 + 3] === 79 && b[i2 + 4] === 70) {
2228
+ idx = i2;
2229
+ break;
2059
2230
  }
2060
- searchSize += 200;
2061
- if (searchSize > end) throw new PdfError("not a PDF file: missing %%EOF");
2062
2231
  }
2232
+ if (idx < 0 || 200 * (Math.floor((end - idx) / 200) + 1) > end) throw new PdfError("not a PDF file: missing %%EOF");
2233
+ const eofEnd = idx + 5;
2063
2234
  const winStart = eofEnd - 200;
2064
2235
  if (winStart < 0) throw new PdfError("malformed PDF file: missing final startxref");
2065
2236
  const buf = b.subarray(winStart, eofEnd);
@@ -2073,13 +2244,342 @@ function findLastLine(buf, s) {
2073
2244
  for (; ; ) {
2074
2245
  const i = str.lastIndexOf(s, max - s.length);
2075
2246
  if (i <= 0 || i + s.length >= buf.length) return -1;
2076
- const before = buf[i - 1];
2077
- const after2 = buf[i + s.length];
2078
- if ((before === 10 || before === 13) && (after2 === 10 || after2 === 13)) return i;
2247
+ const before2 = buf[i - 1];
2248
+ const after3 = buf[i + s.length];
2249
+ if ((before2 === 10 || before2 === 13) && (after3 === 10 || after3 === 13)) return i;
2079
2250
  max = i;
2080
2251
  }
2081
2252
  }
2082
2253
 
2254
+ // src/pades/pdf/nesting.ts
2255
+ var MAX_NESTING = 256;
2256
+ var NEST_SCAN_FACTOR = 16;
2257
+ var MAX_OBJSTM_BYTES = 32 << 20;
2258
+ var MAX_XREF_SIZE = 1 << 21;
2259
+ var MAX_OBJSTM_CHAIN = 64;
2260
+ var StructureError = class extends Error {
2261
+ constructor() {
2262
+ super("PDF-\u0438\u0439\u043D \u0431\u04AF\u0442\u044D\u0446 \u0445\u044D\u0442 \u0433\u04AF\u043D \u0434\u0430\u0432\u0445\u0430\u0440\u043B\u0430\u0441\u0430\u043D \u044D\u0441\u0432\u044D\u043B \u0445\u044D\u0442 \u0442\u04E9\u0432\u04E9\u0433\u0442\u044D\u0439");
2263
+ this.name = "StructureError";
2264
+ }
2265
+ };
2266
+ var ENCRYPT_REF = /\/Encrypt(?:[\t\n\f\r ]+\d+[\t\n\f\r ]+\d+[\t\n\f\r ]+R|[\t\n\f\r ]*<<)/;
2267
+ var isSpace2 = (c) => c === 0 || c === 9 || c === 10 || c === 12 || c === 13 || c === 32;
2268
+ var isDelim2 = (c) => c === 40 || c === 41 || c === 60 || c === 62 || c === 91 || c === 93 || c === 123 || c === 125 || c === 47 || c === 37;
2269
+ var INT_RE = /^[+-]?\d+$/;
2270
+ var INT64_MAX = 9223372036854775807n;
2271
+ var isInt = (s) => INT_RE.test(s) && BigInt(s) <= INT64_MAX && BigInt(s) >= -INT64_MAX - 1n;
2272
+ function parseInt64(s) {
2273
+ if (!INT_RE.test(s)) return 0;
2274
+ const v = BigInt(s);
2275
+ if (v > INT64_MAX) return Number(INT64_MAX);
2276
+ if (v < -INT64_MAX - 1n) return -Number(INT64_MAX) - 1;
2277
+ return Number(v);
2278
+ }
2279
+ var Lex = class {
2280
+ constructor(b, pos) {
2281
+ this.b = b;
2282
+ this.pos = pos;
2283
+ }
2284
+ b;
2285
+ pos;
2286
+ val = "";
2287
+ next() {
2288
+ const b = this.b;
2289
+ for (; ; ) {
2290
+ while (this.pos < b.length && isSpace2(b[this.pos])) this.pos++;
2291
+ if (this.pos < b.length && b[this.pos] === 37) {
2292
+ while (this.pos < b.length && b[this.pos] !== 13 && b[this.pos] !== 10) this.pos++;
2293
+ continue;
2294
+ }
2295
+ break;
2296
+ }
2297
+ if (this.pos >= b.length) return 0 /* EOF */;
2298
+ const c = b[this.pos++];
2299
+ switch (c) {
2300
+ case 60:
2301
+ if (this.pos < b.length && b[this.pos] === 60) {
2302
+ this.pos++;
2303
+ return 4 /* Dict */;
2304
+ }
2305
+ while (this.pos < b.length && b[this.pos] !== 62) this.pos++;
2306
+ this.pos++;
2307
+ return 8 /* Str */;
2308
+ case 40:
2309
+ for (let depth = 1; this.pos < b.length && depth > 0; this.pos++) {
2310
+ const x = b[this.pos];
2311
+ if (x === 40) depth++;
2312
+ else if (x === 41) depth--;
2313
+ else if (x === 92) this.pos++;
2314
+ }
2315
+ return 8 /* Str */;
2316
+ case 91:
2317
+ return 2 /* Arr */;
2318
+ case 93:
2319
+ return 3 /* ArrEnd */;
2320
+ case 123:
2321
+ case 125:
2322
+ this.val = String.fromCharCode(c);
2323
+ return 7 /* Word */;
2324
+ case 47: {
2325
+ let name = "";
2326
+ while (this.pos < b.length && !isDelim2(b[this.pos]) && !isSpace2(b[this.pos])) {
2327
+ if (b[this.pos] === 35 && this.pos + 2 < b.length) {
2328
+ const hx = String.fromCharCode(b[this.pos + 1], b[this.pos + 2]);
2329
+ if (/^[0-9a-fA-F]{2}$/.test(hx)) {
2330
+ name += String.fromCharCode(parseInt(hx, 16));
2331
+ this.pos += 3;
2332
+ continue;
2333
+ }
2334
+ }
2335
+ name += String.fromCharCode(b[this.pos]);
2336
+ this.pos++;
2337
+ }
2338
+ this.val = name;
2339
+ return 6 /* Name */;
2340
+ }
2341
+ case 62:
2342
+ if (this.pos < b.length && b[this.pos] === 62) {
2343
+ this.pos++;
2344
+ return 5 /* DictEnd */;
2345
+ }
2346
+ return 1 /* Err */;
2347
+ case 41:
2348
+ return 1 /* Err */;
2349
+ }
2350
+ const start = this.pos - 1;
2351
+ while (this.pos < b.length && !isDelim2(b[this.pos]) && !isSpace2(b[this.pos])) this.pos++;
2352
+ this.val = fromLatin1(b, start, this.pos);
2353
+ return 7 /* Word */;
2354
+ }
2355
+ };
2356
+ var Scan = class {
2357
+ constructor(budget, inflateLeft, encrypted2) {
2358
+ this.budget = budget;
2359
+ this.inflateLeft = inflateLeft;
2360
+ this.encrypted = encrypted2;
2361
+ }
2362
+ budget;
2363
+ inflateLeft;
2364
+ encrypted;
2365
+ /** Дээд түвшний /Size > MAX_XREF_SIZE. */
2366
+ bigSize = false;
2367
+ /** b[start:]-аас reader-ийн нэг объектыг (давхар `N G obj`-ийг оруулаад) гүнээр шалгана. */
2368
+ object(b, start, allowStream) {
2369
+ const l = new Lex(b, start);
2370
+ try {
2371
+ this.objectBody(l, start, allowStream);
2372
+ } finally {
2373
+ this.budget -= l.pos - start;
2374
+ }
2375
+ }
2376
+ objectBody(l, start, allowStream) {
2377
+ const stack = [];
2378
+ const info = { typ: "", filter: "", filters: 0, parms: false, indirect: false, first: 0, nCount: 0 };
2379
+ for (; ; ) {
2380
+ if (this.budget - (l.pos - start) < 0) throw new StructureError();
2381
+ const tok = l.next();
2382
+ const top = stack.length - 1;
2383
+ if (top >= 0 && stack[top].dict && stack[top].expectKey) {
2384
+ if (tok === 5 /* DictEnd */) {
2385
+ stack.pop();
2386
+ if (stack.length === 0) {
2387
+ if (allowStream && (info.typ === "ObjStm" || info.indirect)) this.objStm(l, info);
2388
+ return;
2389
+ }
2390
+ const p = stack[stack.length - 1];
2391
+ p.expectKey = p.dict;
2392
+ continue;
2393
+ }
2394
+ if (tok === 6 /* Name */) {
2395
+ stack[top].key = l.val;
2396
+ stack[top].expectKey = false;
2397
+ continue;
2398
+ }
2399
+ return;
2400
+ }
2401
+ let done = false;
2402
+ switch (tok) {
2403
+ case 0 /* EOF */:
2404
+ case 1 /* Err */:
2405
+ case 5 /* DictEnd */:
2406
+ return;
2407
+ case 2 /* Arr */:
2408
+ case 4 /* Dict */:
2409
+ if (stack.length >= MAX_NESTING) throw new StructureError();
2410
+ if (stack.length === 1 && stack[0].dict && stack[0].key === "DecodeParms") info.parms = true;
2411
+ stack.push({ dict: tok === 4 /* Dict */, expectKey: tok === 4 /* Dict */, key: "" });
2412
+ continue;
2413
+ case 3 /* ArrEnd */:
2414
+ if (top < 0 || stack[top].dict) return;
2415
+ stack.pop();
2416
+ break;
2417
+ case 7 /* Word */:
2418
+ if (isInt(l.val)) {
2419
+ const save = l.pos;
2420
+ const saveVal = l.val;
2421
+ if (l.next() === 7 /* Word */ && isInt(l.val)) {
2422
+ const t3 = l.next();
2423
+ if (t3 === 7 /* Word */ && l.val === "R") {
2424
+ if (stack.length === 1 && stack[0].dict && ["Type", "Filter", "DecodeParms", "N", "First"].includes(stack[0].key)) info.indirect = true;
2425
+ done = true;
2426
+ } else if (t3 === 7 /* Word */ && l.val === "obj") {
2427
+ continue;
2428
+ }
2429
+ }
2430
+ if (!done) {
2431
+ l.pos = save;
2432
+ l.val = saveVal;
2433
+ }
2434
+ }
2435
+ if (!done) this.noteScalar(stack, info, tok, l.val);
2436
+ break;
2437
+ case 6 /* Name */:
2438
+ case 8 /* Str */:
2439
+ this.noteScalar(stack, info, tok, l.val);
2440
+ break;
2441
+ }
2442
+ if (stack.length === 0) return;
2443
+ const f = stack[stack.length - 1];
2444
+ if (f.dict) f.expectKey = true;
2445
+ }
2446
+ }
2447
+ /** Дээд түвшний толийн (ба /Filter массивын) энгийн утгыг тэмдэглэнэ. */
2448
+ noteScalar(stack, info, tok, val) {
2449
+ if (stack.length === 1 && stack[0].dict) {
2450
+ switch (stack[0].key) {
2451
+ case "Type":
2452
+ if (tok === 6 /* Name */) info.typ = val;
2453
+ break;
2454
+ case "Filter":
2455
+ if (tok === 6 /* Name */) {
2456
+ info.filter = val;
2457
+ info.filters = 1;
2458
+ }
2459
+ break;
2460
+ case "DecodeParms":
2461
+ if (!(tok === 7 /* Word */ && val === "null")) info.parms = true;
2462
+ break;
2463
+ case "N":
2464
+ info.nCount = parseInt64(val);
2465
+ break;
2466
+ case "Size":
2467
+ if (tok === 7 /* Word */ && isInt(val) && BigInt(val) > BigInt(MAX_XREF_SIZE)) this.bigSize = true;
2468
+ break;
2469
+ case "First":
2470
+ info.first = parseInt64(val);
2471
+ break;
2472
+ }
2473
+ } else if (stack.length === 2 && stack[0].dict && stack[0].key === "Filter" && !stack[1].dict && tok === 6 /* Name */) {
2474
+ info.filter = val;
2475
+ info.filters++;
2476
+ }
2477
+ }
2478
+ /** `stream`-ийн араас FlateDecode өгөгдлийг (zlib өөрөө төгсөнө) задалж, толгойн offset бүрээс объектыг шалгана. */
2479
+ objStm(l, info) {
2480
+ if (l.next() !== 7 /* Word */ || l.val !== "stream" || this.encrypted) return;
2481
+ if (info.indirect) throw new StructureError();
2482
+ if (info.typ !== "ObjStm") return;
2483
+ const b = l.b;
2484
+ let p = l.pos;
2485
+ if (p < b.length && b[p] === 13) p++;
2486
+ if (p < b.length && b[p] === 10) p++;
2487
+ if (info.filters === 0) {
2488
+ this.objStmData(b.subarray(p), info);
2489
+ return;
2490
+ }
2491
+ if (info.filters !== 1 || info.filter !== "FlateDecode") return;
2492
+ if (info.parms) throw new StructureError();
2493
+ let data;
2494
+ try {
2495
+ data = zlibInflate(b.subarray(p), this.inflateLeft, 64 << 10);
2496
+ } catch (e) {
2497
+ if (e instanceof InflateLimitError) throw new StructureError();
2498
+ return;
2499
+ }
2500
+ this.inflateLeft -= data.length;
2501
+ this.budget -= data.length;
2502
+ this.objStmData(data, info);
2503
+ }
2504
+ objStmData(data, info) {
2505
+ const l = new Lex(data, 0);
2506
+ for (let i = 0; i < info.nCount; i++) {
2507
+ if (l.next() === 0 /* EOF */) break;
2508
+ if (l.next() !== 7 /* Word */) continue;
2509
+ if (!isInt(l.val)) continue;
2510
+ const off = parseInt64(l.val);
2511
+ if (info.first < 0 || off < 0 || info.first + off >= data.length) continue;
2512
+ if (this.budget < 0) throw new StructureError();
2513
+ this.object(data, info.first + off, false);
2514
+ }
2515
+ if (this.budget < 0) throw new StructureError();
2516
+ }
2517
+ };
2518
+ function checkStructure(doc) {
2519
+ const text = fromLatin1(doc);
2520
+ const s = new Scan(NEST_SCAN_FACTOR * doc.length + (1 << 20), MAX_OBJSTM_BYTES, ENCRYPT_REF.test(text));
2521
+ for (const kw of ["obj", "trailer"]) {
2522
+ for (let i = 0; ; ) {
2523
+ const k = text.indexOf(kw, i);
2524
+ if (k < 0) break;
2525
+ const at = k + kw.length;
2526
+ i = at;
2527
+ if (k > 0 && !isSpace2(doc[k - 1]) && !isDelim2(doc[k - 1]) || at < doc.length && !isSpace2(doc[at]) && !isDelim2(doc[at])) continue;
2528
+ s.object(doc, at, true);
2529
+ }
2530
+ }
2531
+ if (s.bigSize) throw new StructureError();
2532
+ checkObjStmGraph(doc);
2533
+ }
2534
+ function checkObjStmGraph(doc) {
2535
+ let r;
2536
+ try {
2537
+ r = new Reader(doc);
2538
+ } catch {
2539
+ return;
2540
+ }
2541
+ const xr = r.xref;
2542
+ const registered = (p) => p.id < xr.length && xr[p.id].ptr.id === p.id && xr[p.id].ptr.gen === p.gen;
2543
+ const inStream = (p) => registered(p) && xr[p.id].inStream;
2544
+ const containers = /* @__PURE__ */ new Map();
2545
+ for (const e of xr) {
2546
+ if (!e.inStream) continue;
2547
+ if (inStream(e.stream)) throw new StructureError();
2548
+ containers.set(`${e.stream.id} ${e.stream.gen}`, e.stream);
2549
+ }
2550
+ for (const c of containers.values()) {
2551
+ const seen = /* @__PURE__ */ new Set();
2552
+ for (let p = c; registered(p); ) {
2553
+ const k = `${p.id} ${p.gen}`;
2554
+ if (seen.has(k) || seen.size > MAX_OBJSTM_CHAIN) throw new StructureError();
2555
+ seen.add(k);
2556
+ let v;
2557
+ try {
2558
+ const e = xr[p.id].ptr;
2559
+ v = r.resolve(e, new PRef(e.id, e.gen)).data;
2560
+ } catch {
2561
+ return;
2562
+ }
2563
+ if (!(v instanceof PStream)) break;
2564
+ let bad = false;
2565
+ walkRefs(v.hdr, 0, (x) => bad ||= inStream(x));
2566
+ if (bad) throw new StructureError();
2567
+ const ext = v.hdr.get("Extends");
2568
+ if (!(ext instanceof PRef)) break;
2569
+ p = { id: ext.id, gen: ext.gen };
2570
+ }
2571
+ }
2572
+ }
2573
+ function walkRefs(v, depth, fn) {
2574
+ if (depth > MAX_NESTING) return;
2575
+ if (v instanceof PRef) fn({ id: v.id, gen: v.gen });
2576
+ else if (v instanceof Map) for (const x of v.values()) walkRefs(x, depth + 1, fn);
2577
+ else if (Array.isArray(v)) for (const x of v) walkRefs(x, depth + 1, fn);
2578
+ }
2579
+
2580
+ // src/pades/limits.ts
2581
+ var MAX_INPUT_BYTES = (10 << 20) - (256 << 10);
2582
+
2083
2583
  // src/pades/pdf/serialize.ts
2084
2584
  var MAX_DEPTH = 32;
2085
2585
  function serialize(v, container, depth = 0) {
@@ -3302,7 +3802,7 @@ var PrecheckError = class extends Error {
3302
3802
  }
3303
3803
  code;
3304
3804
  };
3305
- var ENCRYPT_KEY = /\/Encrypt\s+\d+\s+\d+\s+R/;
3805
+ var ENCRYPT_KEY = /\/Encrypt(?:\s+\d+\s+\d+\s+R|\s*<<)/;
3306
3806
  function openReader(doc) {
3307
3807
  try {
3308
3808
  return new Reader(doc);
@@ -3543,7 +4043,9 @@ var PadesError = class extends EidError {
3543
4043
  if (options?.cause !== void 0) this.cause = options.cause;
3544
4044
  }
3545
4045
  code;
4046
+ /** TSA_UNAVAILABLE / LTV_UNAVAILABLE — гэхдээ гэрчилгээ цуцлагдсан (`cause` нь {@link CertificateRevokedError}) бол үгүй. */
3546
4047
  get retryable() {
4048
+ if (this.cause instanceof CertificateRevokedError) return false;
3547
4049
  return this.code === "TSA_UNAVAILABLE" || this.code === "LTV_UNAVAILABLE";
3548
4050
  }
3549
4051
  };
@@ -3620,6 +4122,11 @@ async function prepare(pdf, opts) {
3620
4122
  const doc = u8(pdf, "pdf");
3621
4123
  if (doc.length > MAX_INPUT_BYTES) throw new PadesError("PDF_TOO_LARGE", "PDF 9.75 MB-\u0430\u0430\u0441 \u0438\u0445 \u0431\u0430\u0439\u043D\u0430");
3622
4124
  if (doc.length < 5 || String.fromCharCode(...doc.subarray(0, 5)) !== "%PDF-") throw new PadesError("PDF_INVALID", "PDF \u0431\u0438\u0448 \u044D\u0441\u0432\u044D\u043B \u044D\u0432\u0434\u044D\u0440\u0441\u044D\u043D");
4125
+ try {
4126
+ checkStructure(doc);
4127
+ } catch (e) {
4128
+ throw new PadesError("PDF_INVALID", "PDF-\u0438\u0439\u043D \u0431\u04AF\u0442\u044D\u0446 \u0445\u044D\u0442 \u0433\u04AF\u043D \u044D\u0441\u0432\u044D\u043B \u0442\u04E9\u0432\u04E9\u0433\u0442\u044D\u0439", { cause: e });
4129
+ }
3623
4130
  let cert;
3624
4131
  try {
3625
4132
  cert = parseCertificate(u8(opts.signerCert, "signerCert"));
@@ -3790,6 +4297,15 @@ async function complete(state, signature, opts = {}) {
3790
4297
  let chain;
3791
4298
  try {
3792
4299
  st = await decodeState(u8(state, "state"));
4300
+ } catch (e) {
4301
+ throw new PadesError("STATE_INVALID", "state \u0437\u0430\u0434\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439", { cause: e });
4302
+ }
4303
+ try {
4304
+ checkStructure(st.pdf);
4305
+ } catch (e) {
4306
+ throw new PadesError("STATE_INVALID", "state-\u0438\u0439\u043D PDF-\u0438\u0439\u043D \u0431\u04AF\u0442\u044D\u0446 \u0445\u044D\u0442 \u0433\u04AF\u043D \u044D\u0441\u0432\u044D\u043B \u0442\u04E9\u0432\u04E9\u0433\u0442\u044D\u0439", { cause: e });
4307
+ }
4308
+ try {
3793
4309
  cert = parseCertificate(st.signerCert);
3794
4310
  chain = st.chain.map((c) => parseCertificate(c));
3795
4311
  } catch (e) {
@@ -3844,6 +4360,7 @@ async function complete(state, signature, opts = {}) {
3844
4360
  break;
3845
4361
  } catch (e) {
3846
4362
  throwIfAborted(signal);
4363
+ if (e instanceof CertificateRevokedError) throw new PadesError("LTV_UNAVAILABLE", "\u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D \u0446\u0443\u0446\u043B\u0430\u0433\u0434\u0441\u0430\u043D", { cause: e });
3847
4364
  if (attempt >= ltvRetries) {
3848
4365
  throw new PadesError("LTV_UNAVAILABLE", `OCSP/CRL \u0431\u04AF\u0440\u044D\u043D \u0430\u0432\u0447 \u0447\u0430\u0434\u0441\u0430\u043D\u0433\u04AF\u0439${e instanceof LTVError ? ": " + e.message : ""}`, { cause: e });
3849
4366
  }
@@ -3885,6 +4402,7 @@ async function complete(state, signature, opts = {}) {
3885
4402
  }
3886
4403
  // Annotate the CommonJS export names for ESM import in node:
3887
4404
  0 && (module.exports = {
4405
+ CertificateRevokedError,
3888
4406
  PADES_ERROR_CODES,
3889
4407
  PROFILE_VERSION,
3890
4408
  PadesError,