System.setProperty("javax.net.ssl.keyStoreType", Consts.KeyStoreType);
System.setProperty("javax.net.ssl.keyStorePassword", Consts.KeyStorePassword);
System.setProperty("javax.net.ssl.trustStoreType", Consts.KeyStoreTrustedType);
System.setProperty("javax.net.ssl.trustStore", Consts.KeyStoreTrustedFile);
System.setProperty("javax.net.ssl.trustStorePassword", Consts.KeyStoreTrustedPassword);
System.setProperty("javax.net.debug", "ssl");

Security.addProvider(new JCP()); // JCP
Security.addProvider(new CryptoProvider()); // JCryptoP
Security.addProvider(new RevCheck()); // RevCheck
Security.addProvider(new Provider());

keyStore = KeyStore.getInstance(JCP.HD_STORE_NAME);
KeyManagerFactory kf = KeyManagerFactory.getInstance("GostX509");

keyStore.load(null, Consts.KeyStorePassword.toCharArray());
kf.init(keyStore, Consts.KeyStorePassword.toCharArray());

privateKey = (PrivateKey) keyStore.getKey(Consts.KeyAlias, Consts.KeyStorePassword.toCharArray());
cert = (X509Certificate) keyStore.getCertificate(Consts.KeyAlias);

TrustManagerFactory tf = TrustManagerFactory.getInstance("GostX509");

trustStore = KeyStore.getInstance(Consts.KeyStoreTrustedType, Consts.KeyStoreTrustedProvider);
trustStore.load(new FileInputStream(new File(Consts.KeyStoreTrustedFile)), Consts.KeyStoreTrustedPassword.toCharArray());

tf.init(trustStore);

sslContext.init(kf.getKeyManagers(), tf.getTrustManagers(), null);

gostSSLSocketFactory = sslContext.getSocketFactory();

final Document verifyDocument = msg.getSOAPPart().getEnvelope().getOwnerDocument();

final NodeList nl = verifyDocument.getElementsByTagNameNS(XMLSignature.XMLNS, "Signature");

if (nl.getLength() == 0) {
	return;
}


MessageDigestEngineProvider messageDigestEngineProvider = new CustomizableMessageDigestEngineProvider();

	        
CertificateValidationProvider certValidator = KeyStoreUtils.createCertificateValidationProvider(GostConfig.trustStore);
	        
	        
			
XadesVerificationProfile vp = new XadesVerificationProfile(certValidator);
vp.withBinding(MessageDigestEngineProvider.class, messageDigestEngineProvider);
vp.withBinding(QualifyingPropertiesUnmarshaller.class, QualifyingPropertiesUnmarshaller2.class);
vp.withQualifyingPropertyVerifier(SigningTimeData.class, NoSigningTimeVerifier.class);
vp.withQualifyingPropertyVerifier(SigningCertificateData.class, SigningCertificateVerifier2.class);
	        

	        
for (int i = 0; i < nl.getLength(); i++) {
	        	
	final XadesVerifier verifier = vp.newVerifier();
	            
	final SignatureSpecificVerificationOptions verificationOptions = new SignatureSpecificVerificationOptions();
	final Element signatureElement = (Element) nl.item(i);
	XAdESVerificationResult vr = verifier.verify(signatureElement, verificationOptions);
}

static void checkSignedPropertiesIncorporation(Element qualifyingPropsElem, Reference signedPropsRef) throws QualifyingPropertiesIncorporationException
    {
        Element signedPropsElem = DOMHelper.getFirstChildElement(qualifyingPropsElem);
        if (signedPropsElem == null
                || !signedPropsElem.getLocalName().equals(QualifyingProperty.SIGNED_PROPS_TAG)
                || !signedPropsElem.getNamespaceURI().equals(QualifyingProperty.XADES_XMLNS))
        {
            throw new QualifyingPropertiesIncorporationException("SignedProperties not found as the first child of QualifyingProperties.");
        }

        DOMHelper.useIdAsXmlId(signedPropsElem);

        // Only QualifyingProperties in the signature's document are supported.
        // XML-DSIG 4.3.3.2: "a same-document reference is defined as a URI-Reference
        // that consists of a hash sign ('#') followed by a fragment"
        if (!signedPropsRef.getURI().startsWith("#"))
        {
            throw new QualifyingPropertiesIncorporationException("Only QualifyingProperties in the signature's document are supported");
        }

        try
        {
            Node sPropsNode = signedPropsRef.getNodesetBeforeFirstCanonicalization().getSubNode();
            if (sPropsNode == null || sPropsNode.getNodeType() != Node.ELEMENT_NODE)
            {
                throw new QualifyingPropertiesIncorporationException("The supposed reference over signed properties doesn't cover an element.");
            }

            // The referenced signed properties element must be the child of qualifying properties.
            Element referencedSignedPropsElem = (Element) sPropsNode;
            if (referencedSignedPropsElem != signedPropsElem)
            {
                throw new QualifyingPropertiesIncorporationException("The referenced SignedProperties are not contained by the proper QualifyingProperties element");
            }
        } catch (XMLSignatureException ex)
        {
            throw new QualifyingPropertiesIncorporationException("Cannot get the referenced SignedProperties", ex);
        }
    }