@it-enterprise/digital-signature 1.1.7 → 1.2.2

package/src/DigitalSignature.js

@@ -1,9 +1,12 @@
-import { EndUser, EndUserConstants, EndUserProxySettings, EndUserError, KSPSettings, EndUserCertificate, EndUserKeyMedia } from "../euscp/euscp";
+import { EndUser, EndUserConstants, EndUserProxySettings, EndUserError, KSPSettings, EndUserCertificate, EndUserKeyMedia, EndUserSignContainerInfo } from "../euscp/euscp";
 import { DigitalSignatureKeyType, PrivateKeyInfo, FilePrivateKeyInfo, HardwarePrivateKeyInfo, KspPrivateKeyInfo } from "./Models";
-import { downloadData, readFile } from "./Utils";
+import { downloadAndSignFiles, downloadData, format, readFile, signAlgoToHashAlgo } from "./Utils";
 import Resourses from "./Resourses.json";
 import GlSign from "./GlSign";
 
+const PRIVATE_KEY_TYPE = "PKType";
+const PRIVATE_KEY_INFO = "PKInfo";
+
 export default class DigitalSignature {
   /**
    * @param {DigitalSignatureSettings} settingsProvider
@@ -33,30 +36,85 @@ export default class DigitalSignature {
     depositsign.ksp = EndUserConstants.EU_KSP_IIT;
     depositsign.address = "https://depositsign.com/api/v1/it-enterprise/sign-server";
     depositsign.directAccess = true;
+    depositsign.needQRCode = false;
 
     const diia = new KSPSettings();
-    diia.name = "ДіЯ";
+    diia.name = "Дія.Підпис";
     diia.ksp = EndUserConstants.EU_KSP_DIIA;
     diia.directAccess = true;
-    diia.mobileAppName = "ДіЯ";
+    diia.mobileAppName = "Дія";
     diia.address = "https://diia-sign.it.ua/KSPSign";
     diia.systemId = "diia-sign-it-ent";
-
-    /** @type {KSPSettings} */
-    this._KSPs = [depositsign, diia];
+    diia.needQRCode = true;
+
+    const smartId = new KSPSettings();
+    smartId.name = "Приватбанк - хмарний підпис \"SmartID\"";
+    smartId.ksp = EndUserConstants.EU_KSP_PB;
+    smartId.directAccess = true;
+    smartId.mobileAppName = "Приват24";
+    smartId.address = "https://acsk.privatbank.ua/cloud/api/back/";
+    smartId.clientIdPrefix = "IEIS_";
+    smartId.confirmationURL = "https://www.privat24.ua/rd/kep";
+    smartId.needQRCode = true;
+
+    const vchasno = new KSPSettings();
+    vchasno.name = "Вчасно - хмарний підпис";
+    vchasno.ksp = EndUserConstants.EU_KSP_IIT;
+    vchasno.address = "https://cs.vchasno.ua/ss/";
+    vchasno.directAccess = true;
+    vchasno.needQRCode = false;
+
+    const cloudKey = new KSPSettings();
+    cloudKey.name = "ТОВ «ЦСК «Україна» - хмарний підпис CloudKey";
+    cloudKey.ksp = EndUserConstants.EU_KSP_PB;
+    cloudKey.directAccess = true;
+    cloudKey.mobileAppName = "CloudKey";
+    cloudKey.address = "https://sid.uakey.com.ua/smartid/iit/";
+    cloudKey.clientIdPrefix = "DIIA_2";
+    cloudKey.confirmationURL = "https://sid.uakey.com.ua/kep?hash=rd/kep";
+    cloudKey.needQRCode = true;
+
+    const esign = new KSPSettings();
+    esign.name = "ESign - хмарний підпис";
+    esign.ksp = EndUserConstants.EU_KSP_IIT;
+    esign.address = "https://cabinet.e-life.com.ua/api/EDG/Sign";
+    esign.directAccess = true;
+    esign.needQRCode = false;
+
+    const idd = new KSPSettings();
+    idd.name = "ІДД ДПС - хмарний підпис";
+    idd.ksp = EndUserConstants.EU_KSP_IIT;
+    idd.address = "https://smart-sign.tax.gov.ua/";
+    idd.port = "443";
+    idd.directAccess = true;
+    idd.clientIdType = 1;
+    idd.needQRCode = false;
+
+    this._KSPs = {
+      depositsign,
+      diia,
+      smartId,
+      vchasno,
+      cloudKey,
+      esign,
+      idd,
+      asArray: function() {
+        return [
+          depositsign,
+          diia,
+          smartId,
+          vchasno,
+          cloudKey,
+          esign,
+          idd
+        ];
+      }
+    };
 
     /** @type {PrivateKeyInfo} */
     this._readedKey = null;
   }
 
