private static byte[] enhanceSignatureInternal(IConfig config, SignatureActionRequest request, String[] cRLs) throws CAdESException {
        var signature = new CAdESSignature(request.getSignatureData(), request.getSignedData(), null);
        CryptoMethods.setOCSP(signature, cRLs);

        // Список всех подписантов в исходной подписи.
        var srcSignerInfos = new ArrayList<SignerInformation>();

        for (CAdESSigner signer : signature.getCAdESSignerInfos())
            srcSignerInfos.add(signer.getSignerInfo());
            
        // Получаем только первую подпись, усовершенствуем ее. Остальных не трогаем.
        CAdESSigner srcSigner = CryptoMethods.GetSigner(signature);

        // Исключаем ее из исходного списка, т.к. ее место займет усовершенствованная подпись.
        srcSignerInfos.remove(srcSigner.getSignerInfo());

        // Усовершенствуем до CAdES-A.
        String digestAlgOID = srcSigner.getSignerInfo().getDigestAlgOID();
        AttributeTable unsignedAttributes = srcSigner.getSignerUnsignedAttributes();

        var chain = new LinkedList<X509Certificate>();

        srcSigner = srcSigner.enhance(config.getProviderName(),
                    digestAlgOID, 
                    chain,
                    config.getTSAAddress(),
                    CAdESType.CAdES_A);

public static void setOCSP(CAdESSignature signature, String[] cRLs) {
        if(cRLs != null && cRLs.length >= 2) {
            String[] targetArray = new String[cRLs.length - 1];
            System.arraycopy(cRLs, 1, targetArray, 0, cRLs.length - 1);
            setOCSP(signature, cRLs[0], targetArray);
        }
    }

    private static void setOCSP(CAdESSignature signature, String responderURL, String[] thumbs) {
       Options options = new Options();
       setSingleOcsp(options, responderURL);
       setAuthorizedOCSPs(options, thumbs);
       setOcspList(options, responderURL);
       signature.setOptions(options);
    }

    public static Options setSingleOcsp(Options options, String OCSP) {
        return options.setRevocationURLStrategy(
                new SingleRevocationURLStrategy() {
                    @Override
                    public RevocationURL get(ValidatingData validatingData) throws AdESException {
                        return new RevocationURL() {
                            @Override
                            public ConnectionParameters getConnectionParameters() {
                                return null;
                            }

                            @Override
                            public RevocationURLActionOnError onError(Throwable throwable) {
                                return null;
                            }

                            @Override
                            public String get() {
                                return OCSP;
                            }
                        };
                    }
                }
        );
    }

    public static Options setAuthorizedOCSPs(Options options, String[] thumbs) {
        return options.setRevocationPermissions(new RevocationPermission() {
            @Override
            public boolean isAuthorizedIssuer(ValidatingPermissionData validatingPermissionData) {
                X509Certificate cert = validatingPermissionData.getValidatingRevocationData().getCertificate();
                try {
                    MessageDigest digest = MessageDigest.getInstance("SHA-1");
                    digest.update(cert.getEncoded());
                    String thumb = CryptoMethods.bytesToHex(digest.digest());
                    boolean result = false;
                    for (String walk : thumbs)
                        if (thumb.equalsIgnoreCase(walk)) {
                            result = true;
                            break;
                        }
                    return result;

                } catch (NoSuchAlgorithmException | CertificateEncodingException e) {
                    throw new RuntimeException(e);
                }
            }
        });
    }

    private static final char[] HEX_ARRAY = "0123456789ABCDEF".toCharArray();
    public static String bytesToHex(byte[] bytes) {
        char[] hexChars = new char[bytes.length * 2];
        for (int j = 0; j < bytes.length; j++) {
            int v = bytes[j] & 0xFF;
            hexChars[j * 2] = HEX_ARRAY[v >>> 4];
            hexChars[j * 2 + 1] = HEX_ARRAY[v & 0x0F];
        }
        return new String(hexChars);
    }

    public static Options setOcspList(Options options, String OCSP) {
        return options.setRevocationURLStrategy(new CollectionRevocationURLStrategy() {
            @Override
            public RevocationURLCollection get(ValidatingData validatingData) throws AdESException {
                return new RevocationURLCollection() {
                    @Override
                    public Collection<RevocationURL> get() {
                        return Collections.singleton(
                                new RevocationURL() {
                                    @Override
                                    public ConnectionParameters getConnectionParameters() {
                                        return null;
                                    }

                                    @Override
                                    public RevocationURLActionOnError onError(Throwable throwable) {
                                        return null;
                                    }

                                    @Override
                                    public String get() {
                                        return OCSP;
                                    }
                                }
                        );
                    }
                };
            }
        });
    }