@estifanos-sh/convex-auth 0.0.1-preview.0

package/dist/server/connection/saml/c14n.js

@@ -0,0 +1,224 @@
+//#region src/server/connection/saml/c14n.ts
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+const CDATA_SECTION_NODE = 4;
+const PROCESSING_INSTRUCTION_NODE = 7;
+const COMMENT_NODE = 8;
+const xmlSpecialToEncodedAttribute = {
+	"&": "&",
+	"<": "&lt;",
+	"\"": "&quot;",
+	"\r": "&#xD;",
+	"\n": "&#xA;",
+	"	": "&#x9;"
+};
+const xmlSpecialToEncodedText = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\r": "&#xD;"
+};
+function encodeSpecialCharactersInAttribute(attributeValue) {
+	return attributeValue.replace(/([&<"\r\n\t])/g, (_str, item) => xmlSpecialToEncodedAttribute[item]);
+}
+function encodeSpecialCharactersInText(text) {
+	return text.replace(/([&<>\r])/g, (_str, item) => xmlSpecialToEncodedText[item]);
+}
+function isElementNode(node) {
+	return node.nodeType === ELEMENT_NODE;
+}
+function isCommentNode(node) {
+	return node.nodeType === COMMENT_NODE;
+}
+function isTextNode(node) {
+	return node.nodeType === TEXT_NODE || node.nodeType === CDATA_SECTION_NODE;
+}
+function prefixScopeKey(prefix, namespaceURI) {
+	return prefix + "\0" + namespaceURI;
+}
+function isPrefixInScope(scope, prefix, namespaceURI) {
+	return scope.has(prefixScopeKey(prefix, namespaceURI));
+}
+function attrCompare(a, b) {
+	if (!a.namespaceURI && b.namespaceURI) return -1;
+	if (!b.namespaceURI && a.namespaceURI) return 1;
+	const left = (a.namespaceURI || "") + a.localName;
+	const right = (b.namespaceURI || "") + b.localName;
+	if (left === right) return 0;
+	return left < right ? -1 : 1;
+}
+function nsCompare(a, b) {
+	return a.prefix.localeCompare(b.prefix);
+}
+function findChildren(node, localName) {
+	const element = node.documentElement || node;
+	const res = [];
+	if (!element.childNodes) return res;
+	for (let i = 0; i < element.childNodes.length; i++) {
+		const child = element.childNodes[i];
+		if (isElementNode(child) && child.localName === localName) res.push(child);
+	}
+	return res;
+}
+function findDirectChildSignature(node) {
+	if (!node.childNodes) return null;
+	for (let i = 0; i < node.childNodes.length; i++) {
+		const child = node.childNodes[i];
+		if (isElementNode(child) && child.localName === "Signature" && child.namespaceURI === "http://www.w3.org/2000/09/xmldsig#") return child;
+	}
+	return null;
+}
+function findAllSignatures(node, matches = []) {
+	if (isElementNode(node) && node.localName === "Signature" && node.namespaceURI === "http://www.w3.org/2000/09/xmldsig#") matches.push(node);
+	if (node.childNodes) for (let i = 0; i < node.childNodes.length; i++) findAllSignatures(node.childNodes[i], matches);
+	return matches;
+}
+function getSignatureValueText(signatureNode) {
+	if (!signatureNode.childNodes) return null;
+	for (let i = 0; i < signatureNode.childNodes.length; i++) {
+		const child = signatureNode.childNodes[i];
+		if (isElementNode(child) && child.localName === "SignatureValue" && child.childNodes) for (let j = 0; j < child.childNodes.length; j++) {
+			const textNode = child.childNodes[j];
+			if (isTextNode(textNode) && typeof textNode.data === "string") return textNode.data;
+		}
+	}
+	return null;
+}
+function exclusiveRenderAttrs(node) {
+	if (isCommentNode(node)) return "";
+	const attrListToRender = [];
+	if (node.attributes) for (let i = 0; i < node.attributes.length; i++) {
+		const attr = node.attributes[i];
+		if (attr.name.indexOf("xmlns") === 0) continue;
+		attrListToRender.push(attr);
+	}
+	attrListToRender.sort(attrCompare);
+	const res = [];
+	for (const attr of attrListToRender) res.push(" ", attr.name, "=\"", encodeSpecialCharactersInAttribute(attr.value), "\"");
+	return res.join("");
+}
+function exclusiveRenderNs(node, scope, defaultNs, defaultNsForPrefix, inclusiveNamespacesPrefixList) {
+	const res = [];
+	let newDefaultNs = defaultNs;
+	const nsListToRender = [];
+	const currNs = node.namespaceURI || "";
+	if (node.prefix) {
+		const nodeNs = node.namespaceURI || defaultNsForPrefix[node.prefix] || "";
+		if (!isPrefixInScope(scope, node.prefix, nodeNs)) {
+			nsListToRender.push({
+				prefix: node.prefix,
+				namespaceURI: nodeNs
+			});
+			scope.add(prefixScopeKey(node.prefix, nodeNs));
+		}
+	} else if (defaultNs !== currNs) {
+		newDefaultNs = node.namespaceURI || "";
+		res.push(" xmlns=\"", newDefaultNs, "\"");
+	}
+	if (node.attributes) for (let i = 0; i < node.attributes.length; i++) {
+		const attr = node.attributes[i];
+		if (attr.prefix && !isPrefixInScope(scope, attr.localName, attr.value) && inclusiveNamespacesPrefixList.indexOf(attr.localName) >= 0) {
+			nsListToRender.push({
+				prefix: attr.localName,
+				namespaceURI: attr.value
+			});
+			scope.add(prefixScopeKey(attr.localName, attr.value));
+		}
+		if (attr.prefix && !isPrefixInScope(scope, attr.prefix, attr.namespaceURI || "") && attr.prefix !== "xmlns" && attr.prefix !== "xml") {
+			nsListToRender.push({
+				prefix: attr.prefix,
+				namespaceURI: attr.namespaceURI || ""
+			});
+			scope.add(prefixScopeKey(attr.prefix, attr.namespaceURI || ""));
+		}
+	}
+	nsListToRender.sort(nsCompare);
+	for (const p of nsListToRender) res.push(" xmlns:", p.prefix, "=\"", p.namespaceURI, "\"");
+	return {
+		rendered: res.join(""),
+		newDefaultNs
+	};
+}
+function exclusiveProcessInner(node, scope, defaultNs, defaultNsForPrefix, inclusiveNamespacesPrefixList) {
+	if (isCommentNode(node)) return "";
+	if (isTextNode(node)) return encodeSpecialCharactersInText(node.data || "");
+	if (node.nodeType === PROCESSING_INSTRUCTION_NODE) return "";
+	if (isElementNode(node)) {
+		const ns = exclusiveRenderNs(node, scope, defaultNs, defaultNsForPrefix, inclusiveNamespacesPrefixList);
+		const nodeTag = node.tagName || node.nodeName;
+		const res = [
+			"<",
+			nodeTag,
+			ns.rendered,
+			exclusiveRenderAttrs(node),
+			">"
+		];
+		if (node.childNodes) for (let i = 0; i < node.childNodes.length; i++) {
+			const pfxCopy = new Set(scope);
+			res.push(exclusiveProcessInner(node.childNodes[i], pfxCopy, ns.newDefaultNs, defaultNsForPrefix, inclusiveNamespacesPrefixList));
+		}
+		res.push("</", nodeTag, ">");
+		return res.join("");
+	}
+	throw new Error(`Unable to exclusive canonicalize node type: ${node.nodeType}`);
+}
+function exclusiveProcess(elem, options = {}) {
+	let inclusiveNamespacesPrefixList = options.inclusiveNamespacesPrefixList || [];
+	const defaultNs = options.defaultNs || "";
+	const defaultNsForPrefix = options.defaultNsForPrefix || {};
+	const ancestorNamespaces = options.ancestorNamespaces || [];
+	if (inclusiveNamespacesPrefixList.length === 0) {
+		const canonicalizationMethod = findChildren(elem, "CanonicalizationMethod");
+		if (canonicalizationMethod.length !== 0) {
+			const inclusiveNamespaces = findChildren(canonicalizationMethod[0], "InclusiveNamespaces");
+			if (inclusiveNamespaces.length !== 0 && inclusiveNamespaces[0].getAttribute) inclusiveNamespacesPrefixList = (inclusiveNamespaces[0].getAttribute("PrefixList") || "").split(" ").filter(Boolean);
+		}
+	}
+	if (inclusiveNamespacesPrefixList.length > 0) inclusiveNamespacesPrefixList.forEach((prefix) => {
+		ancestorNamespaces.forEach((ancestorNamespace) => {
+			if (prefix === ancestorNamespace.prefix && elem.setAttributeNS) elem.setAttributeNS("http://www.w3.org/2000/xmlns/", `xmlns:${prefix}`, ancestorNamespace.namespaceURI);
+		});
+	});
+	return exclusiveProcessInner(elem, /* @__PURE__ */ new Set(), defaultNs, defaultNsForPrefix, inclusiveNamespacesPrefixList);
+}
+function envelopedSignatureProcess(node, options = {}) {
+	if (options.signatureNode == null) {
+		const signature = findDirectChildSignature(node);
+		if (signature && signature.parentNode && signature.parentNode.removeChild) signature.parentNode.removeChild(signature);
+		return node;
+	}
+	const expectedSignatureValue = getSignatureValueText(options.signatureNode);
+	if (expectedSignatureValue) {
+		const signatures = findAllSignatures(node);
+		for (const nodeSignature of signatures) {
+			const signatureValue = getSignatureValueText(nodeSignature);
+			if (signatureValue && signatureValue === expectedSignatureValue) {
+				if (nodeSignature.parentNode && nodeSignature.parentNode.removeChild) nodeSignature.parentNode.removeChild(nodeSignature);
+			}
+		}
+	}
+	return node;
+}
+const exclusiveCanonicalization = {
+	process: exclusiveProcess,
+	getAlgorithmName: () => "http://www.w3.org/2001/10/xml-exc-c14n#"
+};
+const envelopedSignature = {
+	process: envelopedSignatureProcess,
+	getAlgorithmName: () => "http://www.w3.org/2000/09/xmldsig#enveloped-signature"
+};
+/** XML-dsig transform algorithm URI → its implementation. */
+const TRANSFORM_ALGORITHMS = {
+	"http://www.w3.org/2001/10/xml-exc-c14n#": exclusiveCanonicalization,
+	"http://www.w3.org/2000/09/xmldsig#enveloped-signature": envelopedSignature
+};
+/** Resolve an XML-dsig transform algorithm URI to its implementation. */
+function getTransformByAlgorithm(algorithm) {
+	const transform = TRANSFORM_ALGORITHMS[algorithm];
+	if (transform === void 0) throw new Error(`canonicalization algorithm '${algorithm}' is not supported`);
+	return transform;
+}
+
+//#endregion
+export { getTransformByAlgorithm };
+//# sourceMappingURL=c14n.js.map

package/dist/server/connection/saml/constants.js

@@ -0,0 +1,100 @@
+//#region src/server/connection/saml/constants.ts
+/** SAML 2.0 protocol-binding URIs, keyed by binding short-name. */
+const BINDING_URI = {
+	redirect: "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect",
+	post: "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST",
+	artifact: "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Artifact"
+};
+/** Redirect-binding query-param names carried alongside the message body. */
+const SamlQueryParam = {
+	sigAlg: "SigAlg",
+	signature: "Signature",
+	relayState: "RelayState"
+};
+/** XML element-namespace URIs used when building SAML documents. */
+const SamlNamespace = {
+	protocol: "urn:oasis:names:tc:SAML:2.0:protocol",
+	assertion: "urn:oasis:names:tc:SAML:2.0:assertion",
+	metadata: "urn:oasis:names:tc:SAML:2.0:metadata"
+};
+/** SAML 2.0 NameID-format URIs. */
+const NameIdFormat = {
+	emailAddress: "urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress",
+	persistent: "urn:oasis:names:tc:SAML:2.0:nameid-format:persistent",
+	transient: "urn:oasis:names:tc:SAML:2.0:nameid-format:transient",
+	entity: "urn:oasis:names:tc:SAML:2.0:nameid-format:entity",
+	unspecified: "urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified",
+	kerberos: "urn:oasis:names:tc:SAML:2.0:nameid-format:kerberos",
+	windowsDomainQualifiedName: "urn:oasis:names:tc:SAML:1.1:nameid-format:WindowsDomainQualifiedName",
+	x509SubjectName: "urn:oasis:names:tc:SAML:1.1:nameid-format:X509SubjectName"
+};
+/** The success status-code URI — the only SAML status this library asserts on. */
+const SAML_STATUS_SUCCESS = "urn:oasis:names:tc:SAML:2.0:status:Success";
+/** XML-dsig signature algorithm URIs. */
+const SignatureAlgorithm = {
+	RSA_SHA1: "http://www.w3.org/2000/09/xmldsig#rsa-sha1",
+	RSA_SHA256: "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256"
+};
+/** Bulk-data XML-enc algorithm URIs. */
+const DataEncryptionAlgorithm = {
+	AES_128: "http://www.w3.org/2001/04/xmlenc#aes128-cbc",
+	AES_256: "http://www.w3.org/2001/04/xmlenc#aes256-cbc",
+	AES_128_GCM: "http://www.w3.org/2009/xmlenc11#aes128-gcm"
+};
+/** Key-transport XML-enc algorithm URIs. */
+const KeyEncryptionAlgorithm = { RSA_OAEP_MGF1P: "http://www.w3.org/2001/04/xmlenc#rsa-oaep-mgf1p" };
+/** The digest algorithm URI paired with each signature algorithm URI. */
+const DIGEST_BY_SIGNATURE = {
+	"http://www.w3.org/2000/09/xmldsig#rsa-sha1": "http://www.w3.org/2000/09/xmldsig#sha1",
+	"http://www.w3.org/2001/04/xmldsig-more#rsa-sha256": "http://www.w3.org/2001/04/xmlenc#sha256"
+};
+/** Whether a message is signed-then-encrypted or encrypted-then-signed. */
+const SigningOrder = {
+	SIGN_THEN_ENCRYPT: "sign-then-encrypt",
+	ENCRYPT_THEN_SIGN: "encrypt-then-sign"
+};
+/**
+* Default upper bound (in characters of the received payload) on an inbound
+* `SAMLResponse`, applied when a connection sets no explicit
+* `security.maxResponseSize`. The ACS handler base64-decodes and DOM-parses the
+* response *before* any signature is verified, so an unauthenticated caller
+* could otherwise feed an unbounded document into the parser; this generous cap
+* (~500 KB, far above any legitimate assertion — even encrypted, multi-cert
+* ones) bounds that pre-auth work while staying operator-overridable. A
+* configured non-positive limit disables the cap.
+*/
+const DEFAULT_MAX_SAML_RESPONSE_SIZE = 5e5;
+/**
+* Default upper bound (in characters) on an IdP metadata XML document, applied
+* when a connection sets no explicit `security.maxMetadataSize`. Mirrors
+* {@link DEFAULT_MAX_SAML_RESPONSE_SIZE}: generous enough for any real IdP
+* metadata while bounding parser work against an oversized payload. A configured
+* non-positive limit disables the cap.
+*/
+const DEFAULT_MAX_SAML_METADATA_SIZE = 5e5;
+/** Required child-element ordering of an SPSSODescriptor, per IdP vendor profile. */
+const ElementsOrder = {
+	default: [
+		"KeyDescriptor",
+		"NameIDFormat",
+		"SingleLogoutService",
+		"AssertionConsumerService"
+	],
+	onelogin: [
+		"KeyDescriptor",
+		"NameIDFormat",
+		"SingleLogoutService",
+		"AssertionConsumerService"
+	],
+	shibboleth: [
+		"KeyDescriptor",
+		"SingleLogoutService",
+		"NameIDFormat",
+		"AssertionConsumerService",
+		"AttributeConsumingService"
+	]
+};
+
+//#endregion
+export { BINDING_URI, DEFAULT_MAX_SAML_METADATA_SIZE, DEFAULT_MAX_SAML_RESPONSE_SIZE, DIGEST_BY_SIGNATURE, DataEncryptionAlgorithm, ElementsOrder, KeyEncryptionAlgorithm, NameIdFormat, SAML_STATUS_SUCCESS, SamlNamespace, SamlQueryParam, SignatureAlgorithm, SigningOrder };
+//# sourceMappingURL=constants.js.map

package/dist/server/connection/saml/crypto.js

@@ -0,0 +1,170 @@
+import { decodeBase64, encodeBase64 } from "@oslojs/encoding";
+import { sha1 } from "@noble/hashes/legacy.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+
+//#region src/server/connection/saml/crypto.ts
+const utf8Encoder = new TextEncoder();
+/** Base64-encoded SHA-1 digest of a UTF-8 string. */
+function sha1Base64(text) {
+	return encodeBase64(sha1(utf8Encoder.encode(text)));
+}
+/** Base64-encoded SHA-256 digest of a UTF-8 string. */
+function sha256Base64(text) {
+	return encodeBase64(sha256(utf8Encoder.encode(text)));
+}
+/** Decode a PEM block to its raw DER bytes, stripping the armor and whitespace. */
+function pemToDer(pem) {
+	return decodeBase64(pem.replace(/-----[^-]+-----/g, "").replace(/\s+/g, ""));
+}
+function derToPem(der, label) {
+	const b64 = encodeBase64(der);
+	return `-----BEGIN ${label}-----\n${b64.match(/.{1,64}/g)?.join("\n") ?? b64}\n-----END ${label}-----`;
+}
+function readDerLength(buf, pos) {
+	const first = buf[pos];
+	if (first < 128) return {
+		length: first,
+		consumed: 1
+	};
+	const n = first & 127;
+	let length = 0;
+	for (let i = 0; i < n; i++) length = length << 8 | buf[pos + 1 + i];
+	return {
+		length,
+		consumed: 1 + n
+	};
+}
+function readDerElement(buf, pos) {
+	const { length, consumed } = readDerLength(buf, pos + 1);
+	const valueStart = pos + 1 + consumed;
+	return {
+		value: buf.subarray(valueStart, valueStart + length),
+		end: valueStart + length
+	};
+}
+function derEncodeLength(len) {
+	if (len < 128) return new Uint8Array([len]);
+	if (len < 256) return new Uint8Array([129, len]);
+	return new Uint8Array([
+		130,
+		len >> 8 & 255,
+		len & 255
+	]);
+}
+function concatBytes(...arrays) {
+	const total = arrays.reduce((sum, a) => sum + a.length, 0);
+	const out = new Uint8Array(total);
+	let offset = 0;
+	for (const a of arrays) {
+		out.set(a, offset);
+		offset += a.length;
+	}
+	return out;
+}
+/**
+* Walk a DER-encoded X.509 certificate's TBSCertificate (Certificate SEQUENCE →
+* first element), skipping optional version, serialNumber, signature
+* AlgorithmIdentifier, issuer, validity, and subject to reach and return the
+* SubjectPublicKeyInfo bytes.
+*/
+function extractSpkiFromCert(certPem) {
+	const tbsContent = readDerElement(readDerElement(pemToDer(certPem), 0).value, 0).value;
+	let pos = 0;
+	if (tbsContent[pos] === 160) pos = readDerElement(tbsContent, pos).end;
+	pos = readDerElement(tbsContent, pos).end;
+	pos = readDerElement(tbsContent, pos).end;
+	pos = readDerElement(tbsContent, pos).end;
+	pos = readDerElement(tbsContent, pos).end;
+	pos = readDerElement(tbsContent, pos).end;
+	const spki = readDerElement(tbsContent, pos);
+	return tbsContent.subarray(pos, spki.end);
+}
+const RSA_ALG_ID = new Uint8Array([
+	48,
+	13,
+	6,
+	9,
+	42,
+	134,
+	72,
+	134,
+	247,
+	13,
+	1,
+	1,
+	1,
+	5,
+	0
+]);
+/**
+* Wrap a PKCS#1 `RSA PRIVATE KEY` in a PKCS#8 PrivateKeyInfo structure.
+*
+* Needed because WebCrypto only imports PKCS#8; a key in PKCS#1 form must be
+* converted before {@link crypto.subtle.importKey}.
+*
+* @returns the PKCS#8 DER bytes.
+*/
+function pkcs1ToPkcs8(pkcs1Pem) {
+	const pkcs1 = pemToDer(pkcs1Pem);
+	const octetLen = derEncodeLength(pkcs1.length);
+	const octetString = concatBytes(new Uint8Array([4]), octetLen, pkcs1);
+	const inner = concatBytes(new Uint8Array([
+		2,
+		1,
+		0
+	]), RSA_ALG_ID, octetString);
+	const outerLen = derEncodeLength(inner.length);
+	return concatBytes(new Uint8Array([48]), outerLen, inner);
+}
+function normalizeCertPem(input) {
+	if (input.includes("BEGIN CERTIFICATE")) return input;
+	return `-----BEGIN CERTIFICATE-----\n${input}\n-----END CERTIFICATE-----`;
+}
+async function importSpkiKey(spki, hash) {
+	const copy = new Uint8Array(spki).buffer;
+	return crypto.subtle.importKey("spki", copy, {
+		name: "RSASSA-PKCS1-v1_5",
+		hash
+	}, false, ["verify"]);
+}
+async function importPublicKeyFromCert(certPem, hash) {
+	return importSpkiKey(extractSpkiFromCert(normalizeCertPem(certPem)), hash);
+}
+async function importPrivateKey(privateKeyPem, hash, usages, algo = "RSASSA-PKCS1-v1_5") {
+	let pkcs8;
+	if (privateKeyPem.includes("BEGIN RSA PRIVATE KEY")) pkcs8 = pkcs1ToPkcs8(privateKeyPem);
+	else pkcs8 = pemToDer(privateKeyPem);
+	const copy = new Uint8Array(pkcs8).buffer;
+	return crypto.subtle.importKey("pkcs8", copy, {
+		name: algo,
+		hash
+	}, false, usages);
+}
+/** Sign `data` with an RSASSA-PKCS1-v1_5 private key, returning a base64 signature. */
+async function rsaSign(privateKeyPem, data, hash) {
+	const key = await importPrivateKey(privateKeyPem, hash, ["sign"]);
+	const bytes = utf8Encoder.encode(data);
+	const sig = await crypto.subtle.sign("RSASSA-PKCS1-v1_5", key, bytes);
+	return encodeBase64(new Uint8Array(sig));
+}
+/**
+* Verify an RSASSA-PKCS1-v1_5 signature.
+*
+* @param certOrPubKeyPem an `X509 CERTIFICATE` or `PUBLIC KEY` PEM.
+*/
+async function rsaVerify(certOrPubKeyPem, data, signatureBase64, hash) {
+	let key;
+	if (certOrPubKeyPem.includes("BEGIN CERTIFICATE")) key = await importPublicKeyFromCert(certOrPubKeyPem, hash);
+	else key = await importSpkiKey(pemToDer(certOrPubKeyPem), hash);
+	const sigBytes = new Uint8Array(decodeBase64(signatureBase64.replace(/\s+/g, ""))).buffer;
+	const dataBytes = utf8Encoder.encode(data);
+	return crypto.subtle.verify("RSASSA-PKCS1-v1_5", key, sigBytes, dataBytes);
+}
+/** Extract the SubjectPublicKeyInfo from an X.509 cert as a `PUBLIC KEY` PEM. */
+function getPublicKeyPemFromCert(certPem) {
+	return derToPem(extractSpkiFromCert(normalizeCertPem(certPem)), "PUBLIC KEY");
+}
+
+//#endregion
+export { getPublicKeyPemFromCert, pemToDer, pkcs1ToPkcs8, rsaSign, rsaVerify, sha1Base64, sha256Base64 };
+//# sourceMappingURL=crypto.js.map