From 3d51112b02e540677f95a1bb78d2f28e517ed515 Mon Sep 17 00:00:00 2001 From: Miroshin Stepan Date: Mon, 9 May 2016 19:33:44 +0400 Subject: [PATCH] xadesjs (#9256) * xadesjs beta * Add test & set version * Fix def errors * Change Promise to PromiseType * Fix test error --- xadesjs/xadesjs-tests.ts | 47 ++ xadesjs/xadesjs.d.ts | 1085 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 1132 insertions(+) create mode 100644 xadesjs/xadesjs-tests.ts create mode 100644 xadesjs/xadesjs.d.ts diff --git a/xadesjs/xadesjs-tests.ts b/xadesjs/xadesjs-tests.ts new file mode 100644 index 0000000000..e36f903945 --- /dev/null +++ b/xadesjs/xadesjs-tests.ts @@ -0,0 +1,47 @@ +/// + +let xmlString = ""; +let xmlDoc = new DOMParser().parseFromString(xmlString, "application/xml"); +let signedXml = new xadesjs.SignedXml(xmlDoc); + +let alg = { + name: "ECDSA", + namedCurve: "P-256" +}; +xadesjs.Application.crypto.subtle.generateKey( + alg, + false, + ["sign", "verify"] +) + .then((keys: CryptoKeyPair) => { + signedXml.SigningKey = keys.privateKey; + + // Add the key to the SignedXml document. + // Create a reference to be signed. + let reference = new xadesjs.Reference(); + reference.Uri = ""; + // Add an enveloped transformation to the reference. + reference.AddTransform(new xadesjs.XmlDsigEnvelopedSignatureTransform()); + // Add the reference to the SignedXml object. + signedXml.AddReference(reference); + // Set prefix for Signature namespace + signedXml.Prefix = "ds"; + + // Compute the signature. + return signedXml.ComputeSignature({ name: "ECDSA", hash: { name: "SHA-256" } } as any); + }) + .then(function () { + // Append signature + let xmlDigitalSignature = signedXml.GetXml(); + xmlDoc.documentElement.appendChild(xmlDigitalSignature); + + // Serialize XML document + let signedDocument = new XMLSerializer().serializeToString(xmlDoc); + return Promise.resolve(signedDocument); + }) + .then((doc: string) => { + console.log("Signed document:", doc); + }) + .catch((e: any) => { + console.error("Error", e); + }); \ No newline at end of file diff --git a/xadesjs/xadesjs.d.ts b/xadesjs/xadesjs.d.ts new file mode 100644 index 0000000000..cad137db05 --- /dev/null +++ b/xadesjs/xadesjs.d.ts @@ -0,0 +1,1085 @@ +// Type definitions for xadesjs v1.0.0 +// Project: https://github.com/PeculiarVentures/xadesjs +// Definitions by: Stepan Miroshin +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +/** + * A pure Javascript implementation of XMLDSIG and XAdES based on Web Crypto https://xadesjs.com + * v1.0.0 + */ + +declare namespace xadesjs { + + type PromiseType = any; + + const APPLICATION_XML: string; + + class XmlError extends Error { + stack: any; + constructor(code: XE, ...args: any[]); + } + + enum XE { + NONE = 0, + NULL_REFERENCE = 1, + METHOD_NOT_IMPLEMENTED = 2, + METHOD_NOT_SUPPORTED = 3, + PARAM_REQUIRED = 4, + CONVERTER_UNSUPPORTED = 5, + ELEMENT_MALFORMED = 6, + CRYPTOGRAPHIC = 7, + CRYPTOGRAPHIC_NO_MODULE = 8, + CRYPTOGRAPHIC_UNKNOWN_TRANSFORM = 9, + ALGORITHM_NOT_SUPPORTED = 10, + ALGORITHM_WRONG_NAME = 11, + XML_EXCEPTION = 12, + } + + interface CryptoEx extends Crypto { + name: string; + } + + class Application { + /** + * Sets crypto engine for the current Application + * @param {string} name + * @param {Crypto} crypto + * @returns void + */ + static setEngine(name: string, crypto: Crypto): void; + /** + * Gets the crypto module from the Application + */ + static crypto: CryptoEx; + static isNodePlugin(): boolean; + } + + enum XmlNodeType { + None = 0, + Element = 1, + Attribute = 2, + Text = 3, + CDATA = 4, + EntityReference = 5, + Entity = 6, + ProcessingInstruction = 7, + Comment = 8, + Document = 9, + DocumentType = 10, + DocumentFragment = 11, + Notation = 12, + Whitespace = 13, + SignificantWhitespace = 14, + EndElement = 15, + EndEntity = 16, + XmlDeclaration = 17, + } + + interface IXmlSerializable { + Prefix: string; + /** + * Writes object to XML node + * @returns Node + */ + GetXml(): Node; + /** + * Reads XML from string + * @param {Node} node + * @returns void + */ + LoadXml(node: Node): void; + } + + abstract class XmlObject implements IXmlSerializable { + protected m_prefix: string; + Prefix: string; + protected GetPrefix(): string; + GetXml(): Node; + GetXml(document: Document): Node; + LoadXml(node: Node): void; + toString(): string; + protected getAttribute(xel: Element, attribute: string): string; + } + + const DEFAULT_ROOT_NAME: string; + function IsEqualsEmptyStrings(s1: string, s2: string): boolean; + /** + * Creates new instance of XmlDocument with given name of root element + * @param {string} root Name of root element + * @param {string} namespaceUri + * @param {string} prefix + * @returns Document + */ + function CreateDocument(root?: string, namespaceUri?: string, prefix?: string): Document; + /** + * Returns signle Node from given Node + * @param {Node} node + * @param {string} path + * @returns Node + */ + function SelectSingleNode(node: Node, path: string): Node; + + function findAttr(node: Node, localName: string, nameSpace?: string): Attr; + function findFirst(doc: Node, xpath: string): Node; + function findChilds(node: Node, localName: string, nameSpace?: string): Node[]; + interface IAssocArray { + [index: string]: string; + } + function encodeSpecialCharactersInAttribute(attributeValue: string): string; + function encodeSpecialCharactersInText(text: string): string; + function SelectNamespaces(node: Element): Node[]; + + class Convert { + static ToBase64UrlString(text: string): string; + static FromBase64UrlString(base64UrlText: string): string; + static ToBase64String(text: string): string; + static FromBase64String(base64Text: string): string; + static Base64UrlToBase64(base64url: string): string; + static Base64ToBase64Url(base64: string): string; + static ToBufferUtf8String(text: string): Uint8Array; + static FromBufferUtf8String(buffer: Uint8Array): string; + static ToBufferString(text: string): Uint8Array; + static FromBufferString(buffer: ArrayBuffer): string; + static FromBufferString(buffer: Uint8Array): string; + } + + interface IAlgorithm { + algorithm: Algorithm; + xmlNamespace: string; + getAlgorithmName(): string; + } + interface IHashAlgorithm extends IAlgorithm { + getHash(xml: string): PromiseType; + } + interface IHashAlgorithmConstructable { + new (): IHashAlgorithm; + } + abstract class XmlAlgorithm implements IAlgorithm { + algorithm: Algorithm; + xmlNamespace: string; + getAlgorithmName(): string; + } + abstract class HashAlgorithm extends XmlAlgorithm implements IHashAlgorithm { + getHash(xml: string): PromiseType; + } + interface ISignatureAlgorithm extends IAlgorithm { + getSignature(signedInfo: string, signingKey: CryptoKey, algorithm: Algorithm): PromiseType; + verifySignature(signedInfo: string, key: CryptoKey, signatureValue: string, algorithm?: Algorithm): PromiseType; + } + interface ISignatureAlgorithmConstructable { + new (): ISignatureAlgorithm; + } + abstract class SignatureAlgorithm extends XmlAlgorithm implements ISignatureAlgorithm { + /** + * Sign the given string using the given key + */ + getSignature(signedInfo: string, signingKey: CryptoKey, algorithm: Algorithm): PromiseType; + /** + * Verify the given signature of the given string using key + */ + verifySignature(signedInfo: string, key: CryptoKey, signatureValue: string, algorithm?: Algorithm): PromiseType; + } + + const SHA1: string; + const SHA224: string; + const SHA256: string; + const SHA384: string; + const SHA512: string; + const SHA1_NAMESPACE: string; + const SHA224_NAMESPACE: string; + const SHA256_NAMESPACE: string; + const SHA384_NAMESPACE: string; + const SHA512_NAMESPACE: string; + class Sha1 extends HashAlgorithm { + algorithm: { + name: string; + }; + xmlNamespace: string; + } + class Sha224 extends HashAlgorithm { + algorithm: { + name: string; + }; + xmlNamespace: string; + } + class Sha256 extends HashAlgorithm { + algorithm: { + name: string; + }; + xmlNamespace: string; + } + class Sha384 extends HashAlgorithm { + algorithm: { + name: string; + }; + xmlNamespace: string; + } + class Sha512 extends HashAlgorithm { + algorithm: { + name: string; + }; + xmlNamespace: string; + } + + // RSA PKCS1 + + const RSA_PKCS1: string; + const RSA_PKCS1_SHA1_NAMESPACE: string; + const RSA_PKCS1_SHA224_NAMESPACE: string; + const RSA_PKCS1_SHA256_NAMESPACE: string; + const RSA_PKCS1_SHA384_NAMESPACE: string; + const RSA_PKCS1_SHA512_NAMESPACE: string; + + class RsaPkcs1Sha1 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + class RsaPkcs1Sha224 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + class RsaPkcs1Sha256 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + class RsaPkcs1Sha384 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + class RsaPkcs1Sha512 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + + // RSA PSS + + const RSA_PSS: string; + const RSA_PSS_WITH_PARAMS_NAMESPACE: string; + const RSA_PSS_WITH_PARAMS_MGF1_NAMESPACE: string; + + class RsaPssSha1 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + class RsaPssSha224 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + class RsaPssSha256 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + class RsaPssSha384 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + class RsaPssSha512 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + class PssAlgorithmParams extends XmlObject { + private m_digest_method; + private m_salt_length; + private m_mgf; + private element; + dsPrefix: string; + DigestMethod: string; + SaltLength: number; + MGF: string; + GetXml(): Element; + LoadXml(value: Element): void; + } + + // HMAC + + const HMAC_ALGORITHM: string; + const HMAC_SHA1_NAMESPACE: string; + const HMAC_SHA256_NAMESPACE: string; + const HMAC_SHA384_NAMESPACE: string; + const HMAC_SHA512_NAMESPACE: string; + + class HmacSha1 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + class HmacSha256 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + class HmacSha384 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + class HmacSha512 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + + // ECDSA + + const ECDSA_SIGN_ALGORITHM: string; + const ECDSA_SHA1_NAMESPACE: string; + const ECDSA_SHA224_NAMESPACE: string; + const ECDSA_SHA256_NAMESPACE: string; + const ECDSA_SHA384_NAMESPACE: string; + const ECDSA_SHA512_NAMESPACE: string; + class EcdsaSha1 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + class EcdsaSha224 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + class EcdsaSha256 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + class EcdsaSha384 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + class EcdsaSha512 extends SignatureAlgorithm { + algorithm: any; + xmlNamespace: string; + } + + /** + * Represents an element. + */ + class X509Certificate { + protected raw: Uint8Array; + protected cert_simpl: any; + protected publicKey: CryptoKey; + constructor(rawData?: Uint8Array); + /** + * Loads X509Certificate from DER data + * @param {Uint8Array} rawData + */ + protected LoadFromRawData(rawData: Uint8Array): void; + /** + * Gets the public key from the X509Certificate + */ + PublicKey: CryptoKey; + /** + * Returns DER raw of X509Certificate + */ + GetRawCertData(): Uint8Array; + /** + * Returns public key from X509Certificate + * @param {Algorithm} algorithm + * @returns PromiseType + */ + exportKey(algorithm: Algorithm): PromiseType; + } + + enum X509IncludeOption { + None = 0, + EndCertOnly = 1, + ExcludeRoot = 2, + WholeChain = 3, + } + interface X509IssuerSerial { + issuerName: string; + serialNumber: string; + } + /** + * Represents an subelement of an XMLDSIG or XML Encryption element. + */ + class KeyInfoX509Data extends XmlObject implements KeyInfoClause { + + constructor(); + constructor(rgbCert: Uint8Array); + constructor(cert: X509Certificate); + /** + * Gets public key of the X509Data + */ + Key: CryptoKey; + importKey(key: CryptoKey): PromiseType; + /** + * Exports key from X509Data object + * @param {Algorithm} alg + * @returns PromiseType + */ + exportKey(alg: Algorithm): PromiseType; + /** + * Gets a list of the X.509v3 certificates contained in the KeyInfoX509Data object. + */ + Certificates: X509Certificate[]; + /** + * Gets or sets the Certificate Revocation List (CRL) contained within the KeyInfoX509Data object. + */ + CRL: Uint8Array; + /** + * Gets a list of X509IssuerSerial structures that represent an issuer name and serial number pair. + */ + IssuerSerials: X509IssuerSerial[]; + /** + * Gets a list of the subject key identifiers (SKIs) contained in the KeyInfoX509Data object. + */ + SubjectKeyIds: Uint8Array[]; + /** + * Gets a list of the subject names of the entities contained in the KeyInfoX509Data object. + */ + SubjectNames: string[]; + /** + * Adds the specified X.509v3 certificate to the KeyInfoX509Data. + * @param {X509Certificate} certificate + * @returns void + */ + AddCertificate(certificate: X509Certificate): void; + /** + * Adds the specified issuer name and serial number pair to the KeyInfoX509Data object. + * @param {string} issuerName + * @param {string} serialNumber + * @returns void + */ + AddIssuerSerial(issuerName: string, serialNumber: string): void; + /** + * Adds the specified subject key identifier (SKI) to the KeyInfoX509Data object. + * @param {string | Uint8Array} subjectKeyId + * @returns void + */ + AddSubjectKeyId(subjectKeyId: string): void; + AddSubjectKeyId(subjectKeyId: Uint8Array): void; + /** + * Adds the subject name of the entity that was issued an X.509v3 certificate to the KeyInfoX509Data object. + * @param {string} subjectName + * @returns void + */ + AddSubjectName(subjectName: string): void; + /** + * Returns an XML representation of the KeyInfoX509Data object. + * @returns Element + */ + GetXml(): Element; + /** + * Parses the input XmlElement object and configures the internal state of the KeyInfoX509Data object to match. + * @param {Element} element + * @returns void + */ + LoadXml(element: Element): void; + } + + interface IJwkRsa { + alg: string; + kty: string; + e: string; + n: string; + ext: boolean; + } + /** + * Represents the element of an XML signature. + */ + class RsaKeyValue extends XmlObject implements KeyInfoClause { + /** + * Gets or sets the instance of RSA that holds the public key. + */ + Key: CryptoKey; + /** + * Gets the algorithm of the public key + */ + Algorithm: ISignatureAlgorithm; + /** + * Gets the Modulus of the public key + */ + Modulus: Uint8Array; + /** + * Gets the Exponent of the public key + */ + Exponent: Uint8Array; + constructor(); + /** + * Imports key to the RSAKeyValue object + * @param {CryptoKey} key + * @returns PromiseType + */ + importKey(key: CryptoKey): PromiseType; + /** + * Exports key from the RSAKeyValue object + * @param {Algorithm} alg + * @returns PromiseType + */ + exportKey(alg: Algorithm): PromiseType; + /** + * Returns the XML representation of the RSA key clause. + * @returns Element + */ + GetXml(): Element; + /** + * Loads an RSA key clause from an XML element. + * @param {Element} element + * @returns void + */ + LoadXml(element: Element): void; + } + + type NamedCurve = "P-256" | "P-384" | "P-521"; + + interface IJwkEcdsa { + crv: NamedCurve; + kty: "EC"; + x: string; + y: string; + ext: boolean; + } + + /** + * Represents the element of an XML signature. + */ + class EcdsaKeyValue extends XmlObject implements KeyInfoClause { + /** + * Gets or sets the instance of ECDSA that holds the public key. + */ + Key: CryptoKey; + /** + * Gets the algorithm of the public key + */ + Algorithm: ISignatureAlgorithm; + /** + * Gets the X point value of then public key + */ + X: Uint8Array; + /** + * Gets the Y point value of then public key + */ + Y: Uint8Array; + /** + * Gets the NamedCurve value of then public key + */ + NamedCurve: NamedCurve; + constructor(); + /** + * Imports key to the ECKeyValue object + * @param {CryptoKey} key + * @returns PromiseType + */ + importKey(key: CryptoKey): PromiseType; + /** + * Exports key from the ECKeyValue object + * @param {Algorithm} alg + * @returns PromiseType + */ + exportKey(alg: Algorithm): PromiseType; + /** + * Returns the XML representation of the ECDSA key clause. + * @returns Element + */ + GetXml(): Element; + /** + * Loads an ECDSA key clause from an XML element. + * @param {Element} element + * @returns void + */ + LoadXml(element: Element): void; + } + + type XmlNamespace = { + prefix: string; + namespace: string; + }; + + enum XmlCanonicalizerState { + BeforeDocElement = 0, + InsideDocElement = 1, + AfterDocElement = 2, + } + + class XmlCanonicalizer { + constructor(withComments: boolean, excC14N: boolean, propagatedNamespaces?: XmlNamespace[]); + InclusiveNamespacesPrefixList: string; + Canonicalize(node: Node): string; + } + + interface Transform extends IXmlSerializable { + Algorithm: string; + LoadInnerXml(node: Node): void; + GetInnerXml(): Node; + GetOutput(): string; + } + + interface ICanonicalizationAlgorithmConstructable { + new (): Transform; + } + /** + * Represents the abstract base class from which all elements + * that can be used in an XML digital signature derive. + */ + abstract class Transform extends XmlObject implements Transform { + protected innerXml: Node; + LoadXml(value: Node): void; + /** + * Returns the XML representation of the current Transform object. + * @returns Element + */ + GetXml(): Element; + } + + /** + * Represents the enveloped signature transform for an XML digital signature as defined by the W3C. + */ + class XmlDsigEnvelopedSignatureTransform extends Transform { + Algorithm: string; + /** + * Returns the output of the current XmlDsigEnvelopedSignatureTransform object. + * @returns string + */ + GetOutput(): string; + } + + /** + * Represents the C14N XML canonicalization transform for a digital signature + * as defined by the World Wide Web Consortium (W3C), without comments. + */ + class XmlDsigC14NTransform extends Transform { + protected xmlCanonicalizer: XmlCanonicalizer; + Algorithm: string; + /** + * Returns the output of the current XmlDsigC14NTransform object. + * @returns string + */ + GetOutput(): string; + } + /** + * Represents the C14N XML canonicalization transform for a digital signature + * as defined by the World Wide Web Consortium (W3C), with comments. + */ + class XmlDsigC14NWithCommentsTransform extends XmlDsigC14NTransform { + Algorithm: string; + protected xmlCanonicalizer: XmlCanonicalizer; + } + + /** + * Represents the exclusive C14N XML canonicalization transform for a digital signature + * as defined by the World Wide Web Consortium (W3C), without comments. + */ + class XmlDsigExcC14NTransform extends Transform { + protected xmlCanonicalizer: XmlCanonicalizer; + Algorithm: string; + /** + * Gets or sets a string that contains namespace prefixes to canonicalize + * using the standard canonicalization algorithm. + */ + InclusiveNamespacesPrefixList: string; + /** + * Returns the output of the current XmlDsigExcC14NTransform object + */ + GetOutput(): string; + } + /** + * Represents the exclusive C14N XML canonicalization transform for a digital signature + * as defined by the World Wide Web Consortium (W3C), with comments. + */ + class XmlDsigExcC14NWithCommentsTransform extends XmlDsigExcC14NTransform { + Algorithm: string; + protected xmlCanonicalizer: XmlCanonicalizer; + } + + class CryptoConfig { + static CreateFromName(name: string): Transform; + static CreateSignatureAlgorithm(namespace: string): SignatureAlgorithm; + static CreateHashAlgorithm(namespace: string): HashAlgorithm; + } + + /** + * Represents the object element of an XML signature that holds data to be signed. + */ + class DataObject extends XmlObject { + constructor(); + constructor(id?: string, mimeType?: string, encoding?: string, data?: Element); + /** + * Gets or sets the data value of the current DataObject object. + */ + Data: NodeList; + /** + * Gets or sets the encoding of the current DataObject object. + */ + Encoding: string; + /** + * Gets or sets the identification of the current DataObject object. + */ + Id: string; + /** + * Gets or sets the MIME type of the current DataObject object. + */ + MimeType: string; + /** + * Returns the XML representation of the DataObject object. + * @returns Element + */ + GetXml(): Element; + /** + * Loads a DataObject state from an XML element. + * @param {Element} value + * @returns void + */ + LoadXml(value: Element): void; + } + + /** + * Represents the element of an XML signature. + */ + class Reference extends XmlObject { + + constructor(p?: string); + /** + * Gets or sets the digest method Uniform Resource Identifier (URI) of the current + */ + DigestMethod: string; + /** + * Gets or sets the digest value of the current Reference. + */ + DigestValue: ArrayBuffer; + /** + * Gets or sets the ID of the current Reference. + */ + Id: string; + /** + * Gets the transform chain of the current Reference. + */ + TransformChain: Transform[]; + /** + * Gets or sets the type of the object being signed. + */ + Type: string; + /** + * Gets or sets the Uri of the current Reference. + */ + Uri: string; + /** + * Adds a Transform object to the list of transforms to be performed + * on the data before passing it to the digest algorithm. + * @param {Transform} transform The transform to be added to the list of transforms. + * @returns void + */ + AddTransform(transform: Transform): void; + /** + * Returns the XML representation of the Reference. + * @returns Element + */ + GetXml(): Element; + /** + * Loads a Reference state from an XML element. + * @param {Element} value + */ + LoadXml(value: Element): void; + } + + /** + * Represents an XML digital signature or XML encryption element. + */ + class KeyInfo extends XmlObject { + constructor(); + /** + * Gets the number of KeyInfoClause objects contained in the KeyInfo object. + */ + length: number; + /** + * Gets or sets the key information identity. + */ + Id: string; + /** + * Returns an enumerator of the KeyInfoClause objects in the KeyInfo object. + * @param {any} requestedObjectType? + */ + GetEnumerator(): Array; + GetEnumerator(requestedObjectType: any): Array; + /** + * Returns an enumerator of the KeyInfoClause objects in the KeyInfo object. + * @param {KeyInfoClause} clause The KeyInfoClause to add to the KeyInfo object. + * @returns void + */ + AddClause(clause: KeyInfoClause): void; + /** + * Returns the XML representation of the KeyInfo object. + * @returns Node + */ + GetXml(): Node; + /** + * Loads a KeyInfo state from an XML element. + * @param {Element} value + * @returns void + */ + LoadXml(value: Element): void; + } + interface KeyInfoClause extends IXmlSerializable { + Key: CryptoKey; + importKey(key: CryptoKey): PromiseType; + exportKey(alg: Algorithm): PromiseType; + } + + /** + * Represents the element of an XML signature. + */ + class Signature extends XmlObject { + + constructor(); + /** + * Gets or sets the ID of the current Signature. + */ + Id: string; + /** + * Gets or sets the KeyInfo of the current Signature. + */ + KeyInfo: KeyInfo; + /** + * Gets or sets a list of objects to be signed. + */ + ObjectList: Array; + /** + * Gets or sets the value of the digital signature. + */ + SignatureValue: Uint8Array; + /** + * Gets or sets the SignedInfo of the current Signature. + */ + SignedInfo: SignedInfo; + /** + * Adds a DataObject to the list of objects to be signed. + * @param {DataObject} dataObject The DataObject to be added to the list of objects to be signed. + * @returns void + */ + AddObject(dataObject: DataObject): void; + /** + * Returns the XML representation of the Signature. + * @returns Element + */ + GetXml(): Element; + /** + * Loads a Signature state from an XML element. + * @param {Element} value + * @returns void + */ + LoadXml(value: Element): void; + } + const XmlSignature: { + ElementNames: { + CanonicalizationMethod: string; + DigestMethod: string; + DigestValue: string; + DSAKeyValue: string; + EncryptedKey: string; + HMACOutputLength: string; + RSAPSSParams: string; + MaskGenerationFunction: string; + SaltLength: string; + KeyInfo: string; + KeyName: string; + KeyValue: string; + Modulus: string; + Exponent: string; + Manifest: string; + Object: string; + Reference: string; + RetrievalMethod: string; + RSAKeyValue: string; + ECKeyValue: string; + NamedCurve: string; + PublicKey: string; + Signature: string; + SignatureMethod: string; + SignatureValue: string; + SignedInfo: string; + Transform: string; + Transforms: string; + X509Data: string; + X509IssuerSerial: string; + X509IssuerName: string; + X509SerialNumber: string; + X509SKI: string; + X509SubjectName: string; + X509Certificate: string; + X509CRL: string; + }; + AttributeNames: { + Algorithm: string; + Encoding: string; + Id: string; + MimeType: string; + Type: string; + URI: string; + }; + AlgorithmNamespaces: { + XmlDsigBase64Transform: string; + XmlDsigC14NTransform: string; + XmlDsigC14NWithCommentsTransform: string; + XmlDsigEnvelopedSignatureTransform: string; + XmlDsigXPathTransform: string; + XmlDsigXsltTransform: string; + XmlDsigExcC14NTransform: string; + XmlDsigExcC14NWithCommentsTransform: string; + XmlDecryptionTransform: string; + XmlLicenseTransform: string; + }; + Uri: { + Manifest: string; + }; + NamespaceURI: string; + NamespaceURIMore: string; + NamespaceURIPss: string; + Prefix: string; + GetChildElement: (xel: Node, element: string, ns: string) => Element; + GetAttributeFromElement: (xel: Element, attribute: string, element: string) => string; + GetChildElements: (xel: Element, element: string) => Element[]; + }; + + /** + * The SignedInfo class represents the element + * of an XML signature defined by the XML digital signature specification + */ + class SignedInfo extends XmlObject { + + constructor(signedXml?: SignedXml); + /** + * Gets or sets the canonicalization algorithm that is used before signing + * for the current SignedInfo object. + */ + CanonicalizationMethod: string; + /** + * Gets a Transform object used for canonicalization. + * @returns Transform + */ + CanonicalizationMethodObject: Transform; + /** + * Gets the number of references in the current SignedInfo object. + */ + Count: number; + /** + * Gets or sets the ID of the current SignedInfo object. + */ + Id: string; + /** + * Gets a value that indicates whether the collection is read-only. + * @returns boolean + */ + IsReadOnly: boolean; + /** + * Gets a value that indicates whether the collection is synchronized. + * @returns boolean + */ + IsSynchronized: boolean; + /** + * Gets a list of the Reference objects of the current SignedInfo object. + */ + References: Reference[]; + /** + * Gets or sets the length of the signature for the current SignedInfo object. + */ + SignatureLength: string; + /** + * Gets or sets the name of the algorithm used for signature generation + * and validation for the current SignedInfo object. + */ + SignatureMethod: string; + SignatureParams: XmlObject; + /** + * Gets an object to use for synchronization. + */ + SyncRoot: any; + /** + * Adds a Reference object to the list of references to digest and sign. + * @param {Reference} reference The reference to add to the list of references. + * @returns void + */ + AddReference(reference: Reference): void; + /** + * Copies the elements of this instance into an Array object, starting at a specified index in the array. + * @param {any[]} array + * @param {number} index + * @returns void + */ + CopyTo(array: any[], index: number): void; + /** + * Returns the XML representation of the SignedInfo object. + * @returns Node + */ + GetXml(): Node; + /** + * Loads a SignedInfo state from an XML element. + * @param {Element} value + * @returns void + */ + LoadXml(value: Element): void; + } + + /** + * Provides a wrapper on a core XML signature object to facilitate creating XML signatures. + */ + class SignedXml extends XmlObject { + /** + * Gets or sets the KeyInfo object of the current SignedXml object. + */ + KeyInfo: KeyInfo; + /** + * Gets the Signature object of the current SignedXml object. + */ + Signature: Signature; + /** + * Gets or sets the prefix for the current SignedXml object. + */ + Prefix: string; + /** + * Gets the length of the signature for the current SignedXml object. + */ + SignatureLength: number; + SignatureMethod: string; + /** + * Gets the signature value of the current SignedXml object. + */ + SignatureValue: ArrayBuffer; + /** + * Gets the CanonicalizationMethod of the current SignedXml object. + */ + CanonicalizationMethod: string; + /** + * Gets the SignedInfo object of the current SignedXml object. + */ + SignedInfo: SignedInfo; + /** + * Gets or sets the asymmetric algorithm key used for signing a SignedXml object. + */ + SigningKey: CryptoKey; + /** + * Gets or sets the name of the installed key to be used for signing the SignedXml object. + */ + SigningKeyName: string; + /** + * @param {string} idMode. Value of "wssecurity" will create/validate id's with the ws-security namespace + */ + constructor(); + constructor(node: Document); + constructor(node: Element); + /** + * Adds a Reference object to the SignedXml object that describes a digest method, + * digest value, and transform to use for creating an XML digital signature. + * @param {Reference} reference The Reference object that describes a digest method, digest value, + * and transform to use for creating an XML digital signature. + * @returns void + */ + AddReference(reference: Reference): void; + /** + * Computes an XML digital signature using the specified algorithm. + * @param {Algorithm} algorithm Specified WebCrypto Algoriithm + * @returns PromiseType + */ + ComputeSignature(algorithm: Algorithm): PromiseType; + /** + * Determines whether the SignedXml.Signature property verifies using the public key in the signature. + * @returns PromiseType + */ + CheckSignature(): PromiseType; + CheckSignature(key: CryptoKey): PromiseType; + CheckSignature(cert: X509Certificate): PromiseType; + /** + * Loads a SignedXml state from an XML element. + * @param {Element} value The XML element to load the SignedXml state from. + * @returns void + */ + LoadXml(value: Element): void; + /** + * Returns the XML representation of a SignedXml object. + * @returns Element + */ + GetXml(): Element; + } +}