myrtex-mf-signer 1.1.0

package/esm2020/lib/providers/cryptots.provider.mjs

@@ -0,0 +1,56 @@
+import { Injectable } from '@angular/core';
+import { CertificateSelectComponent } from '../components/certificate-select/certificate-select.component';
+import { CryptoProTsService } from '../services/cryptopro/crypto.pro.ts.service';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-simple-modal";
+import * as i2 from "../services/crypto.service";
+import * as i3 from "../services/crypto.api.service";
+export class CryptoTsProvider {
+    constructor(simpleModalService, cryptoService, cryptoApiService) {
+        this.simpleModalService = simpleModalService;
+        this.cryptoService = cryptoService;
+        this.cryptoApiService = cryptoApiService;
+    }
+    async sign(data, withLog, options) {
+        await this.cryptoService.startUp(withLog);
+        const service = await this.cryptoService.getService(CryptoProTsService.key);
+        const list = await service.getCertificates();
+        const modalResult = await this.simpleModalService
+            .addModal(CertificateSelectComponent, { certificates: list }).toPromise();
+        if (!modalResult.selected) {
+            if (withLog) {
+                console.log('No certificate selected, rejecting');
+            }
+            return Promise.reject();
+        }
+        const signedData = await service.sign(modalResult.selected.certificate, data);
+        if (!options.skipServerCheck) {
+            const validateResult = await this.cryptoApiService.validate(signedData).toPromise();
+            return {
+                data,
+                signed: signedData,
+                success: validateResult.success,
+                validateResult: validateResult.validateResult,
+                certificate: modalResult.selected,
+            };
+        }
+        else {
+            return {
+                data,
+                signed: signedData,
+                success: true,
+                validateResult: '',
+                certificate: modalResult.selected,
+            };
+        }
+    }
+}
+CryptoTsProvider.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CryptoTsProvider, deps: [{ token: i1.SimpleModalService }, { token: i2.CryptoService }, { token: i3.CryptoApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+CryptoTsProvider.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CryptoTsProvider, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CryptoTsProvider, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SimpleModalService }, { type: i2.CryptoService }, { type: i3.CryptoApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/providers/empty.provider.mjs

@@ -0,0 +1,19 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class EmptyProvider {
+    async sign(data, withLog, options) {
+        return Promise.resolve({
+            data: data,
+            success: true
+        });
+    }
+}
+EmptyProvider.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: EmptyProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+EmptyProvider.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: EmptyProvider, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: EmptyProvider, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1wdHkucHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9teXJ0ZXgtbWYtc2lnbmVyL3NyYy9saWIvcHJvdmlkZXJzL2VtcHR5LnByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBTzNDLE1BQU0sT0FBTyxhQUFhO0lBRWpCLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBWSxFQUFFLE9BQWlCLEVBQUUsT0FBYTtRQUM5RCxPQUFPLE9BQU8sQ0FBQyxPQUFPLENBQUM7WUFDckIsSUFBSSxFQUFFLElBQUk7WUFDVixPQUFPLEVBQUUsSUFBSTtTQUNkLENBQUMsQ0FBQztJQUNMLENBQUM7OzJHQVBVLGFBQWE7K0dBQWIsYUFBYSxjQUZaLE1BQU07NEZBRVAsYUFBYTtrQkFIekIsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHsgSVNpZ25Qcm92aWRlciB9IGZyb20gXCIuL2ludGVyZmFjZXMvaXNpZ24ucHJvdmlkZXJcIjtcclxuaW1wb3J0IHsgU2lnbmVkUmVzdWx0TW9kZWwgfSBmcm9tICcuLi9tb2RlbHMnO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgRW1wdHlQcm92aWRlciBpbXBsZW1lbnRzIElTaWduUHJvdmlkZXIge1xyXG5cclxuICBwdWJsaWMgYXN5bmMgc2lnbihkYXRhOiBzdHJpbmcsIHdpdGhMb2c/OiBib29sZWFuLCBvcHRpb25zPzogYW55KTogUHJvbWlzZTxTaWduZWRSZXN1bHRNb2RlbD4ge1xyXG4gICAgcmV0dXJuIFByb21pc2UucmVzb2x2ZSh7XHJcbiAgICAgIGRhdGE6IGRhdGEsXHJcbiAgICAgIHN1Y2Nlc3M6IHRydWVcclxuICAgIH0pO1xyXG4gIH1cclxufVxyXG4iXX0=

package/esm2020/lib/providers/interfaces/isign.provider.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXNpZ24ucHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9teXJ0ZXgtbWYtc2lnbmVyL3NyYy9saWIvcHJvdmlkZXJzL2ludGVyZmFjZXMvaXNpZ24ucHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNpZ25lZFJlc3VsdE1vZGVsIH0gZnJvbSAnLi4vLi4vbW9kZWxzJztcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgSVNpZ25Qcm92aWRlciB7XHJcbiAgc2lnbihkYXRhOiBzdHJpbmcsIHdpdGhMb2c/OiBib29sZWFuLCBvcHRpb25zPzogYW55KTogUHJvbWlzZTxTaWduZWRSZXN1bHRNb2RlbD5cclxufVxyXG4iXX0=

package/esm2020/lib/providers/signprovider.factory.mjs

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./crypto.provider";
+import * as i2 from "./cryptojinn.provider";
+import * as i3 from "./cryptots.provider";
+import * as i4 from "./empty.provider";
+export class SignProviderFactory {
+    constructor(cryptoProvider, cryptoJinnProvider, cryptoTsProvider, emptyProvider) {
+        this.cryptoProvider = cryptoProvider;
+        this.cryptoJinnProvider = cryptoJinnProvider;
+        this.cryptoTsProvider = cryptoTsProvider;
+        this.emptyProvider = emptyProvider;
+    }
+    create(providerType) {
+        switch (providerType) {
+            case 'crypto':
+                return this.cryptoProvider;
+            case 'cryptojinn':
+                return this.cryptoJinnProvider;
+            case 'cryptots':
+                return this.cryptoTsProvider;
+            case 'empty':
+                return this.emptyProvider;
+        }
+    }
+}
+SignProviderFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SignProviderFactory, deps: [{ token: i1.CryptoProvider }, { token: i2.CryptoJinnProvider }, { token: i3.CryptoTsProvider }, { token: i4.EmptyProvider }], target: i0.ɵɵFactoryTarget.Injectable });
+SignProviderFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SignProviderFactory, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SignProviderFactory, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CryptoProvider }, { type: i2.CryptoJinnProvider }, { type: i3.CryptoTsProvider }, { type: i4.EmptyProvider }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/certificate.adjuster.mjs

