@gerege-systems/eid-mongolia-sdk 0.20.1 → 0.21.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/README.md +17 -3
- package/bin/convert-assets.mjs +27 -1
- package/dist/browser.js +1 -1
- package/dist/{chunk-JV4NR4LG.js → chunk-ISTWNY6N.js} +460 -39
- package/dist/{chunk-J7EG3VNQ.js → chunk-T3QLOY6J.js} +369 -50
- package/dist/{chunk-D5NPS7ET.js → chunk-ZB7LEWA5.js} +1 -1
- package/dist/convert.js +16 -25
- package/dist/index.cjs +61 -4
- package/dist/index.d.cts +5 -2
- package/dist/index.d.ts +5 -2
- package/dist/index.js +6 -2
- package/dist/pades.cjs +589 -71
- package/dist/pades.d.cts +7 -1
- package/dist/pades.d.ts +7 -1
- package/dist/pades.js +24 -4
- package/dist/validate.cjs +663 -284
- package/dist/validate.js +101 -430
- package/package.json +2 -2
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
|
|
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
|
|
1203
|
+
let nextUpdatePrecise;
|
|
1003
1204
|
for (const x of single.slice(3)) {
|
|
1004
|
-
if (x.tag === 160)
|
|
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 (
|
|
1025
|
-
if (
|
|
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
|
-
|
|
1030
|
-
|
|
1031
|
-
|
|
1032
|
-
|
|
1033
|
-
|
|
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(
|
|
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(
|
|
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 (
|
|
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
|
-
|
|
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
|
|
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
|
|
2042
|
-
|
|
2043
|
-
|
|
2044
|
-
|
|
2045
|
-
if (
|
|
2046
|
-
|
|
2047
|
-
|
|
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
|
|
2077
|
-
const
|
|
2078
|
-
if ((
|
|
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
|
|
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,
|