mirror of
https://github.com/zhigang1992/DefinitelyTyped.git
synced 2026-05-26 19:04:13 +08:00
1086 lines
34 KiB
TypeScript
1086 lines
34 KiB
TypeScript
// Type definitions for xadesjs v1.0.0
|
|
// Project: https://github.com/PeculiarVentures/xadesjs
|
|
// Definitions by: Stepan Miroshin <https://github.com/microshine>
|
|
// 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 <X509Certificate> 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 <X509Data> subelement of an XMLDSIG or XML Encryption <KeyInfo> 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 <RSAKeyValue> 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 <ECKeyValue> 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 <Transform> 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 <reference> 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 <KeyInfo> 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<KeyInfoClause>;
|
|
GetEnumerator(requestedObjectType: any): Array<KeyInfoClause>;
|
|
/**
|
|
* 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 <Signature> 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<DataObject>;
|
|
/**
|
|
* 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 <SignedInfo> 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;
|
|
}
|
|
}
|