This commit is contained in:
github-actions[bot]
2026-11-11 17:57:22 +00:00
parent d73325020b
commit a65b1af1c3

742
lib/entry-points.js generated
View File

@@ -34203,6 +34203,33 @@ var require_constants6 = __commonJS({
9007199254740991;
var MAX_SAFE_COMPONENT_LENGTH = 16;
var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
var WHITESPACE_CHARACTERS = [
" ",
"\n",
"\v",
"\f",
"\r",
" ",
"\xA0",
"\u1680",
"\u2000",
"\u2001",
"\u2002",
"\u2003",
"\u2004",
"\u2005",
"\u2006",
"\u2007",
"\u2008",
"\u2009",
"\u200A",
"\u2028",
"\u2029",
"\u202F",
"\u205F",
"\u3000",
"\uFEFF"
];
var RELEASE_TYPES = [
"major",
"premajor",
@@ -34217,6 +34244,7 @@ var require_constants6 = __commonJS({
MAX_SAFE_COMPONENT_LENGTH,
MAX_SAFE_BUILD_LENGTH,
MAX_SAFE_INTEGER,
WHITESPACE_CHARACTERS,
RELEASE_TYPES,
SEMVER_SPEC_VERSION,
FLAG_INCLUDE_PRERELEASE: 1,
@@ -35117,6 +35145,197 @@ var require_lrucache = __commonJS({
}
});
// node_modules/semver/internal/trim-comparator-whitespace.js
var require_trim_comparator_whitespace = __commonJS({
"node_modules/semver/internal/trim-comparator-whitespace.js"(exports2, module2) {
"use strict";
var {
MAX_LENGTH,
MAX_SAFE_BUILD_LENGTH,
WHITESPACE_CHARACTERS
} = require_constants6();
var whitespace = new Uint8Array(65536);
for (const char of WHITESPACE_CHARACTERS) {
whitespace[char.charCodeAt(0)] = 1;
}
var isWhitespace = (char) => char !== void 0 && whitespace[char.charCodeAt(0)] === 1;
var isVersionPrefix = (char) => char === "v" || char === "=" || isWhitespace(char);
var isDigit = (char) => char !== void 0 && char >= "0" && char <= "9";
var isLetter = (char) => char !== void 0 && (char >= "a" && char <= "z" || char >= "A" && char <= "Z");
var isIdentifierCharacter = (char) => isDigit(char) || isLetter(char) || char === "-";
var isVersionStart = (char) => isDigit(char) || char === "x" || char === "X" || char === "*";
var findDigitsEndIndex = (range2, start, limit, digitRuns) => {
if (!isDigit(range2[start])) {
return start;
}
if (start >= digitRuns.start && start < digitRuns.end) {
return Math.min(start + limit, digitRuns.end);
}
if (start >= digitRuns.previousStart && start < digitRuns.previousEnd) {
return Math.min(start + limit, digitRuns.previousEnd);
}
let end = start + 1;
while (isDigit(range2[end])) {
end++;
}
digitRuns.previousStart = digitRuns.start;
digitRuns.previousEnd = digitRuns.end;
digitRuns.start = start;
digitRuns.end = end;
return Math.min(start + limit, end);
};
var findVersionNumberEndIndex = (range2, start, loose, digitRuns) => {
if (!loose && range2[start] === "0") {
return start + 1;
}
return findDigitsEndIndex(range2, start, loose ? MAX_LENGTH : MAX_LENGTH + 1, digitRuns);
};
var findPrereleaseIdentifierEndIndex = (range2, start, loose, digitRuns) => {
const digitsEnd = findDigitsEndIndex(range2, start, MAX_LENGTH, digitRuns);
if (isLetter(range2[digitsEnd]) || range2[digitsEnd] === "-") {
let end = digitsEnd + 1;
const limit = end + MAX_SAFE_BUILD_LENGTH;
while (end < limit && isIdentifierCharacter(range2[end])) {
end++;
}
return end;
}
return findVersionNumberEndIndex(range2, start, loose, digitRuns);
};
var findPrereleaseEndIndex = (range2, start, loose, digitRuns) => {
const hyphen = range2[start] === "-";
if (!loose && !hyphen) {
return start;
}
const identifierStart = start + (hyphen ? 1 : 0);
let end = findPrereleaseIdentifierEndIndex(range2, identifierStart, loose, digitRuns);
if (end === identifierStart) {
if (!loose || !hyphen) {
return start;
}
end = findPrereleaseIdentifierEndIndex(range2, start, loose, digitRuns);
}
while (range2[end] === ".") {
const next = findPrereleaseIdentifierEndIndex(range2, end + 1, loose, digitRuns);
if (next === end + 1) {
break;
}
end = next;
}
return end;
};
var findBuildIdentifierEndIndex = (range2, start) => {
let end = start;
while (end - start < MAX_SAFE_BUILD_LENGTH && isIdentifierCharacter(range2[end])) {
end++;
}
return end;
};
var findBuildEndIndex = (range2, start) => {
if (range2[start] !== "+") {
return start;
}
let end = findBuildIdentifierEndIndex(range2, start + 1);
if (end === start + 1) {
return start;
}
while (range2[end] === ".") {
const next = findBuildIdentifierEndIndex(range2, end + 1);
if (next === end + 1) {
break;
}
end = next;
}
return end;
};
var findLooseFullVersionEndIndex = (range2, start, digitRuns) => {
let end = start;
for (let component = 0; component < 3; component++) {
const next = findVersionNumberEndIndex(range2, end, true, digitRuns);
if (next === end) {
return start;
}
end = next;
if (component < 2) {
if (range2[end] !== ".") {
return start;
}
end++;
}
}
const prereleaseEnd = findPrereleaseEndIndex(range2, end, true, digitRuns);
return findBuildEndIndex(range2, prereleaseEnd);
};
var findPartialVersionComponentEndIndex = (range2, start, digitRuns) => {
if (isDigit(range2[start])) {
return findVersionNumberEndIndex(range2, start, false, digitRuns);
}
return isVersionStart(range2[start]) ? start + 1 : start;
};
var findPartialVersionEndIndex = (range2, start, digitRuns) => {
let end = findPartialVersionComponentEndIndex(range2, start, digitRuns);
for (let component = 0; component < 2; component++) {
if (range2[end] !== ".") {
return end;
}
const next = findPartialVersionComponentEndIndex(range2, end + 1, digitRuns);
if (next === end + 1) {
return end;
}
end = next;
}
const prereleaseEnd = findPrereleaseEndIndex(range2, end, false, digitRuns);
return findBuildEndIndex(range2, prereleaseEnd);
};
var findVersionEndIndex = (range2, start, digitRuns) => {
const fullVersionEnd = findLooseFullVersionEndIndex(range2, start, digitRuns);
return fullVersionEnd !== start ? fullVersionEnd : findPartialVersionEndIndex(range2, start, digitRuns);
};
var findRemovableWhitespaceIndex = (range2, matchStart) => {
let position = matchStart;
if (isWhitespace(range2[position])) {
position++;
}
if (range2[position] === "<" || range2[position] === ">") {
position++;
}
if (range2[position] === "=") {
position++;
}
return isWhitespace(range2[position]) ? position : -1;
};
var trimComparatorWhitespace = (range2) => {
let result = "";
let copyFrom = 0;
let cursor = 0;
const digitRuns = { start: -1, end: -1, previousStart: -1, previousEnd: -1 };
while (cursor < range2.length) {
const matchStart = cursor;
if (range2[cursor] === "<" || range2[cursor] === ">") {
cursor++;
} else if (!isVersionPrefix(range2[cursor]) && !isVersionStart(range2[cursor])) {
cursor++;
continue;
}
while (cursor < range2.length && isVersionPrefix(range2[cursor])) {
cursor++;
}
if (!isVersionStart(range2[cursor])) {
continue;
}
const whitespacePosition = findRemovableWhitespaceIndex(range2, matchStart);
if (whitespacePosition !== -1) {
result += range2.slice(copyFrom, whitespacePosition);
copyFrom = whitespacePosition + 1;
}
cursor = findVersionEndIndex(range2, cursor, digitRuns);
}
return result + range2.slice(copyFrom);
};
module2.exports = trimComparatorWhitespace;
}
});
// node_modules/semver/classes/range.js
var require_range = __commonJS({
"node_modules/semver/classes/range.js"(exports2, module2) {
@@ -35198,7 +35417,7 @@ var require_range = __commonJS({
const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
range2 = range2.replace(hr, hyphenReplace(this.options.includePrerelease));
debug6("hyphen replace", range2);
range2 = range2.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
range2 = trimComparatorWhitespace(range2);
debug6("comparator trim", range2);
range2 = range2.replace(re[t.TILDETRIM], tildeTrimReplace);
debug6("tilde trim", range2);
@@ -35268,11 +35487,11 @@ var require_range = __commonJS({
var Comparator = require_comparator();
var debug6 = require_debug();
var SemVer = require_semver();
var trimComparatorWhitespace = require_trim_comparator_whitespace();
var {
safeRe: re,
src,
t,
comparatorTrimReplace,
tildeTrimReplace,
caretTrimReplace
} = require_re();
@@ -115079,7 +115298,7 @@ var require_follow_redirects = __commonJS({
options.headers[headerList[i]] = headerList[i + 1];
}
}
if (!isArray2(options.sensitiveHeaders)) {
if (!Array.isArray(options.sensitiveHeaders)) {
options.sensitiveHeaders = [];
}
if (options.host) {
@@ -115336,9 +115555,6 @@ var require_follow_redirects = __commonJS({
var dot = subdomain.length - domain.length - 1;
return dot > 0 && subdomain[dot] === "." && subdomain.endsWith(domain);
}
function isArray2(value) {
return value instanceof Array;
}
function isString3(value) {
return typeof value === "string" || value instanceof String;
}
@@ -160398,6 +160614,7 @@ var require_pem = __commonJS({
};
pem.decode = function(str) {
var rval = [];
str = String(str);
var messages = _pemMessageScanner(str);
var rHeader = /(?:^|[^\x21-\x7e])([\x21-\x7e]+):\s*([\x21-\x7e\s^:]+)/;
var rCRLF = /\r?\n/;
@@ -167261,6 +167478,14 @@ var require_x509 = __commonJS({
default:
}
}
} else if (e.name === "nameConstraints" && e.id === "2.5.29.30") {
try {
var nc = _readNameConstraints(asn1.fromDer(e.value));
e.permittedSubtrees = nc.permittedSubtrees;
e.excludedSubtrees = nc.excludedSubtrees;
e.unsupportedSubtreeRange = nc.unsupportedSubtreeRange;
} catch (ex) {
}
} else if (e.name === "subjectKeyIdentifier") {
var ev = asn1.fromDer(e.value);
e.subjectKeyIdentifier = forge.util.bytesToHex(ev.value);
@@ -167268,6 +167493,60 @@ var require_x509 = __commonJS({
}
return e;
};
function _readNameConstraints(ev) {
var rval = {
permittedSubtrees: [],
excludedSubtrees: [],
unsupportedSubtreeRange: false
};
if (ev.tagClass !== asn1.Class.UNIVERSAL || ev.type !== asn1.Type.SEQUENCE || !forge.util.isArray(ev.value)) {
throw new Error("Invalid nameConstraints extension.");
}
for (var i = 0; i < ev.value.length; ++i) {
var trees = ev.value[i];
var list;
if (trees.tagClass === asn1.Class.CONTEXT_SPECIFIC && trees.type === 0) {
list = rval.permittedSubtrees;
} else if (trees.tagClass === asn1.Class.CONTEXT_SPECIFIC && trees.type === 1) {
list = rval.excludedSubtrees;
} else {
throw new Error("Invalid nameConstraints extension.");
}
if (!forge.util.isArray(trees.value)) {
throw new Error("Invalid nameConstraints extension.");
}
for (var n = 0; n < trees.value.length; ++n) {
var subtree = trees.value[n];
if (subtree.type !== asn1.Type.SEQUENCE || !forge.util.isArray(subtree.value) || subtree.value.length === 0 || subtree.value[0].tagClass !== asn1.Class.CONTEXT_SPECIFIC) {
throw new Error("Invalid nameConstraints extension.");
}
var gn = subtree.value[0];
var base = {
type: gn.type,
value: gn.value
};
if (gn.type === 4 && forge.util.isArray(gn.value) && gn.value.length === 1 && gn.value[0].type === asn1.Type.SEQUENCE && forge.util.isArray(gn.value[0].value)) {
base.attributes = pki2.RDNAttributesAsArray(gn.value[0]);
}
for (var m = 1; m < subtree.value.length; ++m) {
var bd = subtree.value[m];
if (bd.tagClass === asn1.Class.CONTEXT_SPECIFIC && bd.type === 0) {
base.minimum = asn1.derToInteger(bd.value);
if (base.minimum !== 0) {
rval.unsupportedSubtreeRange = true;
}
} else if (bd.tagClass === asn1.Class.CONTEXT_SPECIFIC && bd.type === 1) {
base.maximum = asn1.derToInteger(bd.value);
rval.unsupportedSubtreeRange = true;
} else {
throw new Error("Invalid nameConstraints extension.");
}
}
list.push(base);
}
}
return rval;
}
pki2.certificationRequestFromAsn1 = function(obj, computeHash) {
var capture = {};
var errors = [];
@@ -168201,6 +168480,382 @@ var require_x509 = __commonJS({
certificate_unknown: "forge.pki.CertificateUnknown",
unknown_ca: "forge.pki.UnknownCertificateAuthority"
};
var _generalNameTypes = {
0: "otherName",
1: "rfc822Name",
2: "dNSName",
3: "x400Address",
4: "directoryName",
5: "ediPartyName",
6: "uniformResourceIdentifier",
7: "iPAddress",
8: "registeredID"
};
var _maxNameConstraintChecks = 1 << 20;
function _getNameConstraints(cert) {
var rval = [];
for (var i = 0; i < cert.extensions.length; ++i) {
var ext2 = cert.extensions[i];
if (ext2.id !== "2.5.29.30") {
continue;
}
var nc;
try {
var value = ext2.value;
if (typeof value === "string") {
value = asn1.fromDer(value);
}
nc = _readNameConstraints(value);
} catch (ex) {
rval.push({ invalid: true });
continue;
}
rval.push({
permitted: _prepareSubtrees(nc.permittedSubtrees),
excluded: _prepareSubtrees(nc.excludedSubtrees)
});
}
return rval;
}
function _prepareSubtrees(subtrees) {
var rval = [];
for (var i = 0; i < subtrees.length; ++i) {
var subtree = subtrees[i];
var st = { type: subtree.type, supported: _isSupportedSubtree(subtree) };
if (st.supported) {
switch (st.type) {
case 1:
var at = subtree.value.lastIndexOf("@");
st.local = at === -1 ? null : subtree.value.substr(0, at);
st.host = subtree.value.substr(at + 1).toLowerCase();
break;
case 2:
case 6:
st.host = subtree.value.toLowerCase();
break;
case 4:
st.attributes = _canonicalAttributes(subtree.attributes);
break;
case 7:
st.value = subtree.value;
break;
}
}
rval.push(st);
}
return rval;
}
function _isSupportedSubtree(subtree) {
if (subtree.minimum && subtree.minimum !== 0 || "maximum" in subtree) {
return false;
}
switch (subtree.type) {
case 1:
case 2:
case 6:
return typeof subtree.value === "string";
case 4:
return forge.util.isArray(subtree.attributes);
case 7:
return typeof subtree.value === "string" && (subtree.value.length === 8 || subtree.value.length === 32);
}
return false;
}
function _canonicalAttributes(attrs) {
var rval = [];
for (var i = 0; i < attrs.length; ++i) {
var value = attrs[i].value;
if (typeof value === "string") {
value = value.replace(/[ \t\n\v\f\r]+/g, " ");
if (value.charAt(0) === " ") {
value = value.substr(1);
}
if (value.charAt(value.length - 1) === " ") {
value = value.substr(0, value.length - 1);
}
value = value.replace(/[A-Z]+/g, function(s) {
return s.toLowerCase();
});
}
rval.push({ type: attrs[i].type, value });
}
return rval;
}
function _isHostName(value) {
if (typeof value !== "string") {
return false;
}
var labels = false;
for (var i = 0; i < value.length; ++i) {
var c = value.charAt(i);
if (/[a-zA-Z0-9_]/.test(c)) {
continue;
}
if (i > 0 && i < value.length - 1) {
if (c === "-") {
continue;
}
var next = value.charAt(i + 1);
if (c === "." && next !== "." && next !== "-" && value.charAt(i - 1) !== "-") {
labels = true;
continue;
}
}
return false;
}
return labels;
}
function _getConstrainedNames(cert, leaf) {
var rval = { names: [], unsupported: {}, types: {} };
var attrs = cert.subject.attributes;
var i;
if (attrs.length > 0) {
_addConstrainedName(rval, 4, attrs);
}
for (i = 0; i < attrs.length; ++i) {
if (attrs[i].type === oids.emailAddress) {
_addConstrainedName(rval, 1, attrs[i].value);
}
}
var hasDnsName = false;
for (i = 0; i < cert.extensions.length; ++i) {
var san = cert.extensions[i];
if (san.id !== "2.5.29.17") {
continue;
}
var altNames = san.altNames || [];
for (var n = 0; n < altNames.length; ++n) {
var altName = altNames[n];
var value = altName.value;
if (altName.type === 2) {
hasDnsName = true;
}
switch (altName.type) {
case 4:
value = null;
if (forge.util.isArray(altName.value) && altName.value.length === 1 && altName.value[0].type === asn1.Type.SEQUENCE && forge.util.isArray(altName.value[0].value)) {
value = pki2.RDNAttributesAsArray(altName.value[0]);
}
break;
case 7:
if (altName.ip) {
value = forge.util.bytesFromIP(altName.ip);
}
break;
}
_addConstrainedName(rval, altName.type, value);
}
}
if (leaf && !hasDnsName) {
for (i = 0; i < attrs.length; ++i) {
if (attrs[i].type === oids.commonName && _isHostName(attrs[i].value)) {
_addConstrainedName(rval, 2, attrs[i].value);
}
}
}
return rval;
}
function _addConstrainedName(names, type, value) {
var name = { type, value };
var ok = false;
names.types[type] = true;
switch (type) {
case 1:
ok = typeof value === "string" && value.lastIndexOf("@") !== -1;
if (ok) {
var at = value.lastIndexOf("@");
name.local = value.substr(0, at);
name.host = value.substr(at + 1).toLowerCase();
}
break;
case 2:
ok = typeof value === "string";
if (ok) {
name.host = value.toLowerCase();
}
break;
case 4:
ok = forge.util.isArray(value);
if (ok) {
name.attributes = _canonicalAttributes(value);
}
break;
case 6:
var m = typeof value === "string" && /^[a-zA-Z][a-zA-Z0-9+.\-]*:\/\/([^\/?#]*)/.exec(value);
if (m) {
var host = m[1].substr(m[1].lastIndexOf("@") + 1);
if (host.charAt(0) === "[") {
name.host = null;
} else {
var colon = host.indexOf(":");
if (colon !== -1) {
host = host.substr(0, colon);
}
name.host = host.toLowerCase();
}
ok = host.length > 0;
}
break;
case 7:
ok = typeof value === "string" && (value.length === 4 || value.length === 16);
break;
}
if (ok) {
names.names.push(name);
} else {
names.unsupported[type] = true;
}
}
function _hostMatchesConstraint(host, base) {
if (base.length === 0) {
return true;
}
if (base.charAt(0) === ".") {
return host.length > base.length && host.substr(host.length - base.length) === base;
}
return host === base;
}
function _nameMatchesConstraint(name, subtree) {
var value = name.host;
var base = subtree.host;
var i;
switch (name.type) {
case 1:
if (subtree.local !== null) {
return (subtree.local === "" || name.local === subtree.local) && value === base;
}
return _hostMatchesConstraint(value, base);
case 2:
if (base.length === 0) {
return true;
}
if (base.charAt(0) === ".") {
return value.length > base.length && value.substr(value.length - base.length) === base;
}
return value === base || value.length > base.length && value.substr(value.length - base.length - 1) === "." + base;
case 6:
return value !== null && _hostMatchesConstraint(value, base);
case 4:
var battrs = subtree.attributes;
var attrs = name.attributes;
if (battrs.length > attrs.length) {
return false;
}
for (i = 0; i < battrs.length; ++i) {
if (battrs[i].type !== attrs[i].type || battrs[i].value !== attrs[i].value) {
return false;
}
}
return true;
case 7:
value = name.value;
base = subtree.value;
if (base.length !== value.length * 2) {
return false;
}
for (i = 0; i < value.length; ++i) {
var mask = base.charCodeAt(value.length + i);
if ((value.charCodeAt(i) & mask) !== (base.charCodeAt(i) & mask)) {
return false;
}
}
return true;
}
return false;
}
function _nameToString(name) {
if (name.type === 4) {
var parts = [];
for (var i = 0; i < name.value.length; ++i) {
var attr = name.value[i];
parts.push((attr.shortName || attr.name || attr.type) + "=" + attr.value);
}
return parts.join(", ");
}
if (name.type === 7) {
return forge.util.bytesToIP(name.value);
}
return name.value;
}
function _checkNameConstraints(cert, constraints, count, leaf, work) {
if (count === 0) {
return null;
}
var subject = _getConstrainedNames(cert, leaf);
var names = subject.names;
var i;
var n;
var k;
var nc;
var subtree;
var typeName;
for (i = 0; i < count && work.checks <= _maxNameConstraintChecks; ++i) {
nc = constraints[i];
work.checks += (names.length + 1) * (nc.invalid ? 1 : nc.permitted.length + nc.excluded.length + 1);
}
if (work.checks > _maxNameConstraintChecks) {
return {
message: "Certificate name constraints require too many checks.",
error: pki2.certificateError.unsupported_certificate
};
}
for (i = 0; i < count; ++i) {
nc = constraints[i];
if (nc.invalid) {
return {
message: "Certificate name constraint could not be parsed.",
error: pki2.certificateError.unsupported_certificate
};
}
var all = nc.permitted.concat(nc.excluded);
for (n = 0; n < all.length; ++n) {
subtree = all[n];
if (subtree.type in subject.unsupported || !subtree.supported && subtree.type in subject.types) {
typeName = _generalNameTypes[subtree.type] || String(subtree.type);
return {
message: "Certificate name constraint of type " + typeName + " is not supported.",
error: pki2.certificateError.unsupported_certificate,
nameType: typeName
};
}
}
}
for (k = 0; k < names.length; ++k) {
var name = names[k];
for (i = 0; i < count; ++i) {
nc = constraints[i];
var found = false;
var matched = false;
for (n = 0; !matched && n < nc.permitted.length; ++n) {
subtree = nc.permitted[n];
if (subtree.type === name.type) {
found = true;
matched = _nameMatchesConstraint(name, subtree);
}
}
if (found && !matched) {
return {
message: "Certificate subject name is not permitted by a name constraint.",
error: pki2.certificateError.bad_certificate,
nameValue: _nameToString(name),
nameType: _generalNameTypes[name.type]
};
}
for (n = 0; n < nc.excluded.length; ++n) {
subtree = nc.excluded[n];
if (subtree.type === name.type && _nameMatchesConstraint(name, subtree)) {
return {
message: "Certificate subject name is excluded by a name constraint.",
error: pki2.certificateError.bad_certificate,
nameValue: _nameToString(name),
nameType: _generalNameTypes[name.type]
};
}
}
}
}
return null;
}
pki2.verifyCertificateChain = function(caStore, chain, options) {
if (typeof options === "function") {
options = { verify: options };
@@ -168212,6 +168867,34 @@ var require_x509 = __commonJS({
if (typeof validityCheckDate === "undefined") {
validityCheckDate = /* @__PURE__ */ new Date();
}
var ncList = [];
var ncCount = [];
var ncWork = { checks: 0 };
var last = certs[certs.length - 1];
if (last && !last.isIssuer(last)) {
var anchors = caStore.getIssuer(last);
anchors = anchors ? forge.util.isArray(anchors) ? anchors.slice() : [anchors] : [];
for (var ai = 0; ai < anchors.length; ++ai) {
var anchorNc = _getNameConstraints(anchors[ai]);
if (anchorNc.length > 0) {
var anchorVerified = false;
try {
anchorVerified = anchors[ai].verify(last);
} catch (ex) {
}
for (var an = 0; anchorVerified && an < anchorNc.length; ++an) {
ncList.push(anchorNc[an]);
}
}
}
}
for (var ci = certs.length - 1; ci >= 0; --ci) {
ncCount[ci] = ncList.length;
var certNc = ci > 0 ? _getNameConstraints(certs[ci]) : [];
for (var cn = 0; cn < certNc.length; ++cn) {
ncList.push(certNc[cn]);
}
}
var first = true;
var error3 = null;
var depth = 0;
@@ -168270,14 +168953,24 @@ var require_x509 = __commonJS({
error: pki2.certificateError.bad_certificate
};
}
if (error3 === null && (first || !cert.isIssuer(cert))) {
error3 = _checkNameConstraints(
cert,
ncList,
ncCount[depth],
first,
ncWork
);
}
if (error3 === null) {
var se = {
keyUsage: true,
basicConstraints: true
basicConstraints: true,
nameConstraints: true
};
for (var i = 0; error3 === null && i < cert.extensions.length; ++i) {
var ext2 = cert.extensions[i];
if (ext2.critical && !(ext2.name in se)) {
if (ext2.critical && (!(ext2.name in se) || ext2.name === "nameConstraints" && ext2.id !== "2.5.29.30")) {
error3 = {
message: "Certificate has an unsupported critical extension.",
error: pki2.certificateError.unsupported_certificate
@@ -169604,6 +170297,16 @@ var require_tls = __commonJS({
});
}
if (client) {
if (msg.compression_method !== tls.CompressionMethod.none) {
return c.error(c, {
message: "Unsupported compression method.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.illegal_parameter
}
});
}
c.session.compressionMethod = msg.compression_method;
} else {
c.session.compressionMethod = tls.CompressionMethod.none;
@@ -170199,7 +170902,7 @@ var require_tls = __commonJS({
b.read -= 4;
var bytes = b.bytes(length + 4);
b.read += 4;
if (type in hsTable[c.entity][c.expect]) {
if (type in hsTable[c.entity][c.expect] && (c.session || c.entity === tls.ConnectionEnd.server)) {
if (c.entity === tls.ConnectionEnd.server && !c.open && !c.fail) {
c.handshaking = true;
c.session = {
@@ -172381,6 +173084,9 @@ var require_ed25519 = __commonJS({
if (unpackneg(q, pk)) {
return -1;
}
if (_isSmallOrder(q)) {
return -1;
}
if (!_isCanonicalSignatureScalar(sm, 32)) {
return -1;
}
@@ -172421,6 +173127,24 @@ var require_ed25519 = __commonJS({
}
return false;
}
function _isSmallOrder(p) {
var i;
var t = new NativeBuffer(32);
var r = [gf(p[0]), gf(p[1]), gf(p[2]), gf(p[3])];
for (i = 0; i < 3; ++i) {
add2(r, r);
}
pack(t, r);
if (t[0] !== 1) {
return false;
}
for (i = 1; i < 32; ++i) {
if (t[i] !== 0) {
return false;
}
}
return true;
}
function modL(r, x) {
var carry, i, j, k;
for (i = 63; i >= 32; --i) {