restpki-client/lib/cades-signature.js

Classes to consume Lacuna Software REST PKI

'use strict';
const fs = require('fs');

const {DigestAlgorithmAndValue} = require('./digest-algorithm-and-value');
const {SignatureAlgorithmAndValue} = require('./signature-algorithm-and-value');
const {PKCertificate} = require('./pk-certificate');
const {SignaturePolicyIdentifier} = require('./signature-policy-identifier');
const {ValidationResults} = require('./validation');

class CadesSignature {

	constructor(model) {
		this._encapsulatedContentType = model.encapsulatedContentType;
		this._hasEncapsulatedContent = model.hasEncapsulatedContent;
		this._encapsulatedContent = model.encapsulatedContent
		this._signers = [];
		if (model.signers) {
			for (let signer of model.signers) {
				this._signers.push(new CadesSignerInfo(signer));
			}
		}
	}

	get encapsulatedContentType() {
		return this._encapsulatedContentType;
	}

	get hasEncapsulatedContent() {
		return this._hasEncapsulatedContent;
	}

	get signers() {
		return this._signers;
	}

	async getEncapsulatedContent(client) {
		try {
			return await client.getRestClient().getAsBuffer(this._encapsulatedContent.url);
		} catch (err) {
			throw err;
		}
	}

	async writeEncapsulatedContentToFile(client, path) {
		try {
			let content = await this.getEncapsulatedContent(client);
			fs.writeFileSync(path, content);
		} catch (err) {
			throw err;
		}
	}
}

class CadesTimestamp extends CadesSignature {

	constructor(model) {
		super(model);
		this._genTime = model.genTime;
		this._serialNumber = model.serialNumber;
		this._messageImprint = new DigestAlgorithmAndValue(model.messageImprint);
	}

	get genTime() {
		return this._genTime;
	}

	get serialNumber() {
		return this._serialNumber;
	}

	get messageImprint() {
		return this._messageImprint;
	}
}

class CadesSignerInfo {

	constructor(model) {
		this._messageDigest = new DigestAlgorithmAndValue(model.messageDigest);
		this._signature = new SignatureAlgorithmAndValue(model.signature);
		this._certificate = new PKCertificate(model.certificate);
		this._signingTime = model.signingTime;
		this._certifiedDateReference = model.certifiedDateReference;

		if (model.signaturePolicy) {
			this._signaturePolicy = new SignaturePolicyIdentifier(model.signaturePolicy);
		}

		this._timestamps = [];
		if (model.timestamps) {
			for (let timestamp of model.timestamps) {
				this._timestamps.push(new CadesTimestamp(timestamp));
			}
		}

		if (model.validationResults) {
			this._validationResults = new ValidationResults(model.validationResults);
		}
	}

	get messageDigest() {
		return this._messageDigest;
	}

	get signature() {
		return this._signature;
	}

	get certificate() {
		return this._certificate;
	}

	get signingTime() {
		return this._signingTime;
	}

	get certifiedDateReference() {
		return this._certifiedDateReference;
	}

	get signaturePolicy() {
		return this._signaturePolicy;
	}

	get timestamps() {
		return this._timestamps;
	}

	get validationResults() {
		return this._validationResults;
	}
}

exports.CadesSignature = CadesSignature;
exports.CadesTimestamp = CadesTimestamp;
exports.CadesSignerInfo = CadesSignerInfo;