@@ -0,0 +1,66 @@
+class CertificateAdjuster {
+    extract(s, name) {
+        if (typeof (name) === 'string') {
+            name = [name];
+        }
+        for (var i = 0; i < name.length; i++) {
+            var n = name[i];
+            var re = new RegExp(n + '\s*=\s*\"?([^,\\/\"]+)');
+            var matches = s.match(re);
+            if (matches && matches.length > 1) {
+                return matches[1].trim();
+            }
+        }
+        return '';
+    }
+    ;
+    Print2Digit(digit) {
+        return (digit < 10) ? '0' + digit : digit;
+    }
+    ;
+    GetCertDate(paramDate) {
+        let certDate = new Date(paramDate);
+        return this.Print2Digit(certDate.getUTCDate()) + '.' + this.Print2Digit(certDate.getMonth() + 1) +
+            '.' + certDate.getFullYear() + ' ' +
+            this.Print2Digit(certDate.getUTCHours()) + ':' + this.Print2Digit(certDate.getUTCMinutes()) +
+            ':' + this.Print2Digit(certDate.getUTCSeconds());
+    }
+    ;
+    GetCertFio(certSubjectName) {
+        const lastName = this.extract(certSubjectName, 'SN');
+        const name = this.extract(certSubjectName, 'G');
+        return lastName + ' ' + name;
+    }
+    ;
+    GetCertPost(certSubjectName) {
+        return this.extract(certSubjectName, 'T');
+    }
+    ;
+    GetCertOgrn(certSubjectName) {
+        return this.extract(certSubjectName, ['OGRN', 'ОГРН', '1.2.643.100.1']);
+    }
+    ;
+    GetCertOrg(certSubjectName) {
+        return this.extract(certSubjectName, 'O');
+    }
+    ;
+    GetCertInn(certSubjectName) {
+        return this.extract(certSubjectName, ['INN', 'ИНН', '1.2.643.3.131.1.1']);
+    }
+    ;
+    GetCertName(certSubjectName) {
+        return this.extract(certSubjectName, 'CN');
+    }
+    ;
+    GetIssuer(certIssuerName) {
+        return this.extract(certIssuerName, 'CN');
+    }
+    ;
+    GetCertInfoString(certSubjectName, certFromDate) {
+        return this.extract(certSubjectName, 'CN') + '; Выдан: ' + this.GetCertDate(certFromDate);
+    }
+    ;
+}
+const instance = new CertificateAdjuster();
+export { instance as CertificateAdjuster };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/crypto.api.service.mjs

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import { EndpointBaseService } from 'myrtex-ui-composite';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class CryptoApiService extends EndpointBaseService {
+    constructor(http, injector) {
+        super(http, injector);
+        this.http = http;
+        this.injector = injector;
+        this.urlCrypto = '/cryptopro/api';
+        this.urlSigner = '/signer/api/v1';
+    }
+    verify(data) {
+        return this.http.post(`${this.urlCrypto}/cryptopro/verify`, data);
+    }
+    validate(data) {
+        return this.http.post(`${this.urlSigner}/jinn/validate`, { data });
+    }
+}
+CryptoApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CryptoApiService, deps: [{ token: i1.HttpClient }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+CryptoApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CryptoApiService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CryptoApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/crypto.base.service.mjs

@@ -0,0 +1,15 @@
+export class CryptoBaseService {
+    constructor() {
+        this.available = false;
+        this.options = {};
+    }
+    init() {
+        return Promise.reject('Not implemented');
+    }
+    ;
+    auth() {
+        return Promise.resolve(true);
+    }
+    ;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3J5cHRvLmJhc2Uuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL215cnRleC1tZi1zaWduZXIvc3JjL2xpYi9zZXJ2aWNlcy9jcnlwdG8uYmFzZS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxpQkFBaUI7SUFBOUI7UUFFUyxjQUFTLEdBQUcsS0FBSyxDQUFDO1FBQ3pCLFlBQU8sR0FBUSxFQUFFLENBQUM7SUFTcEIsQ0FBQztJQVBDLElBQUk7UUFDRixPQUFPLE9BQU8sQ0FBQyxNQUFNLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUMzQyxDQUFDO0lBQUEsQ0FBQztJQUVGLElBQUk7UUFDRixPQUFPLE9BQU8sQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDL0IsQ0FBQztJQUFBLENBQUM7Q0FDSCIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBDcnlwdG9CYXNlU2VydmljZSB7XHJcblxyXG4gIHB1YmxpYyBhdmFpbGFibGUgPSBmYWxzZTtcclxuICBvcHRpb25zOiBhbnkgPSB7fTtcclxuXHJcbiAgaW5pdCgpOiBQcm9taXNlPENyeXB0b0Jhc2VTZXJ2aWNlPiB7XHJcbiAgICByZXR1cm4gUHJvbWlzZS5yZWplY3QoJ05vdCBpbXBsZW1lbnRlZCcpO1xyXG4gIH07XHJcblxyXG4gIGF1dGgoKTogUHJvbWlzZTxib29sZWFuPiB7XHJcbiAgICByZXR1cm4gUHJvbWlzZS5yZXNvbHZlKHRydWUpO1xyXG4gIH07XHJcbn1cclxuIl19

package/esm2020/lib/services/crypto.service.mjs

@@ -0,0 +1,116 @@
+import { CryptoProAsyncService } from './cryptopro/crypto.pro.async.service';
+import { Injectable } from '@angular/core';
+import { CryptoProTsService } from './cryptopro/crypto.pro.ts.service';
+import * as i0 from "@angular/core";
+export class CryptoService {
+    constructor() {
+        this.handlers = new Map();
+        this.selectPromise = null;
+        this._initialized = false;
+        this._withLog = false;
+    }
+    async startUp(withLog) {
+        this._withLog = !!withLog;
+        if (!this._initialized) {
+            this.registerHandler({
+                key: CryptoProAsyncService.key,
+                name: 'КриптоПро',
+                service: new CryptoProAsyncService(),
+                sign: true,
+                default: true
+            });
+            this.registerHandler({
+                key: CryptoProTsService.key,
+                name: 'КриптоПро',
+                service: new CryptoProTsService(),
+                sign: true,
+                default: false
+            });
+            await this.init();
+            this._initialized = true;
+        }
+        this.log('Handlers init completed');
+        return Promise.resolve();
+    }
+    registerHandler(options) {
+        this.log('Register handler', options);
+        options.disabled = false;
+        this.handlers.set(options.key, options);
+    }
+    ;
+    disableHandler(key) {
+        const handler = this.handlers.get(key);
+        if (handler) {
+            handler.disabled = true;
+        }
+    }
+    ;
+    getHandler(key) {
+        const handler = this.getActiveHandlers()
+            .find(x => x.key == key);
+        if (handler) {
+            return Promise.resolve(handler);
+        }
+        return Promise.reject(`Not found ${key} handler`);
+    }
+    ;
+    getDefaultHandler() {
+        const handler = this.getActiveHandlers()
+            .find(x => x.default);
+        if (handler) {
+            return Promise.resolve(handler);
+        }
+        return Promise.reject(`Not found default handler`);
+    }
+    ;
+    getService(key) {
+        const handler = this.handlers.get(key);
+        if (handler) {
+            return Promise.resolve(handler.service);
+        }
+        return Promise.reject(`Not found ${key}`);
+    }
+    ;
+    getActiveHandlers() {
+        const active = new Array();
+        this.handlers.forEach(s => {
+            if (!s.disabled) {
+                active.push(s);
+            }
+        });
+        return active;
+    }
+    ;
+    log(...args) {
+        if (this._withLog) {
+            console.log(args);
+        }
+    }
+    ;
+    async init() {
+        this.log('Initialize handlers');
+        const promises = [];
+        this.handlers.forEach(handler => {
+            handler.service.available = false;
+            this.log('Initialize ' + handler.name);
+            const promise = handler.service.init().then((result) => {
+                result.available = true;
+                this.log('Handler init success', result);
+            }).catch(reason => {
+                this.log('Handler init fail', reason);
+            });
+            promises.push(promise);
+        });
+        return await Promise.all(promises);
+    }
+    ;
+}
+CryptoService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CryptoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CryptoService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CryptoService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CryptoService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crypto.service.js","sourceRoot":"","sources":["../../../../../projects/myrtex-mf-signer/src/lib/services/crypto.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { CryptoProAsyncService } from './cryptopro/crypto.pro.async.service';\r\nimport { Injectable } from '@angular/core';\r\nimport { CryptoBaseService } from './crypto.base.service';\r\nimport { CryptoProTsService } from './cryptopro/crypto.pro.ts.service';\r\n\r\nexport interface CryptoHandler {\r\n  key: string;\r\n  name: string;\r\n  service: CryptoBaseService;\r\n  sign: boolean;\r\n  default: boolean;\r\n  disabled?: boolean;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class CryptoService {\r\n\r\n  handlers: Map<string, CryptoHandler> = new Map<string, CryptoHandler>();\r\n  selectPromise: any = null;\r\n  private _initialized = false;\r\n  private _withLog = false;\r\n\r\n  public async startUp(withLog? : boolean): Promise<void> {\r\n    this._withLog = !!withLog;\r\n\r\n    if (!this._initialized) {\r\n      this.registerHandler({\r\n        key: CryptoProAsyncService.key,\r\n        name: 'КриптоПро',\r\n        service: new CryptoProAsyncService(),\r\n        sign: true,\r\n        default: true\r\n      });\r\n      this.registerHandler({\r\n        key: CryptoProTsService.key,\r\n        name: 'КриптоПро',\r\n        service: new CryptoProTsService(),\r\n        sign: true,\r\n        default: false\r\n      });\r\n      await this.init();\r\n      this._initialized = true;\r\n    }\r\n    this.log('Handlers init completed');\r\n    return Promise.resolve();\r\n  }\r\n\r\n  public registerHandler(options: CryptoHandler) {\r\n    this.log('Register handler', options);\r\n\r\n    options.disabled = false;\r\n    this.handlers.set(options.key, options);\r\n  };\r\n\r\n  public disableHandler(key: string): void {\r\n    const handler = this.handlers.get(key);\r\n    if (handler) {\r\n      handler.disabled = true;\r\n    }\r\n  };\r\n\r\n  public getHandler(key: string): Promise<CryptoHandler> {\r\n    const handler = this.getActiveHandlers()\r\n      .find(x => x.key == key);\r\n\r\n    if (handler) {\r\n      return Promise.resolve(handler);\r\n    }\r\n    return Promise.reject(`Not found ${key} handler`);\r\n  };\r\n\r\n  public getDefaultHandler() : Promise<CryptoHandler> {\r\n    const handler = this.getActiveHandlers()\r\n      .find(x => x.default);\r\n\r\n    if (handler) {\r\n      return Promise.resolve(handler);\r\n    }\r\n    return Promise.reject(`Not found default handler`);\r\n  };\r\n\r\n  public getService<T extends CryptoBaseService>(key: string): Promise<T> {\r\n    const handler = this.handlers.get(key);\r\n    if (handler) {\r\n      return Promise.resolve(handler.service as T);\r\n    }\r\n    return Promise.reject(`Not found ${key}`);\r\n  };\r\n\r\n  public getActiveHandlers(): Array<CryptoHandler> {\r\n    const active = new Array<CryptoHandler>();\r\n    this.handlers.forEach(s => {\r\n      if (!s.disabled) {\r\n        active.push(s);\r\n      }\r\n    });\r\n    return active;\r\n  };\r\n\r\n  private log(...args: any[]) {\r\n    if (this._withLog) {\r\n      console.log(args);\r\n    }\r\n  };\r\n\r\n  private async init(): Promise<any> {\r\n    this.log('Initialize handlers');\r\n\r\n    const promises: Array<Promise<any>> = [];\r\n    this.handlers.forEach(handler => {\r\n      handler.service.available = false;\r\n\r\n      this.log('Initialize ' + handler.name);\r\n\r\n      const promise = handler.service.init().then((result) => {\r\n        result.available = true;\r\n        this.log('Handler init success', result);\r\n      }).catch(reason => {\r\n        this.log('Handler init fail', reason);\r\n      });\r\n\r\n      promises.push(promise);\r\n    });\r\n\r\n    return await Promise.all(promises);\r\n  };\r\n}\r\n"]}

package/esm2020/lib/services/cryptopro/crypto.pro.async.service.mjs

@@ -0,0 +1,30 @@
+import { CryptoProBaseService } from './crypto.pro.base.service';
+export class CryptoProAsyncService extends CryptoProBaseService {
+    constructor() {
+        super();
+    }
+    async signXml(certificate, data) {
+        let signer = await window.cadesplugin.CreateObjectAsync("CAdESCOM.CPSigner" /* CPSigner */);
+        await signer.propset_Certificate(certificate);
+        let timestamp_service_url = 'http://testca.cryptopro.ru/tsp/tsp.srf';
+        await signer.propset_TSAAddress(timestamp_service_url);
+        let signed = await window.cadesplugin.CreateObjectAsync("CAdESCOM.SignedXML" /* SignedXML */);
+        let encodedXml = btoa(unescape(encodeURIComponent(data)));
+        await signed.propset_Content(encodedXml);
+        let cades_xml_signature_type_enveloped = 80;
+        await signed.propset_SignatureType(cades_xml_signature_type_enveloped);
+        const signedData = await signed.Sign(signer);
+        return signedData;
+    }
+    async signBase64(certificate, data, detached = false) {
+        let signer = await window.cadesplugin.CreateObjectAsync("CAdESCOM.CPSigner" /* CPSigner */);
+        await signer.propset_Certificate(certificate);
+        let signed = await window.cadesplugin.CreateObjectAsync("CAdESCOM.CadesSignedData" /* CadesSignedData */);
+        await signed.propset_ContentEncoding(1 /* CADESCOM_BASE64_TO_BINARY */);
+        await signed.propset_Content(data);
+        const signedData = await signed.SignCades(signer, 1 /* CADESCOM_CADES_BES */, detached);
+        return signedData;
+    }
+}
+CryptoProAsyncService.key = 'cryptoproasync';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3J5cHRvLnByby5hc3luYy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbXlydGV4LW1mLXNpZ25lci9zcmMvbGliL3NlcnZpY2VzL2NyeXB0b3Byby9jcnlwdG8ucHJvLmFzeW5jLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBT0EsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFakUsTUFBTSxPQUFPLHFCQUFzQixTQUFRLG9CQUFvQjtJQUk3RDtRQUNFLEtBQUssRUFBRSxDQUFDO0lBQ1YsQ0FBQztJQUVNLEtBQUssQ0FBQyxPQUFPLENBQUMsV0FBZ0IsRUFBRSxJQUFZO1FBQ2pELElBQUksTUFBTSxHQUFxQixNQUFNLE1BQU0sQ0FBQyxXQUFXLENBQUMsaUJBQWlCLG9DQUFrQixDQUFDO1FBQzVGLE1BQU0sTUFBTSxDQUFDLG1CQUFtQixDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBRTlDLElBQUkscUJBQXFCLEdBQUcsd0NBQXdDLENBQUM7UUFDckUsTUFBTSxNQUFNLENBQUMsa0JBQWtCLENBQUMscUJBQXFCLENBQUMsQ0FBQztRQUV2RCxJQUFJLE1BQU0sR0FBcUIsTUFBTSxNQUFNLENBQUMsV0FBVyxDQUFDLGlCQUFpQixzQ0FBbUIsQ0FBQztRQUU3RixJQUFJLFVBQVUsR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLGtCQUFrQixDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUMxRCxNQUFNLE1BQU0sQ0FBQyxlQUFlLENBQUMsVUFBVSxDQUFDLENBQUM7UUFFekMsSUFBSSxrQ0FBa0MsR0FBRyxFQUFFLENBQUM7UUFDNUMsTUFBTSxNQUFNLENBQUMscUJBQXFCLENBQUMsa0NBQWtDLENBQUMsQ0FBQztRQUV2RSxNQUFNLFVBQVUsR0FBRyxNQUFNLE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7UUFFN0MsT0FBTyxVQUFVLENBQUM7SUFDcEIsQ0FBQztJQUVNLEtBQUssQ0FBQyxVQUFVLENBQUMsV0FBZ0IsRUFBRSxJQUFZLEVBQUUsV0FBb0IsS0FBSztRQUMvRSxJQUFJLE1BQU0sR0FBcUIsTUFBTSxNQUFNLENBQUMsV0FBVyxDQUFDLGlCQUFpQixvQ0FBa0IsQ0FBQztRQUM1RixNQUFNLE1BQU0sQ0FBQyxtQkFBbUIsQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUU5QyxJQUFJLE1BQU0sR0FBeUIsTUFBTSxNQUFNLENBQUMsV0FBVyxDQUFDLGlCQUFpQixrREFBeUIsQ0FBQztRQUV2RyxNQUFNLE1BQU0sQ0FBQyx1QkFBdUIsbUNBQTBELENBQUM7UUFDL0YsTUFBTSxNQUFNLENBQUMsZUFBZSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBRW5DLE1BQU0sVUFBVSxHQUFHLE1BQU0sTUFBTSxDQUFDLFNBQVMsQ0FBQyxNQUFNLDhCQUEwQyxRQUFRLENBQUMsQ0FBQztRQUVwRyxPQUFPLFVBQVUsQ0FBQztJQUNwQixDQUFDOztBQXRDc0IseUJBQUcsR0FBRyxnQkFBZ0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XHJcbiAgQXN5bmMsXHJcbiAgQ0FERVNDT01fQ0FERVNfVFlQRSxcclxuICBDQURFU0NPTV9DT05URU5UX0VOQ09ESU5HX1RZUEUsXHJcbiAgQ0FERVNDT01fU1RPUkVfTE9DQVRJT04sIENBUElDT01fU1RPUkVfTkFNRVMsIENBUElDT01fU1RPUkVfT1BFTl9NT0RFLFxyXG4gIFByb2dJZHNcclxufSBmcm9tICdjYWRlc3BsdWdpbi10eXBlcyc7XHJcbmltcG9ydCB7IENyeXB0b1Byb0Jhc2VTZXJ2aWNlIH0gZnJvbSAnLi9jcnlwdG8ucHJvLmJhc2Uuc2VydmljZSc7XHJcblxyXG5leHBvcnQgY2xhc3MgQ3J5cHRvUHJvQXN5bmNTZXJ2aWNlIGV4dGVuZHMgQ3J5cHRvUHJvQmFzZVNlcnZpY2Uge1xyXG5cclxuICBwdWJsaWMgc3RhdGljIHJlYWRvbmx5IGtleSA9ICdjcnlwdG9wcm9hc3luYyc7XHJcblxyXG4gIGNvbnN0cnVjdG9yKCkge1xyXG4gICAgc3VwZXIoKTtcclxuICB9XHJcblxyXG4gIHB1YmxpYyBhc3luYyBzaWduWG1sKGNlcnRpZmljYXRlOiBhbnksIGRhdGE6IHN0cmluZyk6IFByb21pc2U8c3RyaW5nPiB7XHJcbiAgICBsZXQgc2lnbmVyOiBBc3luYy5JQ1BTaWduZXI2ID0gYXdhaXQgd2luZG93LmNhZGVzcGx1Z2luLkNyZWF0ZU9iamVjdEFzeW5jKFByb2dJZHMuQ1BTaWduZXIpO1xyXG4gICAgYXdhaXQgc2lnbmVyLnByb3BzZXRfQ2VydGlmaWNhdGUoY2VydGlmaWNhdGUpO1xyXG5cclxuICAgIGxldCB0aW1lc3RhbXBfc2VydmljZV91cmwgPSAnaHR0cDovL3Rlc3RjYS5jcnlwdG9wcm8ucnUvdHNwL3RzcC5zcmYnO1xyXG4gICAgYXdhaXQgc2lnbmVyLnByb3BzZXRfVFNBQWRkcmVzcyh0aW1lc3RhbXBfc2VydmljZV91cmwpO1xyXG5cclxuICAgIGxldCBzaWduZWQ6IEFzeW5jLklTaWduZWRYTUwgPSBhd2FpdCB3aW5kb3cuY2FkZXNwbHVnaW4uQ3JlYXRlT2JqZWN0QXN5bmMoUHJvZ0lkcy5TaWduZWRYTUwpO1xyXG5cclxuICAgIGxldCBlbmNvZGVkWG1sID0gYnRvYSh1bmVzY2FwZShlbmNvZGVVUklDb21wb25lbnQoZGF0YSkpKTtcclxuICAgIGF3YWl0IHNpZ25lZC5wcm9wc2V0X0NvbnRlbnQoZW5jb2RlZFhtbCk7XHJcblxyXG4gICAgbGV0IGNhZGVzX3htbF9zaWduYXR1cmVfdHlwZV9lbnZlbG9wZWQgPSA4MDtcclxuICAgIGF3YWl0IHNpZ25lZC5wcm9wc2V0X1NpZ25hdHVyZVR5cGUoY2FkZXNfeG1sX3NpZ25hdHVyZV90eXBlX2VudmVsb3BlZCk7XHJcblxyXG4gICAgY29uc3Qgc2lnbmVkRGF0YSA9IGF3YWl0IHNpZ25lZC5TaWduKHNpZ25lcik7XHJcbiAgICBcclxuICAgIHJldHVybiBzaWduZWREYXRhO1xyXG4gIH1cclxuXHJcbiAgcHVibGljIGFzeW5jIHNpZ25CYXNlNjQoY2VydGlmaWNhdGU6IGFueSwgZGF0YTogc3RyaW5nLCBkZXRhY2hlZDogYm9vbGVhbiA9IGZhbHNlKTogUHJvbWlzZTxzdHJpbmc+IHtcclxuICAgIGxldCBzaWduZXI6IEFzeW5jLklDUFNpZ25lcjYgPSBhd2FpdCB3aW5kb3cuY2FkZXNwbHVnaW4uQ3JlYXRlT2JqZWN0QXN5bmMoUHJvZ0lkcy5DUFNpZ25lcik7XHJcbiAgICBhd2FpdCBzaWduZXIucHJvcHNldF9DZXJ0aWZpY2F0ZShjZXJ0aWZpY2F0ZSk7XHJcblxyXG4gICAgbGV0IHNpZ25lZDogQXN5bmMuSUNQU2lnbmVkRGF0YTUgPSBhd2FpdCB3aW5kb3cuY2FkZXNwbHVnaW4uQ3JlYXRlT2JqZWN0QXN5bmMoUHJvZ0lkcy5DYWRlc1NpZ25lZERhdGEpO1xyXG5cclxuICAgIGF3YWl0IHNpZ25lZC5wcm9wc2V0X0NvbnRlbnRFbmNvZGluZyhDQURFU0NPTV9DT05URU5UX0VOQ09ESU5HX1RZUEUuQ0FERVNDT01fQkFTRTY0X1RPX0JJTkFSWSk7XHJcbiAgICBhd2FpdCBzaWduZWQucHJvcHNldF9Db250ZW50KGRhdGEpO1xyXG5cclxuICAgIGNvbnN0IHNpZ25lZERhdGEgPSBhd2FpdCBzaWduZWQuU2lnbkNhZGVzKHNpZ25lciwgQ0FERVNDT01fQ0FERVNfVFlQRS5DQURFU0NPTV9DQURFU19CRVMsIGRldGFjaGVkKTtcclxuXHJcbiAgICByZXR1cm4gc2lnbmVkRGF0YTtcclxuICB9XHJcbn1cclxuIl19

package/esm2020/lib/services/cryptopro/crypto.pro.base.service.mjs

@@ -0,0 +1,47 @@
+import getCadesplugin from 'async-cadesplugin';
+import { CryptoBaseService } from '../crypto.base.service';
+import { CertificateAdjuster } from '../certificate.adjuster';
+export class CryptoProBaseService extends CryptoBaseService {
+    constructor() {
+        super();
+    }
+    async init() {
+        await getCadesplugin();
+        return Promise.resolve(this);
+    }
+    ;
+    async getCertificates() {
+        const store = await window.cadesplugin.CreateObjectAsync("CAdESCOM.Store" /* Store */);
+        await store.Open(2 /* CAPICOM_CURRENT_USER_STORE */, "My" /* CAPICOM_MY_STORE */, 2 /* CAPICOM_STORE_OPEN_MAXIMUM_ALLOWED */);
+        let storeCerts = await store.Certificates;
+        let count = await storeCerts.Count;
+        let certificates = [];
+        for (let i = 1; i <= count; i++) {
+            let cert = await storeCerts.Item(i);
+            let validFromDate = new Date(await cert.ValidFromDate);
+            let validToDate = new Date(await cert.ValidToDate);
+            const subjectName = await cert.SubjectName;
+            certificates.push({
+                id: i,
+                certificate: cert,
+                subjectName: subjectName,
+                name: CertificateAdjuster.GetCertInfoString(subjectName, validFromDate),
+                cn: CertificateAdjuster.GetCertName(subjectName),
+                fio: CertificateAdjuster.GetCertFio(subjectName),
+                post: CertificateAdjuster.GetCertPost(subjectName),
+                ogrn: CertificateAdjuster.GetCertOgrn(subjectName),
+                organization: CertificateAdjuster.GetCertOrg(subjectName),
+                inn: CertificateAdjuster.GetCertInn(subjectName),
+                validFromDate: validFromDate.toLocaleDateString('ru-RU'),
+                validToDate: validToDate.toLocaleDateString('ru-RU'),
+                thumbprint: await cert.Thumbprint,
+                issuerName: await cert.IssuerName,
+                serialNumber: await cert.SerialNumber,
+                isExpired: validToDate < new Date()
+            });
+        }
+        await store.Close();
+        return certificates;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/cryptopro/crypto.pro.ts.service.mjs

@@ -0,0 +1,50 @@
+import { CryptoProBaseService } from './crypto.pro.base.service';
+export class CryptoProTsService extends CryptoProBaseService {
+    constructor() {
+        super();
+    }
+    get TIMESTAMP_SERVICE_URL() {
+        return 'http://testca.cryptopro.ru/tsp/tsp.srf';
+    }
+    async sign(certificate, data) {
+        const store = await window.cadesplugin.CreateObjectAsync("CAdESCOM.Store" /* Store */);
+        await store.Open(2 /* CAPICOM_CURRENT_USER_STORE */, "My" /* CAPICOM_MY_STORE */, 2 /* CAPICOM_STORE_OPEN_MAXIMUM_ALLOWED */);
+        let signer = await window.cadesplugin.CreateObjectAsync("CAdESCOM.CPSigner" /* CPSigner */);
+        await signer.propset_Certificate(certificate);
+        let signedXML = await window.cadesplugin.CreateObjectAsync("CAdESCOM.SignedXML" /* SignedXML */);
+        let publicKey = await certificate.PublicKey();
+        let algorithm = await publicKey.Algorithm;
+        let algorithmOid = await algorithm.Value;
+        let { signMethod, digestMethod } = this.getSigningMethods(algorithmOid);
+        //await signer.propset_Options(api.CAPICOM_CERTIFICATE_INCLUDE_WHOLE_CHAIN);
+        await signer.propset_TSAAddress(this.TIMESTAMP_SERVICE_URL);
+        if (data) {
+            let encodedXml = btoa(unescape(encodeURIComponent(data)));
+            await signedXML.propset_Content(encodedXml);
+        }
+        await signedXML.propset_SignatureType(0 /* CADESCOM_XML_SIGNATURE_TYPE_ENVELOPED */);
+        await signedXML.propset_SignatureMethod(signMethod);
+        await signedXML.propset_DigestMethod(digestMethod);
+        let signature = await signedXML.Sign(signer);
+        await store.Close();
+        return signature;
+    }
+    getSigningMethods(algorithmOid) {
+        let signMethod = '', digestMethod = '';
+        if (algorithmOid == '1.2.643.7.1.1.1.1') { // алгоритм подписи ГОСТ Р 34.10-2012 с ключом 256 бит
+            signMethod = 'urn:ietf:params:xml:ns:cpxmlsec:algorithms:gostr34102012-gostr34112012-256';
+            digestMethod = 'urn:ietf:params:xml:ns:cpxmlsec:algorithms:gostr34112012-256';
+        }
+        else if (algorithmOid == '1.2.643.7.1.1.1.2') { // алгоритм подписи ГОСТ Р 34.10-2012 с ключом 512 бит
+            signMethod = 'urn:ietf:params:xml:ns:cpxmlsec:algorithms:gostr34102012-gostr34112012-512';
+            digestMethod = 'urn:ietf:params:xml:ns:cpxmlsec:algorithms:gostr34112012-512';
+        }
+        else if (algorithmOid == '1.2.643.2.2.19') { // алгоритм ГОСТ Р 34.10-2001
+            signMethod = 'urn:ietf:params:xml:ns:cpxmlsec:algorithms:gostr34102001-gostr3411';
+            digestMethod = 'urn:ietf:params:xml:ns:cpxmlsec:algorithms:gostr3411';
+        }
+        return { signMethod, digestMethod };
+    }
+}
+CryptoProTsService.key = 'cryptoprots';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/download.service.mjs

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import { EndpointBaseService } from 'myrtex-ui-composite';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class DownloadService extends EndpointBaseService {
+    constructor(http, injector) {
+        super(http, injector);
+        this.http = http;
+        this.injector = injector;
+        this.url = '/signer/api/v1/download';
+    }
+    xml(url) {
+        return this.http.get(url, {
+            headers: new HttpHeaders()
+                .set('Content-Type', 'text/xml'),
+            responseType: 'text'
+        });
+    }
+    pdf(url) {
+        return this.http.get(url, {
+            headers: new HttpHeaders()
+                .set('Content-Type', 'application/pdf'),
+            responseType: 'blob'
+        });
+    }
+}
+DownloadService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: DownloadService, deps: [{ token: i1.HttpClient }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+DownloadService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: DownloadService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: DownloadService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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