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

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

@@ -0,0 +1,294 @@
+import { BINDING_URI, ElementsOrder, NameIdFormat, SamlNamespace } from "./constants.js";
+import { extract } from "./extractor.js";
+import { castArrayOpt, isNonEmptyArray, isString } from "./encoding.js";
+import { createKeySection } from "./signature.js";
+import { buildXml } from "./xml/builder.js";
+
+//#region src/server/connection/saml/metadata.ts
+/**
+* SAML metadata parsing — pure functions, no classes.
+*
+* Replaces the `Metadata` / `IdpMetadata` / `SpMetadata` class hierarchy with
+* two factory functions and explicit interface contracts, matching the HOF
+* pattern used throughout the rest of the library.
+*/
+function isSloService(value) {
+	return typeof value === "object" && value !== null;
+}
+function isAcsService(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* Read a parsed-metadata field as a string. The extractor yields attribute and
+* text values as strings; this preserves the original behavior of returning the
+* raw value (which the accessor contracts type as `string`).
+*/
+function metaString(meta, key) {
+	return meta[key];
+}
+/** Narrow an open metadata value to a record of attributes, or `undefined`. */
+function readRecord(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+function parseBaseFields(xml, extraParse) {
+	const xmlString = xml.toString();
+	const parsed = extract(xmlString, [
+		{
+			key: "entityDescriptor",
+			localPath: ["EntityDescriptor"],
+			attributes: [],
+			context: true
+		},
+		{
+			key: "entityID",
+			localPath: ["EntityDescriptor"],
+			attributes: ["entityID"]
+		},
+		{
+			key: "sharedCertificate",
+			localPath: [
+				"EntityDescriptor",
+				"~SSODescriptor",
+				"KeyDescriptor",
+				"KeyInfo",
+				"X509Data",
+				"X509Certificate"
+			],
+			attributes: []
+		},
+		{
+			key: "certificate",
+			localPath: [
+				"EntityDescriptor",
+				"~SSODescriptor",
+				"KeyDescriptor"
+			],
+			index: ["use"],
+			attributePath: [
+				"KeyInfo",
+				"X509Data",
+				"X509Certificate"
+			],
+			attributes: []
+		},
+		{
+			key: "singleLogoutService",
+			localPath: [
+				"EntityDescriptor",
+				"~SSODescriptor",
+				"SingleLogoutService"
+			],
+			attributes: ["Binding", "Location"]
+		},
+		{
+			key: "nameIDFormat",
+			localPath: [
+				"EntityDescriptor",
+				"~SSODescriptor",
+				"NameIDFormat"
+			],
+			attributes: []
+		},
+		...extraParse
+	]);
+	if (typeof parsed.sharedCertificate === "string") {
+		parsed.certificate = {
+			signing: parsed.sharedCertificate,
+			encryption: parsed.sharedCertificate
+		};
+		delete parsed.sharedCertificate;
+	}
+	if (Array.isArray(parsed.entityDescriptor) && parsed.entityDescriptor.length > 1) throw new Error("ERR_MULTIPLE_METADATA_ENTITYDESCRIPTOR");
+	return {
+		xmlString,
+		meta: parsed
+	};
+}
+function getX509Certificate(meta, use) {
+	const certificate = meta.certificate;
+	if (typeof certificate === "object" && certificate !== null) return certificate[use] ?? null;
+	return null;
+}
+function getNameIDFormat(meta) {
+	return meta.nameIDFormat ?? [];
+}
+function getSingleLogoutService(meta, binding) {
+	if (binding && isString(binding)) {
+		const bindType = BINDING_URI[binding];
+		const raw = meta.singleLogoutService;
+		const service = (Array.isArray(raw) ? raw : raw ? [raw] : []).find((obj) => isSloService(obj) && obj.binding === bindType);
+		if (service) return service.location;
+	}
+	return meta.singleLogoutService;
+}
+/** Parse IdP metadata, or build it from {@link MetadataIdpOptions} when options are given. */
+function parseIdpMetadata(input) {
+	let xmlInput;
+	if (isString(input) || input instanceof Uint8Array) xmlInput = input;
+	else {
+		const { entityID, signingCert, encryptCert, wantAuthnRequestsSigned = false, nameIDFormat = [], singleSignOnService = [], singleLogoutService = [] } = input;
+		const IDPSSODescriptor = [{ _attr: {
+			WantAuthnRequestsSigned: String(wantAuthnRequestsSigned),
+			protocolSupportEnumeration: SamlNamespace.protocol
+		} }];
+		for (const cert of castArrayOpt(signingCert)) IDPSSODescriptor.push({ KeyDescriptor: createKeySection("signing", cert).KeyDescriptor });
+		for (const cert of castArrayOpt(encryptCert)) IDPSSODescriptor.push({ KeyDescriptor: createKeySection("encryption", cert).KeyDescriptor });
+		if (isNonEmptyArray(nameIDFormat)) nameIDFormat.forEach((f) => IDPSSODescriptor.push({ NameIDFormat: f }));
+		if (isNonEmptyArray(singleSignOnService)) singleSignOnService.forEach((a) => {
+			const attr = {
+				Binding: a.Binding,
+				Location: a.Location
+			};
+			if (a.isDefault) attr.isDefault = true;
+			IDPSSODescriptor.push({ SingleSignOnService: [{ _attr: attr }] });
+		});
+		else throw new Error("ERR_IDP_METADATA_MISSING_SINGLE_SIGN_ON_SERVICE");
+		if (isNonEmptyArray(singleLogoutService)) singleLogoutService.forEach((a) => {
+			const attr = {
+				Binding: a.Binding,
+				Location: a.Location
+			};
+			if (a.isDefault) attr.isDefault = true;
+			IDPSSODescriptor.push({ SingleLogoutService: [{ _attr: attr }] });
+		});
+		else console.warn("Construct identity provider - missing endpoint of SingleLogoutService");
+		xmlInput = buildXml([{ EntityDescriptor: [{ _attr: {
+			xmlns: SamlNamespace.metadata,
+			"xmlns:assertion": SamlNamespace.assertion,
+			"xmlns:ds": "http://www.w3.org/2000/09/xmldsig#",
+			entityID
+		} }, { IDPSSODescriptor }] }]);
+	}
+	const { xmlString, meta } = parseBaseFields(xmlInput, [{
+		key: "wantAuthnRequestsSigned",
+		localPath: ["EntityDescriptor", "IDPSSODescriptor"],
+		attributes: ["WantAuthnRequestsSigned"]
+	}, {
+		key: "singleSignOnService",
+		localPath: [
+			"EntityDescriptor",
+			"IDPSSODescriptor",
+			"SingleSignOnService"
+		],
+		index: ["Binding"],
+		attributePath: [],
+		attributes: ["Location"]
+	}]);
+	return {
+		xmlString,
+		getEntityID: () => metaString(meta, "entityID"),
+		getX509Certificate: (use) => getX509Certificate(meta, use),
+		getNameIDFormat: () => getNameIDFormat(meta),
+		getSingleLogoutService: (binding) => getSingleLogoutService(meta, binding),
+		isWantAuthnRequestsSigned: () => {
+			const v = meta.wantAuthnRequestsSigned;
+			return v === "true" || v === true;
+		},
+		getSingleSignOnService: (binding) => {
+			if (isString(binding)) {
+				const bindName = BINDING_URI[binding];
+				const map = meta.singleSignOnService;
+				if (typeof map === "object" && map !== null) {
+					const service = map[bindName];
+					if (service) return service;
+				}
+			}
+			return meta.singleSignOnService;
+		}
+	};
+}
+/** Parse SP metadata, or build it from {@link MetadataSpOptions} when options are given. */
+function parseSpMetadata(input) {
+	let xmlInput;
+	if (isString(input) || input instanceof Uint8Array) xmlInput = input;
+	else {
+		const { elementsOrder = ElementsOrder.default, entityID, signingCert, encryptCert, authnRequestsSigned = false, wantAssertionsSigned = false, wantMessageSigned = false, signatureConfig, nameIDFormat = [], singleLogoutService = [], assertionConsumerService = [] } = input;
+		const descriptors = {
+			KeyDescriptor: [],
+			NameIDFormat: [],
+			SingleLogoutService: [],
+			AssertionConsumerService: [],
+			AttributeConsumingService: []
+		};
+		const SPSSODescriptor = [{ _attr: {
+			AuthnRequestsSigned: String(authnRequestsSigned),
+			WantAssertionsSigned: String(wantAssertionsSigned),
+			protocolSupportEnumeration: SamlNamespace.protocol
+		} }];
+		if (wantMessageSigned && signatureConfig === void 0) console.warn("Construct service provider - missing signatureConfig");
+		for (const cert of castArrayOpt(signingCert)) descriptors.KeyDescriptor.push(createKeySection("signing", cert).KeyDescriptor);
+		for (const cert of castArrayOpt(encryptCert)) descriptors.KeyDescriptor.push(createKeySection("encryption", cert).KeyDescriptor);
+		if (isNonEmptyArray(nameIDFormat)) nameIDFormat.forEach((f) => descriptors.NameIDFormat.push(f));
+		else descriptors.NameIDFormat.push(NameIdFormat.emailAddress);
+		if (isNonEmptyArray(singleLogoutService)) singleLogoutService.forEach((a) => {
+			const attr = {
+				Binding: a.Binding,
+				Location: a.Location
+			};
+			if (a.isDefault) attr.isDefault = true;
+			descriptors.SingleLogoutService.push([{ _attr: attr }]);
+		});
+		if (isNonEmptyArray(assertionConsumerService)) {
+			let indexCount = 0;
+			assertionConsumerService.forEach((a) => {
+				const attr = {
+					index: String(indexCount++),
+					Binding: a.Binding,
+					Location: a.Location
+				};
+				if (a.isDefault) attr.isDefault = true;
+				descriptors.AssertionConsumerService.push([{ _attr: attr }]);
+			});
+		}
+		elementsOrder.filter((name) => isNonEmptyArray(descriptors[name])).forEach((name) => {
+			descriptors[name].forEach((e) => SPSSODescriptor.push({ [name]: e }));
+		});
+		xmlInput = buildXml([{ EntityDescriptor: [{ _attr: {
+			entityID,
+			xmlns: SamlNamespace.metadata,
+			"xmlns:assertion": SamlNamespace.assertion,
+			"xmlns:ds": "http://www.w3.org/2000/09/xmldsig#"
+		} }, { SPSSODescriptor }] }]);
+	}
+	const { xmlString, meta } = parseBaseFields(xmlInput, [{
+		key: "spSSODescriptor",
+		localPath: ["EntityDescriptor", "SPSSODescriptor"],
+		attributes: ["WantAssertionsSigned", "AuthnRequestsSigned"]
+	}, {
+		key: "assertionConsumerService",
+		localPath: [
+			"EntityDescriptor",
+			"SPSSODescriptor",
+			"AssertionConsumerService"
+		],
+		attributes: [
+			"Binding",
+			"Location",
+			"isDefault",
+			"index"
+		]
+	}]);
+	return {
+		xmlString,
+		getMetadata: () => xmlString,
+		getEntityID: () => metaString(meta, "entityID"),
+		getX509Certificate: (use) => getX509Certificate(meta, use),
+		getNameIDFormat: () => getNameIDFormat(meta),
+		getSingleLogoutService: (binding) => getSingleLogoutService(meta, binding),
+		isWantAssertionsSigned: () => readRecord(meta.spSSODescriptor)?.wantAssertionsSigned === "true",
+		isAuthnRequestSigned: () => readRecord(meta.spSSODescriptor)?.authnRequestsSigned === "true",
+		getAssertionConsumerService: (binding) => {
+			if (isString(binding)) {
+				const bindName = BINDING_URI[binding];
+				const services = meta.assertionConsumerService;
+				if (Array.isArray(services)) return services.find((obj) => isAcsService(obj) && obj.binding === bindName)?.location;
+				if (isAcsService(services) && services.binding === bindName) return services.location;
+			}
+			return meta.assertionConsumerService;
+		}
+	};
+}
+
+//#endregion
+export { parseIdpMetadata, parseSpMetadata };
+//# sourceMappingURL=metadata.js.map

package/dist/server/connection/saml/service/provider.js

@@ -0,0 +1,117 @@
+import { BINDING_URI } from "../constants.js";
+import { DEFAULT_ENTITY_SETTINGS } from "../entity.js";
+import { parseSpMetadata } from "../metadata.js";
+import { flow } from "../flow.js";
+import { loginRequestRedirectURL, logoutResponseRedirectURL } from "../binding/redirect.js";
+import { base64LoginRequest, base64LogoutResponse } from "../binding/post.js";
+
+//#region src/server/connection/saml/service/provider.ts
+/** Service-provider entity factory. */
+/**
+* The redirect bindings declare `customTagReplacement` over {@link SAMLDocumentTemplate}
+* rather than `string`. The callback never inspects the parameter's nominal shape, so the
+* bridge is type-only.
+*/
+function asDocumentTemplateReplacement(replacement) {
+	return replacement;
+}
+function isBindingKey(binding) {
+	return Object.prototype.hasOwnProperty.call(BINDING_URI, binding);
+}
+function bindingProtocol(binding) {
+	return isBindingKey(binding) ? BINDING_URI[binding] : void 0;
+}
+/** Build an {@link ServiceProviderEntity} from service-provider settings or metadata. */
+function createServiceProvider(settings) {
+	const entitySetting = Object.assign(
+		{},
+		DEFAULT_ENTITY_SETTINGS,
+		{
+			authnRequestsSigned: false,
+			wantAssertionsSigned: false,
+			wantMessageSigned: false
+		},
+		settings
+		/** `Object.assign` yields a structural intersection; widen to the named, mutable SamlEntitySettings. */
+	);
+	const entityMeta = parseSpMetadata(settings.metadata ?? settings);
+	entitySetting.authnRequestsSigned = entityMeta.isAuthnRequestSigned();
+	entitySetting.wantAssertionsSigned = entityMeta.isWantAssertionsSigned();
+	entitySetting.nameIDFormat = entityMeta.getNameIDFormat() || entitySetting.nameIDFormat;
+	let sp;
+	sp = {
+		entitySetting,
+		entityMeta,
+		getMetadata: () => entityMeta.getMetadata(),
+		createLoginRequest: async (idp, binding = "redirect", customTagReplacement) => {
+			const protocol = bindingProtocol(binding);
+			if (entityMeta.isAuthnRequestSigned() !== idp.entityMeta.isWantAuthnRequestsSigned()) throw new Error("ERR_METADATA_CONFLICT_REQUEST_SIGNED_FLAG");
+			if (protocol === BINDING_URI.redirect) return loginRequestRedirectURL({
+				idp,
+				sp
+			}, asDocumentTemplateReplacement(customTagReplacement));
+			if (protocol === BINDING_URI.post) return {
+				...await base64LoginRequest("/*[local-name(.)='AuthnRequest']", {
+					idp,
+					sp
+				}, customTagReplacement),
+				relayState: entitySetting.relayState,
+				entityEndpoint: idp.entityMeta.getSingleSignOnService(binding),
+				type: "SAMLRequest"
+			};
+			throw new Error("ERR_SP_LOGIN_REQUEST_UNDEFINED_BINDING");
+		},
+		parseLoginResponse: (idp, binding, request) => flow({
+			from: idp,
+			self: sp,
+			checkSignature: true,
+			parserType: "SAMLResponse",
+			binding,
+			request
+		}),
+		parseLogoutRequest: (idp, binding, request) => flow({
+			from: idp,
+			self: sp,
+			parserType: "LogoutRequest",
+			checkSignature: entitySetting.wantLogoutRequestSigned,
+			binding,
+			request
+		}),
+		parseLogoutResponse: (idp, binding, request) => flow({
+			from: idp,
+			self: sp,
+			parserType: "LogoutResponse",
+			checkSignature: entitySetting.wantLogoutResponseSigned,
+			binding,
+			request
+		}),
+		createLogoutResponse: async (target, requestInfo, binding, relayState = "", customTagReplacement) => {
+			const protocol = bindingProtocol(binding);
+			if (protocol === BINDING_URI.redirect) return logoutResponseRedirectURL(requestInfo, {
+				init: sp,
+				target
+			}, relayState, asDocumentTemplateReplacement(customTagReplacement));
+			if (protocol === BINDING_URI.post) return {
+				...await base64LogoutResponse(
+					requestInfo,
+					{
+						init: sp,
+						target
+					},
+					/** The binding declares this parameter required; the SP contract has always
+					* forwarded it optionally, preserving the prior pass-through behavior. */
+					customTagReplacement
+				),
+				relayState,
+				entityEndpoint: target.entityMeta.getSingleLogoutService(binding),
+				type: "SAMLResponse"
+			};
+			throw new Error("ERR_CREATE_LOGOUT_RESPONSE_UNDEFINED_BINDING");
+		}
+	};
+	return sp;
+}
+
+//#endregion
+export { createServiceProvider };
+//# sourceMappingURL=provider.js.map

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

@@ -0,0 +1,214 @@
+import { DIGEST_BY_SIGNATURE, SignatureAlgorithm } from "./constants.js";
+import { getContext } from "./api.js";
+import { isElementNode, isTextNode, selectXPath, serializeXmlNode } from "./dom/select.js";
+import { base64Encode, flattenDeep, normalizeCerString, readPrivateKey, toUtf8String } from "./encoding.js";
+import { getPublicKeyPemFromCert, rsaSign, rsaVerify } from "./crypto.js";
+import { constructMessageSignature as constructMessageSignature$1, constructSamlSignature as constructSamlSignature$1, createSignedXml, schemeToHash, verifyMessageSignature as verifyMessageSignature$1 } from "./xmldsig.js";
+import { decodeBase64, encodeBase64 } from "@oslojs/encoding";
+
+//#region src/server/connection/saml/signature.ts
+/** Map XML-dsig signature algorithm URIs to node-rsa signing-scheme aliases. */
+const nrsaAliasMapping = {
+	"http://www.w3.org/2000/09/xmldsig#rsa-sha1": "pkcs1-sha1",
+	"http://www.w3.org/2001/04/xmldsig-more#rsa-sha256": "pkcs1-sha256",
+	"http://www.w3.org/2001/04/xmldsig-more#rsa-sha512": "pkcs1-sha512"
+};
+const signatureAlgorithms = SignatureAlgorithm;
+const digestAlgorithms = DIGEST_BY_SIGNATURE;
+function getDigestMethod(sigAlg) {
+	return digestAlgorithms[sigAlg];
+}
+/**
+* Read the text data of an `<X509Certificate>`'s first child, narrowing the
+* XPath result to an element/text node. Mirrors the prior `node.firstChild.data`
+* access; a non-text or missing child yields an empty certificate string, which
+* downstream certificate matching rejects.
+*/
+function certificateNodeData(node) {
+	if (isElementNode(node)) {
+		const child = node.firstChild;
+		if (child !== null && isTextNode(child) && child.data !== null) return child.data;
+	}
+	return "";
+}
+function toPemCertificate(certificate) {
+	if (certificate.indexOf("BEGIN CERTIFICATE") >= 0) return certificate;
+	return `-----BEGIN CERTIFICATE-----\n${certificate}\n-----END CERTIFICATE-----`;
+}
+function bytesToBinaryString(input) {
+	let output = "";
+	for (const byte of input) output += String.fromCodePoint(byte);
+	return output;
+}
+/** Construct the XML signature for POST binding, returning a base64-encoded string. */
+async function constructSamlSignature(opts) {
+	return constructSamlSignature$1({
+		...opts,
+		signatureAlgorithm: opts.signatureAlgorithm || signatureAlgorithms.RSA_SHA256,
+		getDigestMethod,
+		getKeyInfo,
+		readPrivateKey: (keyString, passphrase, isOutputString) => readPrivateKey(keyString, passphrase, isOutputString),
+		base64Encode
+	});
+}
+/**
+* Verify the XML signature.
+*
+* Hardened against XML Signature Wrapping (XSW): signatures are located with
+* absolute XPaths rather than by naively fetching the first `Signature`
+* element, and any signature/assertion smuggled inside
+* `SubjectConfirmationData` is rejected as a potential wrapping attack.
+*
+* Per SAML core 5.4.2 (References): a SAML assertion or protocol message
+* being signed MUST carry an ID on its root element, and the signature MUST
+* contain a single `<ds:Reference>` whose URI is a same-document reference
+* to that ID (e.g. `#foo` for ID `foo`). Only references that actually
+* passed verification are returned, so the assertion handed back is
+* cryptographically authenticated rather than merely present in the document.
+*
+* Fails closed: a failed assertion signature aborts immediately rather than
+* falling through to another candidate. When `opts.metadata` is supplied,
+* the response's X509 certificate is pinned to one declared in metadata
+* (supporting rolling certificate usage). If metadata declares no signing
+* certificate, verification is rejected (`NO_SELECTED_CERTIFICATE`) rather than
+* trusting a certificate embedded in the assertion itself — a self-signed forgery
+* must never be allowed to verify against its own bundled certificate.
+*
+* Returns a tuple where the first element is `true` if the signature is valid,
+* and the second is the cryptographically authenticated assertion node as a
+* string, or `null` if not found.
+*/
+async function verifySignature(xml, opts) {
+	const { dom } = getContext();
+	const doc = dom.parseFromString(xml);
+	const { dom: docParser } = getContext();
+	const messageSignatureXpath = "/*[contains(local-name(), 'Response') or contains(local-name(), 'Request')]/*[local-name(.)='Signature']";
+	const assertionSignatureXpath = "/*[contains(local-name(), 'Response') or contains(local-name(), 'Request')]/*[local-name(.)='Assertion']/*[local-name(.)='Signature']";
+	const wrappingElementsXPath = "/*[contains(local-name(), 'Response')]/*[local-name(.)='Assertion']/*[local-name(.)='Subject']/*[local-name(.)='SubjectConfirmation']/*[local-name(.)='SubjectConfirmationData']//*[local-name(.)='Assertion' or local-name(.)='Signature']";
+	let selection = [];
+	const messageSignatureNode = selectXPath(messageSignatureXpath, doc);
+	const assertionSignatureNode = selectXPath(assertionSignatureXpath, doc);
+	const wrappingElementNode = selectXPath(wrappingElementsXPath, doc);
+	selection = selection.concat(assertionSignatureNode);
+	selection = selection.concat(messageSignatureNode);
+	if (wrappingElementNode.length !== 0) throw new Error("ERR_POTENTIAL_WRAPPING_ATTACK");
+	if (selection.length === 0) return [false, null];
+	for (const signatureNode of selection) {
+		if (!isElementNode(signatureNode)) continue;
+		const isAssertionSignature = assertionSignatureNode.includes(signatureNode);
+		const sig = createSignedXml();
+		let verified = false;
+		sig.signatureAlgorithm = opts.signatureAlgorithm;
+		if (!opts.keyFile && !opts.metadata) throw new Error("ERR_UNDEFINED_SIGNATURE_VERIFIER_OPTIONS");
+		if (opts.keyFile) {
+			const { readFile } = getContext();
+			if (!readFile) throw new Error("ERR_FILE_IO_NOT_AVAILABLE");
+			sig.publicCert = toUtf8String(readFile(opts.keyFile));
+		}
+		if (opts.metadata) {
+			const certificateNode = selectXPath(".//*[local-name(.)='X509Certificate']", signatureNode);
+			let metadataCertList = opts.metadata.getX509Certificate("signing");
+			if (Array.isArray(metadataCertList)) metadataCertList = flattenDeep(metadataCertList);
+			else if (typeof metadataCertList === "string") metadataCertList = [metadataCertList];
+			else metadataCertList = [];
+			/**
+			* `flattenDeep` is deliberately loose (`unknown[]`); IdP metadata only ever
+			* yields PEM strings here, which `normalizeCerString` accepts. A missing
+			* (`null`) or empty list is normalized to `[]` above so the fail-closed
+			* guard below throws a clean `NO_SELECTED_CERTIFICATE` instead of a raw
+			* `TypeError`.
+			*/
+			const metadataCert = metadataCertList.map(normalizeCerString);
+			/**
+			* Fail CLOSED: without at least one pinned signing certificate from IdP
+			* metadata there is no trust anchor. NEVER fall back to an
+			* `<X509Certificate>` embedded in the assertion — trusting the assertion's
+			* own certificate lets a self-signed forgery verify against itself (auth
+			* bypass). Reject whether or not the assertion carries an embedded cert.
+			*/
+			if (metadataCert.length === 0) throw new Error("NO_SELECTED_CERTIFICATE");
+			if (certificateNode.length !== 0) {
+				const x509Certificate = normalizeCerString(certificateNodeData(certificateNode[0]));
+				if (!metadataCert.find((cert) => cert.trim() === x509Certificate.trim())) throw new Error("ERROR_UNMATCH_CERTIFICATE_DECLARATION_IN_METADATA");
+				sig.publicCert = getKeyInfo(x509Certificate).getKey();
+			} else sig.publicCert = getKeyInfo(metadataCert[0]).getKey();
+		}
+		sig.loadSignature(signatureNode);
+		verified = await sig.checkSignature(serializeXmlNode(doc));
+		if (!verified) {
+			if (isAssertionSignature) throw new Error("ERR_FAILED_TO_VERIFY_ASSERTION_SIGNATURE");
+			continue;
+		}
+		if (!(sig.getSignedReferences().length >= 1)) throw new Error("NO_SIGNATURE_REFERENCES");
+		const signedVerifiedXML = sig.getSignedReferences()[0];
+		const rootNode = docParser.parseFromString(signedVerifiedXML).documentElement;
+		if (rootNode.localName === "Response") {
+			const assertions = selectXPath("./*[local-name()='Assertion']", rootNode);
+			const encryptedAssertions = selectXPath("./*[local-name()='EncryptedAssertion']", rootNode);
+			if (assertions.length === 1) return [true, serializeXmlNode(assertions[0])];
+			else if (encryptedAssertions.length >= 1) return [true, serializeXmlNode(rootNode)];
+			else return [true, null];
+		} else if (rootNode.localName === "Assertion") return [true, serializeXmlNode(rootNode)];
+		else return [true, null];
+	}
+	return [false, null];
+}
+/** Create the key section in metadata (an abstraction shared by signing and encryption use). */
+function createKeySection(use, certString) {
+	return { ["KeyDescriptor"]: [{ _attr: { use } }, { ["ds:KeyInfo"]: [{ _attr: { "xmlns:ds": "http://www.w3.org/2000/09/xmldsig#" } }, { ["ds:X509Data"]: [{ "ds:X509Certificate": normalizeCerString(certString) }] }] }] };
+}
+/** Construct the message signature (octet-string signature) used by the redirect binding. */
+async function constructMessageSignature(octetString, key, passphrase, isBase64, signingAlgorithm) {
+	return constructMessageSignature$1({
+		octetString,
+		key,
+		passphrase,
+		isBase64,
+		signingAlgorithm,
+		nrsaAliasMapping,
+		defaultSignatureAlgorithm: signatureAlgorithms.RSA_SHA1,
+		readPrivateKey: (keyString, keyPassphrase, isOutputString) => readPrivateKey(keyString, keyPassphrase, isOutputString),
+		signMessage: async ({ octetString: source, privateKey, signingScheme, isBase64Output }) => {
+			const sigB64 = await rsaSign(typeof privateKey === "string" ? privateKey : new TextDecoder().decode(privateKey), source, schemeToHash(signingScheme));
+			if (isBase64Output) return sigB64;
+			return bytesToBinaryString(decodeBase64(sigB64));
+		}
+	});
+}
+/** Verify a message signature against the identity/service provider's signing certificate. */
+async function verifyMessageSignature(metadata, octetString, signature, verifyAlgorithm) {
+	return verifyMessageSignature$1({
+		octetString,
+		signature,
+		signCert: metadata.getX509Certificate("signing"),
+		verifyAlgorithm,
+		nrsaAliasMapping,
+		defaultSignatureAlgorithm: signatureAlgorithms.RSA_SHA1,
+		getPublicKeyPemFromCertificate: getPublicKeyPemFromCert,
+		verifyMessage: async ({ octetString: source, signature: incomingSignature, publicKey, signingScheme }) => {
+			const hash = schemeToHash(signingScheme);
+			let sigBase64;
+			if (typeof incomingSignature === "string") sigBase64 = incomingSignature;
+			else sigBase64 = encodeBase64(incomingSignature);
+			let certOrKey = publicKey;
+			if (publicKey.indexOf("BEGIN CERTIFICATE") < 0 && publicKey.indexOf("BEGIN PUBLIC KEY") < 0) certOrKey = toPemCertificate(publicKey);
+			return rsaVerify(certOrKey, source, sigBase64, hash);
+		}
+	});
+}
+/** Build the `<KeyInfo>`/public-key accessors for an X509 certificate string. */
+function getKeyInfo(x509Certificate, signatureConfig = {}) {
+	const prefix = signatureConfig.prefix ? `${signatureConfig.prefix}:` : "";
+	return {
+		getKeyInfo: () => {
+			return `<${prefix}X509Data><${prefix}X509Certificate>${x509Certificate}</${prefix}X509Certificate></${prefix}X509Data>`;
+		},
+		getKey: () => {
+			return getPublicKeyPemFromCert(x509Certificate).toString();
+		}
+	};
+}
+
+//#endregion
+export { constructMessageSignature, constructSamlSignature, createKeySection, verifyMessageSignature, verifySignature };
+//# sourceMappingURL=signature.js.map