-  get PRIVATE_KEY_TYPE() {
-    return "_PrivateKeyType";
-  }
-
-  get PRIVATE_KEY_INFO() {
-    return "_PrivateKeyInfo";
-  }
-
   /**
    * Считанный приватный ключ
    * @type {PrivateKeyInfo}
@@ -78,15 +136,17 @@ export default class DigitalSignature {
    * @param {number} type
    */
   async setLibraryType(type) {
-    if (this._euSign) {
-      await this._euSign.ResetPrivateKey();
-    }
-
     switch (type) {
       case DigitalSignatureKeyType.Token:
+        if (this._euSign === this._euSignKeyMedia && await this._euSign.IsInitialized()) {
+          return;
+        }
         this._euSign = this._euSignKeyMedia;
         break;
       default:
+        if (this._euSign === this._euSignFile) {
+          return;
+        }
         this._euSign = this._euSignFile;
         break;
     }
@@ -104,7 +164,6 @@ export default class DigitalSignature {
    * @returns {Promise<number>} Текущий тип библиотеки
    */
   async initialise() {
-
     if (!this._glSign) {
       this._glSign = await Promise.resolve(this._settingsProvider.getGlSign());
     }
@@ -187,23 +246,35 @@ export default class DigitalSignature {
     }
 
     if (!this._euSettings) {
-      const certificates = await this._settings.certificatesProvider.loadCertificates();
+      let certificates;
+      try {
+        certificates = await this._settings.certificatesProvider.loadCertificates();
+      } catch (error) {
+        if (error && error.code === EndUserError.EU_ERROR_DOWNLOAD_FILE) {
+          throw {
+            code: EndUserError.EU_ERROR_DOWNLOAD_FILE,
+            message: this._resourses.DownloadingRootCertificatesError
+          };
+        } else {
+          throw error;
+        }
+      }
 
       this._euSettings = {
-        language: this._settings.language,
+        language: this._language,
         encoding: "UTF-16LE",
         httpProxyServiceURL: this._settings.httpProxyServiceURL,
         directAccess: true,
         CAs: certificates.CAs,
         CACertificates: certificates.CACertificates,
-        mssServiceURL: this._settings.mssServiceURL,
-        KSPs: this._KSPs,
+        KSPs: this.KSPs,
         allowedKeyMediaTypes: [
           "е.ключ BIFIT iToken",
           "криптомод. ІІТ Гряда-61",
-          "криптомод. ІІТ Гряда-301",
           "е.ключ ІІТ Алмаз-1К",
+          "е.ключ ІІТ Алмаз-1К (Bluetooth)",
           "е.ключ ІІТ Кристал-1",
+          "криптомод. ІІТ Гряда-301",
           "ID-карта громадянина (БЕН)",
           "е.ключ ІІТ Алмаз-1К (PKCS#11)",
           "е.ключ ІІТ Кристал-1 (PKCS#11)",
@@ -243,6 +314,7 @@ export default class DigitalSignature {
     if (euSign === this._euSignKeyMedia && !await this._euSignFile.IsInitialized()) {
       this._euSignFile.SetRuntimeParameter(EndUserConstants.EU_SIGN_TYPE_PARAMETER, EndUserConstants.EndUserSignType.CAdES_X_Long);
     }
+
     return this.getLibraryType();
   }
 
@@ -256,35 +328,93 @@ export default class DigitalSignature {
 
   /**
    * Получить список подключённых устройств
-   * @returns {Promise<Array<EndUserKeyMedia>>} Информация о владельце ключа
+   * @returns {Promise<Array<EndUserKeyMedia>>} Список подключённых устройств
    */
   async getKeyMedias() {
-    if (this._euSign != this._euSignKeyMedia) {
-      await this.setLibraryType(DigitalSignatureKeyType.Token);
-    }
-    return this._euSign.GetKeyMedias();
+    await this.setLibraryType(DigitalSignatureKeyType.Token);
+    return this._euSignKeyMedia.GetKeyMedias();
   }
 
+  /**
+   * Считать ключ по параметрам
+   * @param {PrivateKeyInfo} keyInfo - Параметры ключа
+   */
+   async readPrivateKeyByInfo(keyInfo) {
+    if (!keyInfo) {
+      throw {
+        code: EndUserError.EU_ERROR_BAD_PARAMETER,
+        message: this._resourses.BadParameter + " keyInfo"
+      };
+    }
+
+    await this.setLibraryType(keyInfo.keyType);
+    switch (keyInfo.keyType) {
+      case DigitalSignatureKeyType.File:
+        return await this.readFileKey(keyInfo.privateKey, keyInfo.password, keyInfo.certificates);
+      case DigitalSignatureKeyType.Token:
+        return await this.readHardwareKey(keyInfo.keyMedia, keyInfo.certificates);
+      case DigitalSignatureKeyType.KSP:
+        return await this.readPrivateKeyKSP(keyInfo.ksp, keyInfo.kspUserId, false);
+    }
+   }
+
   /**
    * Считать аппаратный ключ
    * @param {EndUserKeyMedia} keyMedia - Параметры аппаратного ключа
    * @param {Array<Uint8Array>?} certs - Сертификаты ключа (при необходимости)
    */
   async readHardwareKey(keyMedia, certs) {
-    if (this._euSign != this._euSignKeyMedia) {
-      await this.setLibraryType(DigitalSignatureKeyType.Token);
+    await this.setLibraryType(DigitalSignatureKeyType.Token);
+
+    if (!keyMedia) {
+      throw {
+        code: EndUserError.EU_ERROR_BAD_PARAMETER,
+        message: this._resourses.BadParameter + " keyMedia"
+      };
+    }
+    if (!keyMedia.password) {
+      throw {
+        code: EndUserError.EU_ERROR_BAD_PARAMETER,
+        message: this._resourses.PasswordNotSet
+      };
     }
+
     if (Array.isArray(certs)) {
       certs = await Promise.all(certs.map(cert => cert instanceof File || cert instanceof Blob ? readFile(cert) : cert));
     }
-    const ownerInfo = await this._euSign.ReadPrivateKey(keyMedia, certs, this._selectedIssuerCN);
-    this._readedKey = new HardwarePrivateKeyInfo(
-      DigitalSignatureKeyType.Token,
-      ownerInfo,
-      await this._euSign.GetOwnCertificates(),
-      keyMedia
-    );
-    return this._readedKey;
+
+    try {
+      const ownerInfo = await this._euSign.ReadPrivateKey(keyMedia, certs, this._selectedIssuerCN);
+      this._readedKey = new HardwarePrivateKeyInfo(
+        DigitalSignatureKeyType.Token,
+        ownerInfo,
+        await this._euSign.GetOwnCertificates(),
+        keyMedia
+      );
+      return this._readedKey;
+    } catch (error) {
+      if (error && error.code === EndUserError.EU_ERROR_CERT_NOT_FOUND) {
+        if (!this._selectedIssuerCN) {
+          throw {
+            code: EndUserError.EU_ERROR_CERT_NOT_FOUND,
+            message: this._resourses.ReadPrivateKeyCAAutoDetectError
+          };
+        } else if (this._selectedIssuerCN) {
+          if (!this._selectedCA.cmpAddress) {
+            throw {
+              code: EndUserError.EU_ERROR_CERT_NOT_FOUND,
+              message: format(this._resourses.ReadPrivateKeyNeedCertificateError, this._selectedIssuerCN)
+            };
+          } else {
+            throw {
+              code: EndUserError.EU_ERROR_CERT_NOT_FOUND,
+              message: format(this._resourses.ReadPrivateKeyInvalidCAError, this._selectedIssuerCN)
+            };
+          }
+        }
+      }
+      throw error;
+    }
   }
 
   /**
@@ -294,26 +424,60 @@ export default class DigitalSignature {
    * @param {Array<Uint8Array|File>?} certs - Сертификаты ключа (при необходимости)
    */
   async readFileKey(privateKey, password, certs) {
-    let keyName = "Key";
-    if (this._euSign != this._euSignFile) {
-      await this.setLibraryType(DigitalSignatureKeyType.File);
+    await this.setLibraryType(DigitalSignatureKeyType.File);
+
+    if (!privateKey) {
+      throw {
+        code: EndUserError.EU_ERROR_BAD_PARAMETER,
+        message: this._resourses.BadParameter + " keyMedia"
+      };
+    }
+    if (!password) {
+      throw {
+        code: EndUserError.EU_ERROR_BAD_PARAMETER,
+        message: this._resourses.PasswordNotSet
+      };
     }
+
     if (privateKey instanceof File || privateKey instanceof Blob) {
-      keyName = privateKey.name;
       privateKey = await readFile(privateKey);
     }
     if (Array.isArray(certs)) {
       certs = await Promise.all(certs.map(cert => cert instanceof File || cert instanceof Blob ? readFile(cert) : cert));
     }
-    const ownerInfo = await this._euSign.ReadPrivateKeyBinary(privateKey, password, certs, this._selectedIssuerCN);
-    this._readedKey = new FilePrivateKeyInfo(
-      DigitalSignatureKeyType.File,
-      ownerInfo,
-      await this._euSign.GetOwnCertificates(),
-      privateKey,
-      this.glSign.AllowSavePassword ? password : undefined
-    );
-    return this._readedKey;
+    try {
+      const ownerInfo = await this._euSign.ReadPrivateKeyBinary(privateKey, password, certs, this._selectedIssuerCN);
+      this._readedKey = new FilePrivateKeyInfo(
+        DigitalSignatureKeyType.File,
+        ownerInfo,
+        await this._euSign.GetOwnCertificates(),
+        privateKey,
+        password
+      );
+      return this._readedKey;
+    } catch (error) {
+      if (error && error.code === EndUserError.EU_ERROR_CERT_NOT_FOUND) {
+        if (!this._selectedIssuerCN) {
+          throw {
+            code: EndUserError.EU_ERROR_CERT_NOT_FOUND,
+            message: this._resourses.ReadPrivateKeyCAAutoDetectError
+          };
+        } else if (this._selectedIssuerCN) {
+          if (!this._selectedCA.cmpAddress) {
+            throw {
+              code: EndUserError.EU_ERROR_CERT_NOT_FOUND,
+              message: format(this._resourses.ReadPrivateKeyNeedCertificateError, this._selectedIssuerCN)
+            };
+          } else {
+            throw {
+              code: EndUserError.EU_ERROR_CERT_NOT_FOUND,
+              message: format(this._resourses.ReadPrivateKeyInvalidCAError, this._selectedIssuerCN)
+            };
+          }
+        }
+      }
+      throw error;
+    }
   }
 
   /**
@@ -322,9 +486,8 @@ export default class DigitalSignature {
    * @returns {Promise<EndUserJKSPrivateKeyInfo[]>}
    */
   async getJKSPrivateKeys(jks) {
-    if (this._euSign != this._euSignFile) {
-      await this.setLibraryType(DigitalSignatureKeyType.File);
-    }
+    await this.setLibraryType(DigitalSignatureKeyType.File);
+
     if (jks instanceof File || jks instanceof Blob) {
       jks = await readFile(jks);
     }
@@ -340,56 +503,44 @@ export default class DigitalSignature {
   }
 
   /**
-   * Считать ключ с DepositSign
-   * @param {string} userId - Идентификатор пользователя
-   * @param {boolean?} getCerts - Получать информацию о ключе пользователя. Это приведёт к дополнительному запросу на подписание
-   */
+     * Считать ключ с DepositSign
+     * @param {string} userId - Идентификатор пользователя
+     * @param {boolean?} getCerts - Получать информацию о ключе пользователя. Это приведёт к дополнительному запросу на подписание
+     */
   async readPrivateKeyDepositsign(userId, getCerts = false) {
-    return await this.readPrivateKeyKSP(userId, this.KSPs[0], getCerts);
+    return await this.readPrivateKeyKSP(userId, this._KSPs.depositsign, getCerts);
   }
 
   /**
    * Считать ключ с Дiя
    * @param {boolean?} getCerts - Получать информацию о ключе пользователя. Это приведёт к дополнительному запросу на подписание
    */
-   async readPrivateKeyDiia(getCerts = false) {
-    const diia = "DIIA";
-    if (sessionStorage[diia] != "+") {
-      try {
-        sessionStorage[diia] = await downloadData(new URL(this.KSPs[1].address).origin + "/diia");
-      } catch {
-        throw {
-          message: this._resourses.DiiaError + `<a target="_blank" href="${window.origin}">${window.origin}</a></li><ul>`
-        };
-      }
-    }
-
-    return await this.readPrivateKeyKSP(null, this.KSPs[1], getCerts);
+  async readPrivateKeyDiia(getCerts = false) {
+    return await this.readPrivateKeyKSP(null, this.KSPs.diia, getCerts);
   }
 
   /**
    * Считать ключ с облачного провайдера
-   * @param {string} userId - Идентификатор пользователя
-   * @param {string|KSPSettings} ksp - Идентификатор облачного провайдера
+   * @param {KSPSettings} ksp - Идентификатор облачного провайдера
+   * @param {string?} userId - Идентификатор пользователя
    * @param {boolean?} getCerts - Получать информацию о ключе пользователя. Это приведёт к дополнительному запросу на подписание
-   * @param {number?} keyType - Тип ключа
    */
-  async readPrivateKeyKSP(userId, ksp, getCerts = false) {
-    if (ksp != EndUserConstants.EndUserKSP.DIIA && typeof ksp !== "string") {
-      ksp = ksp.name;
-    }
-    const keyType = ksp == "DepositSign" ? DigitalSignatureKeyType.Depositsign : ksp == "diia" ? DigitalSignatureKeyType.Diia : DigitalSignatureKeyType.KSP;
-    if (this._euSign != this._euSignFile) {
-      await this.setLibraryType(keyType);
+  async readPrivateKeyKSP(ksp, userId, getCerts = false) {
+    await this.setLibraryType(DigitalSignatureKeyType.KSP);
+
+    if (ksp.ksp === EndUserConstants.EU_KSP_DIIA) {
+      await this._diiaCheckAccess();
     }
-    const ownerInfo = await this._euSign.ReadPrivateKeyKSP(userId, ksp, getCerts);
+
+    const ownerInfo = await this._euSign.ReadPrivateKeyKSP(userId, ksp.name, getCerts);
     if (getCerts && !ownerInfo) {
       throw {
+        code: EndUserError.EU_ERROR_KEY_MEDIAS_READ_FAILED,
         message: this._resourses.PrivateKeyNotReaded
       };
     }
     this._readedKey = new KspPrivateKeyInfo(
-      keyType,
+      DigitalSignatureKeyType.KSP,
       ownerInfo,
       getCerts ? await this._euSign.GetOwnCertificates() : [],
       userId,
@@ -419,7 +570,7 @@ export default class DigitalSignature {
    * @returns {KSPSettings[]} Список поддержирживаемых облачных провайдеров
    */
   get KSPs() {
-    return this._KSPs;
+    return this._KSPs.asArray();
   }
 
   /**
@@ -427,16 +578,18 @@ export default class DigitalSignature {
    * @returns {Promise<boolean>} считан ли ключ
    */
   async isPrivateKeyReaded() {
-    return !!this._readedKey && await this._euSign.IsPrivateKeyReaded();
+    try {
+      return !!this._readedKey && await this._euSign.IsPrivateKeyReaded();
+    } catch {
+      return false;
+    }
   }
 
   /**
    * Очистить считанный ключ
    */
   async resetPrivateKey() {
-    await Promise.all([
-      this._euSign.ResetPrivateKey()
-    ]);
+    await this._euSign.ResetPrivateKey();
     this._readedKey = null;
   }
 
@@ -445,7 +598,7 @@ export default class DigitalSignature {
    * @returns {Promise<Array<CASettings>>}
    */
   async getCAs() {
-    return await this._euSign.GetCAs();
+    return await this._euSignFile.GetCAs();
   }
 
   /**
@@ -469,49 +622,78 @@ export default class DigitalSignature {
 
   /**
    * Подписать данные
-   * @param {Uint8Array | string | NamedeData | Array<Uint8Array | string | NamedeData>} data - Данные для подписи. Можно передавать данные в массиве для наложения нескольких подписей за раз
-   * @param {boolean?} internal - Внутренняя или внешняя подпись
+   * @param {Uint8Array | string | NamedData | Array<Uint8Array | string | NamedData>} data - Данные для подписи. Можно передавать данные в массиве для наложения нескольких подписей за раз
+   * @param {EndUserSignContainerInfo?} signType - Тип подписи
    * @param {boolean?} asByteArray - Возвращать подпись в виде массива байтов. По умолчанию подпись возвращается в виде строки в base64
    */
-  async signData(data, internal, asByteArray) {
-    if (typeof internal !== "boolean") {
-      internal = false;
+  async signData(data, signType, asByteArray) {
+    if (signType === true) {
+      // Обратная совместимость. Если передать в параметре значение true, дожна создаться подпись CAdES Enveloped (внутренняя)
+      signType = new EndUserSignContainerInfo();
+      signType.type = EndUserConstants.EndUserSignContainerType.CAdES;
+      signType.subType = EndUserConstants.EndUserCAdESType.Enveloped;
+    } else if (typeof signType != "object") {
+      // По умолчанию создаётся подпись CAdES Detached
+      signType = new EndUserSignContainerInfo();
+      signType.type = EndUserConstants.EndUserSignContainerType.CAdES;
+      signType.subType = EndUserConstants.EndUserCAdESType.Detached;
     }
     if (typeof asByteArray !== "boolean") {
       asByteArray = false;
     }
-    return await this._euSign.SignDataEx(this._readedKey.getSignAlgo(), data, !internal, true, !asByteArray);
+
+    if (this.readedKey.keyType === DigitalSignatureKeyType.KSP && signType.type !== EndUserConstants.EndUserSignContainerType.CAdES) {
+      throw {
+        code: EndUserError.EU_ERROR_NOT_SUPPORTED,
+        message: this._resourses.KSPSignFormatError
+      };
+    }
+
+    if (signType.type === EndUserConstants.EndUserSignContainerType.ASiC) {
+      const signLevel = signType.asicSignType === EndUserConstants.EndUserASiCSignType.CAdES ? EndUserConstants.EndUserSignType.CAdES_X_Long : EndUserConstants.EndUserXAdESSignLevel.B_LT;
+      return await this._euSign.ASiCSignData(this._readedKey.getSignAlgo(), signType.subType, signType.asicSignType, signLevel, data, !asByteArray);
+    } else if (signType.type === EndUserConstants.EndUserSignContainerType.XAdES) {
+      let returnArray = true;
+      if (!Array.isArray(data)) {
+        data = [data];
+        returnArray = false;
+      }
+      data = data.map((e, i) => !e.name && !e.val ? { name: "data" + i, val: e } : e);
+      const signs = [];
+      for (let i = 0; i < data.length; i++) {
+        const result = await this._euSign.XAdESSignData(this._readedKey.getSignAlgo(), signType.subType, EndUserConstants.EndUserXAdESSignLevel.B_LT, data[i], !asByteArray);
+        signs[i] = result;
+      }
+      return returnArray ? signs : signs[0];
+    } else if (signType.type === EndUserConstants.EndUserSignContainerType.PAdES) {
+      return await this._euSign.PDFSignData(this._readedKey.getSignAlgo(), data, EndUserConstants.EndUserPAdESSignLevel.B_T, !asByteArray);
+    } else if (signType.type === EndUserConstants.EndUserSignContainerType.CAdES) {
+      if (signType.subType === EndUserConstants.EndUserCAdESType.Detached) {
+        const hash = await this._euSign.HashData(this._readedKey.getHashAlgo(), data, !asByteArray);
+        return await this._euSign.SignHash(this._readedKey.getSignAlgo(), hash, true, !asByteArray);
+      } else {
+        return await this._euSign.SignDataEx(this._readedKey.getSignAlgo(), data, false, true, !asByteArray);
+      }
+    } else {
+      throw {
+        code: EndUserError.EU_ERROR_BAD_PARAMETER,
+        message: this._resourses.BadSignatureType
+      };
+    }
   }
 
   /**
    * Подписать файл
-   * @param {string | NamedeData | Array<string | NamedeData>} fileUrl - Ссылка на загрузку файла. Можно передавать несколько ссылок в массиве для наложения нескольких подписей за раз
-   * @param {boolean?} internal - Внутренняя или внешняя подпись
+   * @param {string | NamedData | Array<string | NamedData>} fileUrl - Ссылка на загрузку файла. Можно передавать несколько ссылок в массиве для наложения нескольких подписей за раз
+   * @param {EndUserSignContainerInfo?} signType - Тип подписи
    * @param {boolean?} asByteArray - Возвращать подпись в виде массива байт. По умолчанию подпись возвращается в виде строки в base64
    */
-  async signFile(fileUrl, internal, asByteArray) {
-    if (typeof internal !== "boolean") {
-      internal = false;
-    }
-    if (typeof asByteArray !== "boolean") {
-      asByteArray = false;
-    }
-    const isNamedData = Array.isArray(fileUrl) && fileUrl.every(url => typeof url === "object") || typeof fileUrl === "object";
-    let data;
-    if (Array.isArray(fileUrl)) {
-      data = await Promise.all(fileUrl.map(function(url) {
-        const downloadedData = downloadData(isNamedData ? url.val : url, "binary");
-        return isNamedData ? {name: url.name, val: downloadedData} : downloadedData;
-      }));
-    } else {
-      const downloadedData = await downloadData(isNamedData ? fileUrl.val : fileUrl, "binary");
-      data = isNamedData ? {name: fileUrl.name, val: downloadedData} : downloadedData;
-    }
-    return await this.signData(data, internal, asByteArray);
+  async signFile(fileUrl, signType, asByteArray) {
+    return await downloadAndSignFiles(fileUrl, async (data) => await this.signData(data, signType, asByteArray));
   }
 
   /**
-   * Подписать хеш
+   * Подписать хеш подписью CAdES Detached
    * @param {Uint8Array | string | NamedData | Array<Uint8Array | string> | NamedData} hash - Хеш файла. Можно передавать несколько хешей в массиве для наложения нескольких подписей за раз
    * @param {boolean?} asByteArray - Возвращать подпись в виде массива байт. По умолчанию подпись возвращается в виде строки в base64
    */
@@ -523,38 +705,57 @@ export default class DigitalSignature {
   }
 
   /**
-   * Подписать хеш из файла
+   * Подписать хеш из файла подписью CAdES Detached
    * @param {string | NamedData | Array<string | NamedData>} hashUrl - Ссылка на скачивание хеша. Можно передавать несколько ссылок в массиве для наложения нескольких подписей за раз
    * @param {boolean?} asByteArray - Возвращать подпись в виде массива байт. По умолчанию подпись возвращается в виде строки в base64
    */
   async signFileHash(hashUrl, asByteArray) {
-    if (typeof asByteArray !== "boolean") {
-      asByteArray = false;
-    }
-    const isNamedData = Array.isArray(hashUrl) && hashUrl.every(url => typeof url === "object") || typeof hashUrl === "object";
-    let hash;
-    if (Array.isArray(hashUrl)) {
-      hash = await Promise.all(hashUrl.map(function(url) {
-        const downloadedData = downloadData(isNamedData ? url.val : url, "binary");
-        return isNamedData ? {name: url.name, val: downloadedData} : downloadedData;
-      }));
-    } else {
-      const downloadedData = await downloadData(hashUrl, "binary");
-      hash = isNamedData ? {name: hashUrl.name, val: downloadedData} : downloadedData;
-    }
-    return await this.signHash(hash, asByteArray);
+    return await downloadAndSignFiles(hashUrl, async (hash) => await this.signHash(hash, asByteArray));
+  }
+
+  /**
+   * Получить данные о типе подписи
+   * @param {string | Uint8Array} sign - Подпись
+   */
+  async getSignContainerInfo(sign) {
+    return await this._euSign.GetSignContainerInfo(sign);
   }
 
   /**
-   * Проверить внешнюю подпись
+   * Проверить подпись (Соответствие подписанных данных не проверяется)
    * @param {Uint8Array | string} data - Подписанные данные
    * @param {Uint8Array | string} sign - Подпись
    * @param {number?} signIndex - Номер подписи. -1 что бы проверить все подписи
    */
   async verifyData(data, sign, signIndex) {
     if (!Number.isInteger(signIndex)) {
-      signIndex = 0;
+      signIndex = -1;
     }
+    const signContainerInfo = await this._euSign.GetSignContainerInfo(sign.val || sign);
+
+    if (signContainerInfo.type === EndUserConstants.EndUserSignContainerType.ASiC) {
+      return await this._euSign.ASiCVerifyData(sign, signIndex);
+    } else if (signContainerInfo.type === EndUserConstants.EndUserSignContainerType.PAdES) {
+      return await this._euSign.PDFVerifyData(sign, signIndex);
+    } else if (signContainerInfo.type === EndUserConstants.EndUserSignContainerType.XAdES) {
+      return await this._euSign.XAdESVerifyData(data, sign.val || sign, signIndex);
+    } else if (signContainerInfo.type === EndUserConstants.EndUserSignContainerType.CAdES) {
+      if (signContainerInfo.subType === EndUserConstants.EndUserCAdESType.Detached) {
+        if (!data) {
+          throw {
+            code: EndUserError.EU_ERROR_BAD_PARAMETER,
+            message: this._resourses.BadParameter + " data"
+          };
+        }
+        const signerInfo = await this._euSign.GetSigner(sign, signIndex, false);
+        const hashAlgo = signAlgoToHashAlgo((Array.isArray(signerInfo) ? signerInfo[0] : signerInfo).infoEx.publicKeyType);
+        const hash = await this._euSign.HashData(hashAlgo, data);
+        return await this._euSign.VerifyHash(hash.val || hash, sign.val || sign, signIndex);
+      } else {
+        return await this._euSign.VerifyDataInternal(sign.val || sign, signIndex);
+      }
+    }
+
     return await this._euSign.VerifyData(data, sign, signIndex);
   }
 
@@ -578,10 +779,7 @@ export default class DigitalSignature {
    * @param {number?} signIndex - Номер подписи. -1 что бы проверить все подписи
    */
   async verifyDataInternal(sign, signIndex) {
-    if (!Number.isInteger(signIndex)) {
-      signIndex = 0;
-    }
-    return await this._euSign.VerifyDataInternal(sign, signIndex);
+    return await this.verifyData(null, sign, signIndex);
   }
 
   /**
@@ -595,20 +793,20 @@ export default class DigitalSignature {
   }
 
   /**
-   * Проверить подпись хеша
+   * Проверить подпись хеша (Только CAdES Detached)
    * @param {Uint8Array | string} hash - Хеш подписанного файла
    * @param {Uint8Array | string} sign - Подпись
    * @param {number?} signIndex - Номер подписи. -1 что бы проверить все подписи
    */
   async verifyHash(hash, sign, signIndex) {
     if (!Number.isInteger(signIndex)) {
-      signIndex = 0;
+      signIndex = -1;
     }
-    return await this._euSign.VerifyHash(hash, sign, signIndex);
+    return await this._euSign.VerifyHash(hash.val || hash, sign.val || sign, signIndex);
   }
 
   /**
-   * Проверить подпись хеша из файла
+   * Проверить подпись хеша из файла (Только CAdES Detached)
    * @param {string} hashUrl - Ссылка на загрузку файла
    * @param {string} signUrl - Ссылка на загрузку подписи
    * @param {number?} signIndex - Номер подписи. -1 что бы проверить все подписи
@@ -623,62 +821,57 @@ export default class DigitalSignature {
 
   /**
    * Выполнить подписание данных с проверкой подписи
-   * @param {Uint8Array | string | NamedData} data - данные для подписи
-   * @param {boolean?} internal - Накладывать внутреннюю или внешнюю подпись. По умолчанию накладывается внешняя.
-   */
-  async signDataEx(data, internal) {
-    if (typeof internal !== "boolean") {
-      internal = false;
-    }
-    const isNamedData = typeof data === "object" && !(data instanceof Uint8Array);
-    if (!internal) {
-      const hashedData = await this._euSign.HashData(this._readedKey.getHashAlgo(), isNamedData ? data.val : data, false);
-      if(isNamedData) {
-        data.val = hashedData;
-      } else {
-        data = hashedData;
+   * @param {Uint8Array | string | NamedData | Array<Uint8Array | string | NamedData>} data - Данные для подписи. Можно передавать данные в массиве для наложения нескольких подписей за раз
+   * @param {EndUserSignContainerInfo?} signType - Тип подписи
+   */
+  async signDataEx(data, signType) {
+    const signs = await this.signData(data, signType);
+
+    if (Array.isArray(data)) {
+      const result = [];
+      for (let i = 0; i < signs.length; i++) {
+        const sign = signs[i];
+        let signInfo = await this.verifyData(data[i].val || data[i], sign.val || sign);
+        if (Array.isArray(signInfo)) {
+          signInfo = signInfo[signInfo.length - 1];
+        }
+        result[i] = {
+          Success: true,
+          Sign: sign.val || sign,
+          SignatureInfo: {
+            Success: true,
+            DateTimeStr: signInfo.timeInfo.time,
+            Signer: signInfo.ownerInfo.subjCN,
+            OwnerInfo: signInfo.ownerInfo
+          }
+        };
       }
-    }
-    const signature = internal ? await this.signData(data, internal) : await this.signHash(data);
-    const signatureInfo = internal ? await this.verifyDataInternal(isNamedData ? signature.val : signature, 0) : await this.verifyHash(isNamedData ? data.val : data, isNamedData ? signature.val : signature);
-    return {
-      Success: true,
-      Sign: isNamedData ? signature.val : signature,
-      SignatureInfo: {
-        Success: true,
-        DateTimeStr: signatureInfo.timeInfo.time,
-        Signer: signatureInfo.ownerInfo.subjCN,
-        OwnerInfo: signatureInfo.ownerInfo
+      return result;
+    } else {
+      let signInfo = await this.verifyData(data.val || data, signs.val || signs);
+      if (Array.isArray(signInfo)) {
+        signInfo = signInfo[signInfo.length - 1];
       }
-    };
+      return {
+        Success: true,
+        Sign: signs.val || signs,
+        SignatureInfo: {
+          Success: true,
+          DateTimeStr: signInfo.timeInfo.time,
+          Signer: signInfo.ownerInfo.subjCN,
+          OwnerInfo: signInfo.ownerInfo
+        }
+      };
+    }
   }
 
   /**
    * Выполнить подписание с проверкой подписи
-   * @param {string | NamedData} fileUrl - ссылка на загрузку файла для подписания
-   * @param {boolean} hash - подписывать хеш
-   */
-  async signFileEx(fileUrl, hash) {
-    const isNamedData = typeof fileUrl === "object";
-    let data = await downloadData(isNamedData ? fileUrl.val : fileUrl, "binary");
-    if(!hash) {
-      data = await this._euSign.HashData(this._readedKey.getHashAlgo(), data, false);
-      if(isNamedData) {
-        data = {name: fileUrl.name, val: data};
-      }
-    }
-    const signature = await this.signHash(data);
-    const signatureInfo = await this.verifyHash(isNamedData ? data.val : data, isNamedData ? signature.val : signature);
-    return {
-      Success: true,
-      Sign: isNamedData ? signature.val : signature,
-      SignatureInfo: {
-        Success: true,
-        DateTimeStr: signatureInfo.timeInfo.time,
-        Signer: signatureInfo.ownerInfo.subjCN,
-        OwnerInfo: signatureInfo.ownerInfo
-      }
-    };
+   * @param {string | NamedData | Array<string> | Array<NamedData>} fileUrl - ссылка на загрузку файла для подписания
+   * @param {EndUserSignContainerInfo?} signType - Тип подписи
+   */
+  async signFileEx(fileUrl, signType) {
+    return await downloadAndSignFiles(fileUrl, async (data) => await this.signDataEx(data, signType));
   }
 
   /**
@@ -686,19 +879,44 @@ export default class DigitalSignature {
    * @param {string | NamedData} hash - хеш для подписания
    */
   async signHashEx(hash) {
-    const isNamedData = typeof hash === "object";
-    const signature = await this.signHash(isNamedData ? hash.val : hash);
-    const signatureInfo = await this.verifyHash(isNamedData ? hash.val : hash, isNamedData ? signature.val : signature);
-    return {
-      Success: true,
-      Sign: isNamedData ? signature.val : signature,
-      SignatureInfo: {
-        Success: true,
-        DateTimeStr: signatureInfo.timeInfo.time,
-        Signer: signatureInfo.ownerInfo.subjCN,
-        OwnerInfo: signatureInfo.ownerInfo
+    const signs = await this.signHash(hash);
+
+    if (Array.isArray(hash)) {
+      const result = [];
+      for (let i = 0; i < signs.length; i++) {
+        const sign = signs[i];
+        let signInfo = await this.verifyHash(hash[i].val || hash[i], sign.val || sign);
+        if (Array.isArray(signInfo)) {
+          signInfo = signInfo[signInfo.length - 1];
+        }
+        result[i] = {
+          Success: true,
+          Sign: sign.val || sign,
+          SignatureInfo: {
+            Success: true,
+            DateTimeStr: signInfo.timeInfo.time,
+            Signer: signInfo.ownerInfo.subjCN,
+            OwnerInfo: signInfo.ownerInfo
+          }
+        };
       }
-    };
+      return result;
+    } else {
+      let signInfo = await this.verifyHash(hash.val || hash, signs.val || signs);
+      if (Array.isArray(signInfo)) {
+        signInfo = signInfo[signInfo.length - 1];
+      }
+      return {
+        Success: true,
+        Sign: signs.val || signs,
+        SignatureInfo: {
+          Success: true,
+          DateTimeStr: signInfo.timeInfo.time,
+          Signer: signInfo.ownerInfo.subjCN,
+          OwnerInfo: signInfo.ownerInfo
+        }
+      };
+    }
   }
 
   /**
@@ -759,18 +977,18 @@ export default class DigitalSignature {
    * @param {boolean} toLocalStorage - Будет ли ключ сохранён после закрытия вкладки
    */
   async storePrivateKeyInfo(privateKeyInfo, toLocalStorage) {
-    if(privateKeyInfo.ksp && (privateKeyInfo.ksp == EndUserConstants.EndUserKSP.DIIA || privateKeyInfo.ksp == this.KSPs[1].name)) {
+    if (privateKeyInfo.ksp && privateKeyInfo.ksp.needQRCode) {
       return;
     }
 
     const storage = toLocalStorage ? localStorage : sessionStorage;
     const keys = await this.getStoredPrivateKeyInfo();
 
-    if(keys.length == 0 || keys.filter(key => key.id == privateKeyInfo.id).length < 1) {
+    if (keys.length == 0 || keys.filter(key => key.id == privateKeyInfo.id).length < 1) {
       const keys = await this.getPrivateKeyInfoFromStorage(toLocalStorage);
       keys.push(privateKeyInfo);
       const data = await this._euSignFile.ProtectDataByPassword(JSON.stringify(keys), "", true);
-      storage[this._userId + this.PRIVATE_KEY_INFO] = data;
+      storage[this._userId + PRIVATE_KEY_INFO] = data;
     }
   }
 
@@ -787,27 +1005,27 @@ export default class DigitalSignature {
 
   async getPrivateKeyInfoFromStorage(fromLocalStorage, keyType) {
     const storage = fromLocalStorage ? localStorage : sessionStorage;
-    const storedKeys = storage[this._userId + this.PRIVATE_KEY_INFO];
+    const storedKeys = storage[this._userId + PRIVATE_KEY_INFO];
 
     let ls;
     const result = [];
-    if(!storedKeys) {
+    if (!storedKeys) {
       return result;
     }
     const data = await this._euSignFile.UnprotectDataByPassword(storedKeys, "", true);
-    try{
+    try {
       ls = JSON.parse(data);
-      if(keyType >= 0) {
+      if (keyType >= 0) {
         ls = ls.filter(key => key.keyType == keyType);
       }
     }
-    catch{
+    catch {
       ls = [];
     }
 
     ls.forEach(key => {
       const password = key.password;
-      if(key.keyType == DigitalSignatureKeyType.File) {
+      if (key.keyType == DigitalSignatureKeyType.File) {
         key.privateKey = new Uint8Array(Object.assign(new Array(), key.privateKey));
         key = new FilePrivateKeyInfo(key.keyType, key.ownerInfo, key.certificates, key.privateKey, key.password);
       }
@@ -834,22 +1052,22 @@ export default class DigitalSignature {
    * Удалить сохранённые ключи
    * @param {string} keyId - Идентификатор ключа
    */
-    async removeStoredPrivateKeyInfo(keyId) {
-      if (keyId === undefined) {
-      localStorage.removeItem(this._userId + this.PRIVATE_KEY_INFO);
-      sessionStorage.removeItem(this._userId + this.PRIVATE_KEY_INFO);
+  async removeStoredPrivateKeyInfo(keyId) {
+    if (keyId === undefined) {
+      localStorage.removeItem(this._userId + PRIVATE_KEY_INFO);
+      sessionStorage.removeItem(this._userId + PRIVATE_KEY_INFO);
     }
-    else{
+    else {
       const localStoredKeys = await this.getPrivateKeyInfoFromStorage(true);
       const sessionStoredKeys = await this.getPrivateKeyInfoFromStorage(false);
       const storage = localStoredKeys.filter(item => item.id == keyId).length > 0 ? localStorage : sessionStorage;
       const keys = storage == localStorage ? localStoredKeys : sessionStoredKeys;
       const keyIndex = keys.findIndex((element) => element.id == keyId);
 
-      if(keyIndex > -1) {
+      if (keyIndex > -1) {
         keys.splice(keyIndex, 1);
         const data = await this._euSignFile.ProtectDataByPassword(JSON.stringify(keys), "", true);
-        storage[this._userId + this.PRIVATE_KEY_INFO] = data;
+        storage[this._userId + PRIVATE_KEY_INFO] = data;
       }
     }
   }
@@ -858,11 +1076,11 @@ export default class DigitalSignature {
    * Получить предпочитаемый тип ключа
    */
    get _preferredKeyType () {
-    const keyType = parseInt(localStorage[this._userId + this.PRIVATE_KEY_TYPE]);
+    const keyType = parseInt(localStorage[this._userId + PRIVATE_KEY_TYPE]);
     if (typeof keyType === "number" && keyType > -1) {
       return keyType;
     } else {
-      localStorage[this._userId + this.PRIVATE_KEY_TYPE] = DigitalSignatureKeyType.File;
+      localStorage[this._userId + PRIVATE_KEY_TYPE] = DigitalSignatureKeyType.File;
       return DigitalSignatureKeyType.File;
     }
   }
@@ -873,15 +1091,36 @@ export default class DigitalSignature {
    */
   set _preferredKeyType (keyType) {
     if (typeof keyType === "number" && keyType > -1) {
-      localStorage[this._userId + this.PRIVATE_KEY_TYPE] = keyType;
+      localStorage[this._userId + PRIVATE_KEY_TYPE] = keyType;
     }
   }
 
   get _resourses() {
-    return Resourses[this._settings.language];
+    return Resourses[this._language];
   }
 
   get _userId () {
-    return typeof this._settings.userId === "function" ? this._settings.userId() : this._settings.userId;
+    return typeof this._settingsProvider.userId === "function" ? this._settingsProvider.userId() : this._settingsProvider.userId;
+  }
+
+  get _language () {
+    return typeof this._settingsProvider.language === "function" ? this._settingsProvider.language() : this._settingsProvider.language;
+  }
+
+  /**
+   * Проверка доступности Дiя
+   */
+  async _diiaCheckAccess() {
+    const diia = "DIIA";
+    if (sessionStorage[diia] != "+") {
+      try {
+        sessionStorage[diia] = await downloadData(new URL(this._KSPs.diia.address).origin + "/diia");
+      } catch {
+        throw {
+          code: EndUserError.EU_ERROR_TRANSMIT_REQUEST,
+          message: this._resourses.DiiaError + `<a target="_blank" href="${window.origin}">${window.origin}</a></li><ul>`
+        };
+      }
+    }
   }
 }