signHash: function (sHashValue, hashAlg, certThumbprint) {
            const signHashByWebPlugin = function (sHashValue, hashAlg, certThumbprint) {
                return new Promise(function (resolve, reject) {
                    cadesplugin.async_spawn(function* (args) {
                        var oStore = yield cadesplugin.CreateObjectAsync("CAPICOM.Store");
                        yield oStore.Open(cadesplugin.CAPICOM_CURRENT_USER_STORE, cadesplugin.CAPICOM_MY_STORE,
                            cadesplugin.CAPICOM_STORE_OPEN_MAXIMUM_ALLOWED);

                        var oStoreCerts = yield oStore.Certificates;
                        var oCertificates = yield oStoreCerts.Find(
                            cadesplugin.CAPICOM_CERTIFICATE_FIND_SHA1_HASH, certThumbprint);
                        var certsCount = yield oCertificates.Count;
                        if (certsCount === 0) {
                            err = "Certificate not found: " + certThumbprint;
                            console.error(err);
                            return args[1](err);
                        }
                        var oCertificate = yield oCertificates.Item(1);

                        var oSigner = yield cadesplugin.CreateObjectAsync("CAdESCOM.CPSigner");
                        yield oSigner.propset_Certificate(oCertificate);
                        yield oSigner.propset_CheckCertificate(true);
                        // Сохраняем всю цепочку сертификатов https://docs.microsoft.com/ru-ru/windows/win32/seccrypto/signer-options
                        yield oSigner.propset_Options(cadesplugin.CAPICOM_CERTIFICATE_INCLUDE_WHOLE_CHAIN);


                        // Создаем объект CAdESCOM.HashedData
                        var oHashedData = yield cadesplugin.CreateObjectAsync("CAdESCOM.HashedData");

                        // Инициализируем объект заранее вычисленным хэш-значением
                        // Алгоритм хэширования нужно указать до того, как будет передано хэш-значение
                        yield oHashedData.propset_Algorithm(hashAlg);
                        yield oHashedData.SetHashValue(sHashValue);

                        var oSignedData = yield cadesplugin.CreateObjectAsync("CAdESCOM.CadesSignedData");
                        // Значение свойства ContentEncoding должно быть задано до заполнения свойства Content
                        //yield oSignedData.propset_ContentEncoding(cadesplugin.CADESCOM_BASE64_TO_BINARY);
                        //yield oSignedData.propset_Content(sHashValue);

                        var sSignedMessage = "";
                        try {
                            sSignedMessage = yield oSignedData.SignHash(oHashedData, oSigner, cadesplugin.CADESCOM_CADES_BES);
                            yield oStore.Close();
                        } catch (err) {
                            e = cadesplugin.getLastError(err);
                            console.error("Failed to create signature. Error: " + e);
                            yield oStore.Close();
                            return args[1](e);
                        }
                        return args[0](sSignedMessage);
                    }, resolve, reject);
                });
            };

fun signHashData(hashData: String, hashAlg: String, currentAlias: String, pin: String?): String? {
        Logger.log("Load key container to sign data.")
        // Тип контейнера по умолчанию.
        val keyStoreType: String = KeyStoreType.currentType()
        Logger.log("Default container type: $keyStoreType")

        // Загрузка ключа и сертификата.
        if (pin != null) {
            load(
                false, keyStoreType,
                currentAlias, pin.toCharArray()
            )
        } else {
            load(
                true, keyStoreType,
                currentAlias, null
            )
        }
        if (privateKey == null) {
            Logger.log("Private key is null.")
            return null
        }

        // Формируем подпись.
        val chain = mutableListOf<X509Certificate>()

        if (certificates != null) {
            for (cert in certificates!!) {
                chain.add(cert as X509Certificate)
            }
        } else {
            chain.add(certificate!!)
        }
        var cAdESSignature = CAdESSignature(true, true)
        cAdESSignature.certificateStore =
            CollectionStore(mutableListOf(X509CertificateHolder(certificate!!.encoded)))

        val setCRL = getCRLsFromAssets()
        Logger.log(
            "Single signature type: " +
                    if (cAdESType == CAdESType.CAdES_BES) "CAdES-BES" else "CAdES-X Long Type 1"
        )
        Logger.log(
            "Add one signer: " +
                    certificate!!.subjectDN + "\n public key Alg  " + certificate!!.publicKey.algorithm
        )

        if (cAdESType == CAdESType.CAdES_BES) {
            cAdESSignature.addSigner(
                JCSP.PROVIDER_NAME, null,
                null, privateKey, chain, cAdESType, null, false, null, null, setCRL, true
            )
        } else {
            cAdESSignature.addSigner(
                JCSP.PROVIDER_NAME, null,
                null, privateKey, chain, cAdESType, CAdESSignVerifyPresenter.TSA_DEFAULT,
                false
            )
        }
        val signatureStream = ByteArrayOutputStream()
        Logger.log(
            "Compute signature for hash '" +
                    hashData + "\n" +
                    hashAlg
        )
        cAdESSignature.open(signatureStream)
        val encodedHash = toBase64(hashData.toByteArray())
        cAdESSignature.update(hashData.toByteArray())
        cAdESSignature.close()
        signatureStream.close()
        val sign = signatureStream.toByteArray()

        Logger.log(sign, true)

        // Проверяем подпись.
        Logger.log(
            "Verify CAdES signature of type: " +
                    if (cAdESType == CAdESType.CAdES_BES) "CAdES-BES" else "CAdES-X Long Type 1"
        )
        cAdESSignature = CAdESSignature(sign, hashData.toByteArray(), cAdESType, true)
        cAdESSignature.verify(chain, setCRL)
        Logger.log("CAdES signature has been created and verified (OK)")
        return toBase64(sign)
    }

fun hexStringToByteArray(s: String): ByteArray {
            val len = s.length
            val data = ByteArray(len / 2)
            var i = 0
            while (i < len) {
                data[i / 2] = ((Character.digit(s[i], 16) shl 4)
                        + Character.digit(s[i + 1], 16)).toByte()
                i += 2
            }
            return data
        }