package isc.jcp;

import java.util.*;

import java.io.IOException;

import org.w3c.dom.Element;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;

import javax.xml.xpath.XPathFactory;
import org.apache.xml.security.exceptions.XMLSecurityException;
import org.apache.ws.security.WSSecurityException;

import java.security.SignatureException;
import java.security.InvalidKeyException;
import java.security.cert.X509Certificate;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateEncodingException;
import java.security.KeyStore;
import java.security.PrivateKey;
import java.security.KeyStoreException;
import java.security.UnrecoverableKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;

import com.objsys.asn1j.runtime.Asn1Exception;
//import javax.swing.JFrame;
//import javax.swing.JOptionPane;

/**
 * Фасад для работы с JCP из веб-сервисов Cache.
 */
public class JcpFacade
{
  private static final String ENVELOPE_NS_URI = "http://schemas.xmlsoap.org/soap/envelope/";
  private static final String WSSE_NS_URI = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd";
  private static final String DS_NS_URI = "http://www.w3.org/2000/09/xmldsig#";
  
  private static XPathFactory xpathFactory = XPathFactory.newInstance();

  /**
   * Формирует ЭЦП в формате XML Signature (ds:Signature).
   *
   * @param xmlFragmentBytes XML-документ, элемент которого подписывается; передается в виде массива байт в кодировке UTF-8
   * @param wsuId значение атрибута wsu:Id подписываемаего элемента
   * @param certFilename имя файла сертификата в формате X.509, соответствующего секретному ключу
   * @param keyPassword пароль для доступа к секретному ключу
   * @return Строка, содержащая XML-элемент ds:Signature.
   * @throws XMLSecurityException
   * @throws IOException
   * @throws CertificateException
   * @throws KeyStoreException
   * @throws NoSuchAlgorithmException
   * @throws UnrecoverableKeyException
   */
   public static String createSignature(byte[] xmlFragmentBytes, String wsuId, String certFilename, String keyPassword, String StoreName)
    throws XMLSecurityException, IOException, CertificateException, KeyStoreException, NoSuchAlgorithmException, UnrecoverableKeyException
  {
    String xmlFragment = new String(xmlFragmentBytes, "UTF-8");
    
    
    JcpUtils.initJcp();
    if (StoreName == null)
    {
      throw new RuntimeException("Не задано имя хранилища");
    }
    //String storename = JcpUtils.getStoreName("c:\\store.cfg"); 
 
    //JcpUtils.ShowMessage(storename);
    
    KeyStore keyStore = JcpUtils.getFloppyStore(StoreName,keyPassword);
    if (keyStore == null)
    {
      throw new RuntimeException("Не удалось получить доступ к хранилищу ключей " + StoreName);
    }
    
    //Test(keyStore);
    
    //JcpUtils.ShowMessage("Получение сертификата");  
    X509Certificate certificate = JcpUtils.getCertificate(certFilename);
    if (certificate == null)
    {
    //    JcpUtils.ShowMessage("Не смогли получить");  
        throw new RuntimeException("Не найден сертификат");
    }
    //JcpUtils.ShowMessage("Получение закрытого ключа");  
    PrivateKey privateKey = getPrivateKey(keyStore, certificate, keyPassword, certFilename);
    if (privateKey == null)
    {
      throw new RuntimeException("Не найден закрытый ключ");
    }
    //JcpUtils.ShowMessage("Работа с xml");  
    Document document = XmlUtils.deserialize(xmlFragment);
    
    IdAttrResourceResolver resolver;
    synchronized(xpathFactory)
    {
      resolver = new IdAttrResourceResolver(xpathFactory);
    }
    
    Element signature = JcpUtils.signDocuments(
        document,
        new String[] {"#" + wsuId},
        resolver,
        certificate,
        privateKey);
   
    return XmlUtils.serializeNode(signature);
  }
   
  /**
   * Проверяет валидность ЭЦП для SOAP-сообщения.
   *
   * @param soapEnvelopeBytes подписанное SOAP-сообщение; передается в виде массива байт в кодировке UTF-8
   * @return Boolean
   * @throws XMLSecurityException
   * @throws IOException
   * @throws WSSecurityException
   * @throws CertificateException
   */
  public static Boolean verifySignature(byte[] soapEnvelopeBytes)
    throws XMLSecurityException, IOException, WSSecurityException, CertificateException
  {
    String soapEnvelope = new String(soapEnvelopeBytes, "UTF-8");
    
    //FileOutputStream f = new FileOutputStream("C://Temp//verifySignature.xml");
    //f.write(soapEnvelopeBytes);
    //f.flush();
  
    Document envelopeDocument = XmlUtils.deserialize(soapEnvelope);

    Element header = findSoapHeader(envelopeDocument);
    if (header == null)
      throw new RuntimeException("Не найден элемент SOAP Header");
    
    NodeList securityNL = header.getElementsByTagNameNS(WSSE_NS_URI, "Security");
    if (securityNL == null || securityNL.getLength() == 0)
    {
      throw new RuntimeException("Не найден элемент WS-Security");
    }
    
    IdAttrResourceResolver resolver;
    synchronized(xpathFactory)
    {
      resolver = new IdAttrResourceResolver(xpathFactory);
    }
    
    JcpUtils.initJcp();
    
    int signaturesVerified = 0;
    for (int i = 0; i < securityNL.getLength(); i++)
    {
      Element signature = getSignatureElement((Element)securityNL.item(i));
      if (signature == null) continue;
      
      if (!JcpUtils.verifySignature(signature, resolver))
      {
        signaturesVerified = -1;
        break;
      }
      
      signaturesVerified++;
    }
    
    if (signaturesVerified == 0)
    {
      throw new RuntimeException("Не найден элемент WS-Security, содержащий элемент Signature");
    }
    
    return Boolean.valueOf(signaturesVerified > -1);
  }
  
  private static Element findSoapHeader(Document envelopeDocument)
  {
    Element header = null;
    Element envelope = envelopeDocument.getDocumentElement();
    
    if (!"Envelope".equals(envelope.getLocalName()) || !ENVELOPE_NS_URI.equals(envelope.getNamespaceURI()))
      throw new RuntimeException("Не найден элемент SOAP Envelope");
    
    Element body = XmlUtils.getFirstChildElement(envelope);
    if (body == null || !ENVELOPE_NS_URI.equals(body.getNamespaceURI()))
      throw new RuntimeException("Не найдены элементы SOAP Header / SOAP Body");
    
    if ("Header".equals(body.getLocalName()))
    {
      header = body;
      body = XmlUtils.getNextChildElement(envelope, header);
      if (body == null || !ENVELOPE_NS_URI.equals(body.getNamespaceURI()))
        throw new RuntimeException("Не найден элемент SOAP Body");
    }

    if (!"Body".equals(body.getLocalName()))
      throw new RuntimeException("Не найден элемент SOAP Body");
    
    return header;
  }
  
  private static Element getSignatureElement(Element security)
  {
    NodeList sigNL = security.getElementsByTagNameNS(DS_NS_URI, "Signature");
    if (sigNL == null || sigNL.getLength() == 0)
    {
      return null;
    }
    else if (sigNL.getLength() > 1)
    {
      throw new RuntimeException("Найдено несколько элементов Signature в рамках одного элемента Security");
    }
    else
    {
      return (Element)sigNL.item(0);
    }
  }
  
  private static PrivateKey getPrivateKey(KeyStore keyStore, X509Certificate certificate, String password, String certFilename)
    throws KeyStoreException, CertificateEncodingException, NoSuchAlgorithmException, UnrecoverableKeyException
  {
    PrivateKey result = null;
    
    Enumeration aliases = keyStore.aliases();
    String alias = JcpUtils.getAlias(certFilename);
    if (alias == null) {
        while (aliases.hasMoreElements())
        {
          alias = (String)aliases.nextElement();

          if (keyStore.isKeyEntry(alias))
          {
            Key key = getKey(keyStore, alias, password);
            if (key instanceof PrivateKey)
            {
              result = (PrivateKey)key;
              X509Certificate floppyCertificate = (X509Certificate)keyStore.getCertificate(alias);

              if (floppyCertificate != null)
              {
                if (Arrays.equals(certificate.getEncoded(), floppyCertificate.getEncoded()))
                  return result;
                else
                  result = null;
              }
            }
          }
        }
    }
    else 
    {
      if (keyStore.isKeyEntry(alias))
      {
        Key key = getKey(keyStore, alias, password);
        if (key instanceof PrivateKey)
        {
          result = (PrivateKey)key;
          X509Certificate floppyCertificate = (X509Certificate)keyStore.getCertificate(alias);

          if (floppyCertificate != null)
          {
            if (Arrays.equals(certificate.getEncoded(), floppyCertificate.getEncoded()))
              return result;
            else
              result = null;
          }
        }
      }
    }
    
    if ((keyStore.size() == 1) && (result != null))
      return result;
    else   
      return null;
  }
  
private static Key getKey(KeyStore keyStore, String Alias, String Password) 
        throws KeyStoreException, NoSuchAlgorithmException, UnrecoverableKeyException
{
    Key key;
    
    if (Password != null)
    {
      key = keyStore.getKey(Alias, Password.toCharArray());
    }
    else
    {
      key = keyStore.getKey(Alias, null);
    }
    return key;
}
/**
   * Формирует ЭЦП для произвольного массива байт.
   *
   * @param data подписываемый массив байт
   * @param certFilename имя файла сертификата в формате X.509, соответствующего секретному ключу
   * @param keyPassword пароль для доступа к секретному ключу
   * @return ЭЦП
   * @throws IOException, KeyStoreException, CertificateException, NoSuchAlgorithmException, UnrecoverableKeyException, SignatureException, Asn1Exception, CertificateEncodingException, InvalidKeyException
   */
  public static byte[] createCMSSignature(byte[] data, String certFilename, String keyPassword, String StoreName)
    throws IOException, KeyStoreException, CertificateException, NoSuchAlgorithmException, UnrecoverableKeyException, SignatureException, Asn1Exception, CertificateEncodingException, InvalidKeyException
  {
    JcpUtils.initJcp();
    
    if (StoreName == null)
    {
      throw new RuntimeException("Не задано имя хранилища");
    }
    //String StoreName = JcpUtils.getStoreName("c:\\store.cfg"); 
    KeyStore keyStore = JcpUtils.getFloppyStore(StoreName, keyPassword);
    if (keyStore == null) throw new RuntimeException("Не удалось получить доступ к хранилищу ключей "+StoreName);
    
    X509Certificate certificate = JcpUtils.getCertificate(certFilename);
    if (certificate == null) throw new RuntimeException("Не найден сертификат");
    
    PrivateKey privateKey = getPrivateKey(keyStore, certificate, keyPassword, certFilename);
    if (privateKey == null) throw new RuntimeException("Не найден закрытый ключ");
    
    return JcpUtils.createCMS(data, new PrivateKey[] { privateKey }, new Certificate[] { certificate }, true);
  }
  
  /**
   * Проверка CMS подписи массива байт.
   *
   * @param cmsBytes CMS подпись
   * @param data подписанные данные; null = поверяются подписанные данные, содержащиеся внутри CMS; если имеются вложенные в CMS подписанные данные, то data игнорируется
   * @param certFilename имя файла сертификата в формате X.509; null = использовать сертификат, содержащийся в CMS; если имеются вложенные в CMS сертификаты, то certFilename игнорируется
   * @return верна ли подпись
   * @throws IOException, SignatureException, Asn1Exception, NoSuchAlgorithmException, InvalidKeyException, CertificateException, KeyStoreException
   */
  public static Boolean verifyCMSSignature(byte[] cmsBytes, byte[] data, String certFilename)
    throws IOException, SignatureException, Asn1Exception, NoSuchAlgorithmException, InvalidKeyException, CertificateException, KeyStoreException
  {
    X509Certificate certificate = null;
    if (certFilename != null)
    {
      certificate = JcpUtils.getCertificate(certFilename);
      if (certificate == null) {
            throw new RuntimeException("Не найден сертификат");
        }
    }
    
    JcpUtils.initJcp();
    
    return Boolean.valueOf(JcpUtils.verifyCMS(cmsBytes, certificate == null ? null : new Certificate[] { certificate }, data));
  }  
  /**

   */
  public static byte[] getDigest(byte[] data) 
          throws IOException, NoSuchAlgorithmException
  {  
    JcpUtils.initJcp(); 
    return JcpUtils.getDigest(data);
  }
}

package isc.jcp;

import java.util.*;
import java.io.*;

import org.w3c.dom.Element;
import org.w3c.dom.Document;

import java.security.DigestInputStream;
import java.security.Security;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.MessageDigest;
import java.security.Signature;
import java.security.SignatureException;
import java.security.InvalidKeyException;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateEncodingException;

import org.apache.xml.security.Init;
import org.apache.xml.security.c14n.Canonicalizer;
import org.apache.xml.security.utils.resolver.ResourceResolverSpi;
import org.apache.xml.security.keys.KeyInfo;
import org.apache.xml.security.signature.XMLSignature;
import org.apache.xml.security.exceptions.XMLSecurityException;
import org.apache.xml.security.transforms.Transforms;

import org.apache.ws.security.message.token.SecurityTokenReference;
import org.apache.ws.security.WSDocInfo;
import org.apache.ws.security.message.token.X509Security;
import org.apache.ws.security.WSSecurityException;

import ru.CryptoPro.JCP.JCP;
import ru.CryptoPro.JCP.params.OID;
import ru.CryptoPro.JCP.ASN.CryptographicMessageSyntax.CMSVersion;
import ru.CryptoPro.JCP.ASN.CryptographicMessageSyntax.CertificateChoices;
import ru.CryptoPro.JCP.ASN.CryptographicMessageSyntax.CertificateSet;
import ru.CryptoPro.JCP.ASN.CryptographicMessageSyntax.ContentInfo;
import ru.CryptoPro.JCP.ASN.CryptographicMessageSyntax.DigestAlgorithmIdentifier;
import ru.CryptoPro.JCP.ASN.CryptographicMessageSyntax.DigestAlgorithmIdentifiers;
import ru.CryptoPro.JCP.ASN.CryptographicMessageSyntax.EncapsulatedContentInfo;
import ru.CryptoPro.JCP.ASN.CryptographicMessageSyntax.IssuerAndSerialNumber;
import ru.CryptoPro.JCP.ASN.CryptographicMessageSyntax.SignatureAlgorithmIdentifier;
import ru.CryptoPro.JCP.ASN.CryptographicMessageSyntax.SignatureValue;
import ru.CryptoPro.JCP.ASN.CryptographicMessageSyntax.SignedData;
import ru.CryptoPro.JCP.ASN.CryptographicMessageSyntax.SignerIdentifier;
import ru.CryptoPro.JCP.ASN.CryptographicMessageSyntax.SignerInfo;
import ru.CryptoPro.JCP.ASN.CryptographicMessageSyntax.SignerInfos;
import ru.CryptoPro.JCP.ASN.PKIX1Explicit88.Attribute;
import ru.CryptoPro.JCP.ASN.PKIX1Explicit88.CertificateSerialNumber;
import ru.CryptoPro.JCP.ASN.PKIX1Explicit88.Name;
import ru.CryptoPro.JCP.tools.Array;

import com.objsys.asn1j.runtime.Asn1Type;
import com.objsys.asn1j.runtime.Asn1BerDecodeBuffer;
import com.objsys.asn1j.runtime.Asn1BerEncodeBuffer;
import com.objsys.asn1j.runtime.Asn1Null;
import com.objsys.asn1j.runtime.Asn1ObjectIdentifier;
import com.objsys.asn1j.runtime.Asn1OctetString;
import com.objsys.asn1j.runtime.Asn1Exception;
import java.security.UnrecoverableKeyException;
import javax.swing.JFrame;
import javax.swing.JOptionPane;

/**
 * Контейнер для полезных методов работы с КриптоПро JCP.
 */
public class JcpUtils
{
  /** Алгоритм подписи (ГОСТ Р 34.10-2001) **/
  public static final String signMethod = "http://www.w3.org/2001/04/xmldsig-more#gostr34102001-gostr3411";

  /** Алгоритм хеширования, используемый при подписи (ГОСТ Р 34.11-94) **/
  public static final String digestMethod = "http://www.w3.org/2001/04/xmldsig-more#gostr3411"; 

  private static final String STR_CMS_OID_SIGNED = "1.2.840.113549.1.7.2";
  private static final String DIGEST_OID = JCP.GOST_DIGEST_OID;
  private static final String STR_CMS_OID_DATA = "1.2.840.113549.1.7.1";
  private static final String SIGN_OID = JCP.GOST_EL_KEY_OID;
  private static final String STR_CMS_OID_CONT_TYP_ATTR = "1.2.840.113549.1.9.3";
  private static final String STR_CMS_OID_DIGEST_ATTR = "1.2.840.113549.1.9.4";
  private static final String DIGEST_ALG_NAME = JCP.GOST_DIGEST_NAME;
  
  /** Хранилище ключей типа FloppyStore **/
  private static KeyStore floppyStore;
  
  /** Кэш сертификатов **/
  private static Map certificates = new HashMap();
  
  /** Фабрика сертификатов **/
  private static CertificateFactory certificateFactory;

  /**
   * Инициализирует JCP и XML Security.
   */
  public synchronized static void initJcp()
  {
    ru.CryptoPro.JCP.JCP jcp = new ru.CryptoPro.JCP.JCP();
    if (Security.getProvider(jcp.getName()) == null)
    {
      Security.addProvider(jcp);
    }
    
    if (!ru.CryptoPro.JCPxml.xmldsig.JCPXMLDSigInit.isInitialized())
    {
      ru.CryptoPro.JCPxml.xmldsig.JCPXMLDSigInit.init();
    }
    
    if (!Init.isInitialized())
    {
      Init.init();
    }
  }
  /*
   * Вернет имя хранилищиа
   */
  public static String getStoreName(String file)
    throws IOException, CertificateException, KeyStoreException, NoSuchAlgorithmException
  {
      String str = "";
      try {
        BufferedReader in = new BufferedReader(new FileReader(file));
        while ((str = in.readLine()) != null) {            
            //JOptionPane.showMessageDialog(frame, str);
            if (!"".equals(str)) {
                break;
            }
        }
        in.close();
    } catch (IOException e) {}
    if ("".equals(str)) {
            str = "FloppyStore";
    } 
    //JOptionPane.showMessageDialog(frame, str);
    return str;
  }
  /**
   * Возвращает ссылку на хранилище ключей FloppyStore.
   *
   * @return KeyStore
   * @throws IOException
   * @throws CertificateException
   * @throws KeyStoreException
   * @throws NoSuchAlgorithmException
   */
  public static KeyStore getFloppyStore(String StoreName, String keyPassword )
    throws IOException, CertificateException, KeyStoreException, NoSuchAlgorithmException
  {
    if (floppyStore == null)
      initFloppyStore(StoreName, keyPassword);
    
    return floppyStore;
  }

  /**
   * Инициализирует хранилище ключей FloppyStore.
   *
   * @throws IOException
   * @throws CertificateException
   * @throws KeyStoreException
   * @throws NoSuchAlgorithmException
   */
  private synchronized static void initFloppyStore(String StoreName, String keyPassword )
    throws IOException, CertificateException, KeyStoreException, NoSuchAlgorithmException
  {
    floppyStore = KeyStore.getInstance(StoreName);
    if (floppyStore != null)
    {
        if (keyPassword == null) {
            floppyStore.load(null, null);
        }
        else {
            floppyStore.load(null, keyPassword.toCharArray());            
        }
        
    }
    
   /*   
      */
  }
  
  /**
   * Загружает сертификат в формате X.509 из потока.
   *
   * @param is поток, содержащий сертификат в формате X.509
   * @return X509Certificate
   * @throws CertificateException
   */
  public synchronized static X509Certificate getCertificate(InputStream is)
    throws CertificateException
  {
    if (certificateFactory == null)
      certificateFactory = CertificateFactory.getInstance("X.509");
      
    X509Certificate cert = null;
    try
    {
      cert = (X509Certificate)certificateFactory.generateCertificate(new BufferedInputStream(is));
    }
    finally
    {
      try
      {
        is.close();
      }
      catch (IOException ignore)
      {}
    }
    return cert;
  }

  /**
   * Загружает сертификат в формате X.509 из файла. Использует кэш сертификатов.
   *
   * @param file имя файла, содержащего сертификат в формате X.509
   * @return X509Certificate
   * @throws FileNotFoundException
   * @throws CertificateException
   */
  public synchronized static X509Certificate getCertificate(String file)
    throws CertificateException, KeyStoreException, UnsupportedEncodingException
  {
      X509Certificate cert = null;
      if (file != null) {
          String alias = getAlias(file);
          if (alias == null) { 
            try {
              FileInputStream ifStream = new FileInputStream(file);
              if (certificates.containsKey(file)) {
                    return (X509Certificate)certificates.get(file);
                }
              cert = getCertificate(ifStream);
            }
            catch(FileNotFoundException ignore)
            { }
            if (cert != null) {
                certificates.put(file, cert);
                return cert;
            }
          }
          else {
              cert = (X509Certificate) floppyStore.getCertificate(alias); 
          }
      }
    return cert;
  }

  // Получить алиас
public static String getAlias(String fileoralias) 
        throws KeyStoreException
{
    if (fileoralias == null) return null;
    Enumeration aliasesEnum = floppyStore.aliases();
    String result = null;
    while (aliasesEnum.hasMoreElements()) {        
          String alias = aliasesEnum.nextElement().toString();                          
          if (alias.indexOf(fileoralias)!= -1) {
              result = alias;
              break;
        }
    }
    return result;
}
 // Просто функция ShowMessage
 public static void ShowMessage(String Message)
 {
    JFrame frame=new JFrame();
    JOptionPane.showMessageDialog(frame, Message);  
 }
  /**
   * Проверяет валидность ЭЦП.
   *
   * @param signatureElement XML-элемент ds:Signature
   * @param resourceResolver реализация <code>org.apache.xml.security.utils.resolver.ResourceResolverSpi</code>, используемая при проверке подписи
   * @return boolean
   * @throws XMLSecurityException
   * @throws WSSecurityException
   * @throws CertificateException
   */
  public static boolean verifySignature(Element signatureElement, ResourceResolverSpi resourceResolver)
    throws XMLSecurityException, WSSecurityException, CertificateException
  {
    XMLSignature signature = new XMLSignature(signatureElement, "");
    if (signature.getSignedInfo().getLength() == 0)
      throw new RuntimeException("No signed resources");
    
    signature.addResourceResolver(resourceResolver);

    KeyInfo ki = signature.getKeyInfo();
    if (ki == null) 
      throw new RuntimeException("KeyInfo element not found");
    else if (ki.isEmpty()) 
      throw new RuntimeException("Empty KeyInfo element");
    else if (ki.containsX509Data())
      return signature.checkSignatureValue(ki.getX509Certificate());
    else if (ki.getPublicKey() != null)
      return signature.checkSignatureValue(ki.getPublicKey());
    
    // далее - сложный случай
    Element kiChild = XmlUtils.getFirstChildElement(ki.getElement());
    if (kiChild == null) throw new RuntimeException("Empty KeyInfo element");
    
    SecurityTokenReference tref = new SecurityTokenReference(kiChild);
    if (!tref.containsReference() || (tref.getReference() == null))
      throw new RuntimeException("SecurityTokenReference does not contain a direct reference (i.e. <wsse:Reference> element)");
    else if (!X509Security.X509_V3_TYPE.equals(tref.getReference().getValueType()))
      throw new RuntimeException("Reference value type \"" + tref.getReference().getValueType() + "\" is not supported");
      
    Element tokenEl = tref.getTokenElement(signatureElement.getOwnerDocument(), new WSDocInfo(signatureElement.getOwnerDocument()), null);
    X509Security token = new X509Security(tokenEl);
    X509Certificate cert = getCertificate(new ByteArrayInputStream(token.getToken()));
    
    return signature.checkSignatureValue(cert);
  }
  
  /**
   * Формирует ЭЦП в формате XML Signature (ds:Signature).
   *
   * @param targetDoc XML-документ (DOM), элементы которого подписываются
   * @param uris массив ссылок (URI) на подписываемые элементы
   * @param resourceResolver реализация <code>org.apache.xml.security.utils.resolver.ResourceResolverSpi</code>, используемая при формировании подписи
   * @param certificate сертификат в формате X.509, соответствующий секретному ключу, используемому при формировании подписи
   * @param privateKey секретный ключ, используемый при формировании подписи
   * @return XML-элемент ds:Signature
   * @throws XMLSecurityException
   */
  public static Element signDocuments(Document targetDoc, String[] uris, ResourceResolverSpi resourceResolver, X509Certificate certificate, PrivateKey privateKey)
    throws XMLSecurityException
  {
    XMLSignature sig = new XMLSignature(targetDoc, "", signMethod, Canonicalizer.ALGO_ID_C14N_EXCL_OMIT_COMMENTS);

    Transforms transforms = new Transforms(targetDoc);
    transforms.addTransform(Transforms.TRANSFORM_C14N_EXCL_OMIT_COMMENTS);
    
    for (int i = 0; i < uris.length; i++)
      sig.addDocument(uris[i], transforms, digestMethod);

    sig.getSignedInfo().addResourceResolver(resourceResolver);

    sig.addKeyInfo(certificate);
    sig.sign(privateKey);
    
    return sig.getElement();
  }
  
  /**
   * Формирует ЭЦП для произвольного массива байт.
   *
   * @param data подписываемый массив байт
   * @param keys массив секретных ключей, используемый при формировании подписи
   * @param certs массив сертификатов в формате X.509, соответствующий массиву секретных ключей
   * @param detached признак необходимости создания detached ЭЦП - см. http://notary.cryptopro.ru/Notary_Help.htm
   * @return ЭЦП
   * @throws IOException, SignatureException, Asn1Exception, CertificateEncodingException, NoSuchAlgorithmException, InvalidKeyException
   */
   public static byte[] createCMS(byte[] data, PrivateKey[] keys, Certificate[] certs, boolean detached)
    throws IOException, SignatureException, Asn1Exception, CertificateEncodingException, NoSuchAlgorithmException, InvalidKeyException
  {
    //create CMS
    final SignedData cms = new SignedData();
    cms.version = new CMSVersion(1);

    final ContentInfo all = new ContentInfo();
    all.contentType = new Asn1ObjectIdentifier(new OID(STR_CMS_OID_SIGNED).value);
    all.content = cms;
    
    // digest
    final DigestAlgorithmIdentifier a = new DigestAlgorithmIdentifier(new OID(DIGEST_OID).value);
    a.parameters = new Asn1Null();
    cms.digestAlgorithms = new DigestAlgorithmIdentifiers(1);
    cms.digestAlgorithms.elements[0] = a;
    
    if (detached)
      cms.encapContentInfo = new EncapsulatedContentInfo(new Asn1ObjectIdentifier(new OID(STR_CMS_OID_DATA).value), null);
    else
      cms.encapContentInfo = new EncapsulatedContentInfo(new Asn1ObjectIdentifier(new OID(STR_CMS_OID_DATA).value), new Asn1OctetString(data));

    // certificates
    final int ncerts = certs.length;
    cms.certificates = new CertificateSet(ncerts);
    cms.certificates.elements = new CertificateChoices[ncerts];
    for (int i = 0; i < cms.certificates.elements.length; i++)
    {
      final ru.CryptoPro.JCP.ASN.PKIX1Explicit88.Certificate certificate = new ru.CryptoPro.JCP.ASN.PKIX1Explicit88.Certificate();
      final Asn1BerDecodeBuffer decodeBuffer = new Asn1BerDecodeBuffer(certs[i].getEncoded());
      certificate.decode(decodeBuffer);
      cms.certificates.elements[i] = new CertificateChoices();
      cms.certificates.elements[i].set_certificate(certificate);
    }
    
    // Signature.getInstance
    final Signature signature = Signature.getInstance(JCP.GOST_EL_SIGN_NAME);
    byte[] sign;
    
    // signer infos
    final int nsign = keys.length;
    cms.signerInfos = new SignerInfos(nsign);
    for (int i = 0; i < cms.signerInfos.elements.length; i++)
    {
      signature.initSign(keys[i]);
      signature.update(data);
      sign = signature.sign();

      final CertificateSerialNumber num = new CertificateSerialNumber(((X509Certificate)certs[i]).getSerialNumber());
      final byte[] encodedName = ((X509Certificate)certs[i]).getIssuerX500Principal().getEncoded();
      final Asn1BerDecodeBuffer nameBuf = new Asn1BerDecodeBuffer(encodedName);
      final Name name = new Name();
      name.decode(nameBuf);

      cms.signerInfos.elements[i] = new SignerInfo();
      cms.signerInfos.elements[i].version = new CMSVersion(1);
      cms.signerInfos.elements[i].sid = new SignerIdentifier();
      cms.signerInfos.elements[i].sid.set_issuerAndSerialNumber(new IssuerAndSerialNumber(name, num));
      cms.signerInfos.elements[i].digestAlgorithm = new DigestAlgorithmIdentifier(new OID(DIGEST_OID).value);
      cms.signerInfos.elements[i].digestAlgorithm.parameters = new Asn1Null();
      cms.signerInfos.elements[i].signatureAlgorithm = new SignatureAlgorithmIdentifier(new OID(SIGN_OID).value);
      cms.signerInfos.elements[i].signatureAlgorithm.parameters = new Asn1Null();
      cms.signerInfos.elements[i].signature = new SignatureValue(sign);
    }
    
    // encode
    final Asn1BerEncodeBuffer asnBuf = new Asn1BerEncodeBuffer();
    all.encode(asnBuf, true);
    
    return asnBuf.getMsgCopy();
  }
  
  /**
   * Проверка CMS подписи массива байт.
   *
   * @param cmsBytes CMS подпись
   * @param certs массив сертификатов в формате X.509; null = использовать сертификат, содержащийся в CMS; если имеются вложенные в CMS сертификаты, то certs игнорируется
   * @param data подписанные данные; null = поверяются подписанные данные, содержащиеся внутри CMS; если имеются вложенные в CMS подписанные данные, то data игнорируется
   * @return верна ли подпись
   * @throws IOException, SignatureException, Asn1Exception, NoSuchAlgorithmException, InvalidKeyException, CertificateException
   */
  public static boolean verifyCMS(byte[] cmsBytes, Certificate[] certs, byte[] data)
    throws IOException, SignatureException, Asn1Exception, NoSuchAlgorithmException, InvalidKeyException, CertificateException
  {
    int validsign = 0;
    
    final Asn1BerDecodeBuffer asnBuf = new Asn1BerDecodeBuffer(cmsBytes);
    final ContentInfo all = new ContentInfo();
    all.decode(asnBuf);
    if (!new OID(STR_CMS_OID_SIGNED).eq(all.contentType.value)) throw new RuntimeException("Формат подписи не поддерживается");
    
    final SignedData cms = (SignedData)all.content;
    
    final byte[] text;
    if (cms.encapContentInfo.eContent != null)
      text = cms.encapContentInfo.eContent.value;
    else if (data != null)
      text = data;
    else
      throw new RuntimeException("Нет данных для проверки подписи");
      
    OID digestOid = null;
    final DigestAlgorithmIdentifier digestAlgorithmIdentifier = new DigestAlgorithmIdentifier(new OID(DIGEST_OID).value);
    for (int i = 0; i < cms.digestAlgorithms.elements.length; i++)
    {
      if (cms.digestAlgorithms.elements[i].algorithm.equals(digestAlgorithmIdentifier.algorithm))
      {
        digestOid = new OID(cms.digestAlgorithms.elements[i].algorithm.value);
        break;
      }
    }
    if (digestOid == null) throw new RuntimeException("Неизвестный дайджест");
    
    final OID eContTypeOID = new OID(cms.encapContentInfo.eContentType.value);
    if (cms.certificates != null)
    {
      //Проверка на вложенных сертификатах
      for (int i = 0; i < cms.certificates.elements.length; i++)
      {
        final Asn1BerEncodeBuffer encBuf = new Asn1BerEncodeBuffer();
        cms.certificates.elements[i].encode(encBuf);

        final CertificateFactory cf = CertificateFactory.getInstance("X.509");
        final X509Certificate cert = (X509Certificate)cf.generateCertificate(encBuf.getInputStream());

        for (int j = 0; j < cms.signerInfos.elements.length; j++)
        {
          final SignerInfo info = cms.signerInfos.elements[j];
          if (!digestOid.equals(new OID(info.digestAlgorithm.algorithm.value))) throw new RuntimeException("Подпись не соответствует сертификату");
          final boolean checkResult = verifyOnCert(cert, cms.signerInfos.elements[j], text, eContTypeOID);
          if (checkResult) validsign += 1;
        }
      }
    }
    else if (certs != null)
    {
      //Проверка на указанных сертификатах
      for (int i = 0; i < certs.length; i++)
      {
        final X509Certificate cert = (X509Certificate)certs[i];
        for (int j = 0; j < cms.signerInfos.elements.length; j++)
        {
          final SignerInfo info = cms.signerInfos.elements[j];
          if (!digestOid.equals(new OID(info.digestAlgorithm.algorithm.value))) throw new RuntimeException("Подпись не соответствует сертификату");
          final boolean checkResult = verifyOnCert(cert, cms.signerInfos.elements[j], text, eContTypeOID);
          if (checkResult) validsign += 1;
        }
      }
    }
    else
    {
       // Certificates for validation not found
    }
    
    return (cms.signerInfos.elements.length == validsign);
  }
  
  /**
   * Попытка проверки подписи на указанном сертификате
   *
   * @param cert сертификат для проверки
   * @param text текст для проверки
   * @param info подпись
   * @param eContentTypeOID
   * @return верна ли подпись
   * @throws IOException, SignatureException, Asn1Exception, NoSuchAlgorithmException, InvalidKeyException
   */
  private static boolean verifyOnCert(X509Certificate cert, SignerInfo info, byte[] text, OID eContentTypeOID)
    throws IOException, SignatureException, Asn1Exception, NoSuchAlgorithmException, InvalidKeyException
  {
    //подпись
    final byte[] sign = info.signature.value;
    
    //данные для проверки подписи
    final byte[] data;
    if (info.signedAttrs == null)
    {
      //аттрибуты подписи отсутствуют
      data = text;
    }
    else
    {
      //присутствуют аттрибуты подписи (SignedAttr)
      final Attribute[] signAttrElem = info.signedAttrs.elements;

      //проверка аттрибута content-type
      final Asn1ObjectIdentifier contentTypeOid = new Asn1ObjectIdentifier((new OID(STR_CMS_OID_CONT_TYP_ATTR)).value);
      Attribute contentTypeAttr = null;
      for (int r = 0; r < signAttrElem.length; r++)
      {
        final Asn1ObjectIdentifier oid = signAttrElem[r].type;
        if (oid.equals(contentTypeOid)) contentTypeAttr = signAttrElem[r];
      }

      if (contentTypeAttr == null)
        throw new RuntimeException("Отсутствует атрибут, отвечающий за структуру подписи");

      if (!contentTypeAttr.values.elements[0].equals(new Asn1ObjectIdentifier(eContentTypeOID.value)))
        throw new RuntimeException("Недопустимая структура подписи");

      //проверка аттрибута message-digest
      final Asn1ObjectIdentifier messageDigestOid = new Asn1ObjectIdentifier((new OID(STR_CMS_OID_DIGEST_ATTR)).value);
      Attribute messageDigestAttr = null;
      for (int r = 0; r < signAttrElem.length; r++)
      {
        final Asn1ObjectIdentifier oid = signAttrElem[r].type;
        if (oid.equals(messageDigestOid)) messageDigestAttr = signAttrElem[r];
      }
      if (messageDigestAttr == null)
        throw new RuntimeException("Не найдено значение дайджеста");

      //вычисление messageDigest
      final ByteArrayInputStream stream = new ByteArrayInputStream(text);
      final MessageDigest digest = MessageDigest.getInstance(DIGEST_ALG_NAME);
      final DigestInputStream digestStream = new DigestInputStream(stream, digest);
      while (digestStream.available() != 0)
        digestStream.read();
        
      final Asn1Type open = messageDigestAttr.values.elements[0];
      final Asn1OctetString hash = (Asn1OctetString)open;
      if (!Array.toHexString(digest.digest()).equals(Array.toHexString(hash.value)))
        throw new RuntimeException("Недопустимое значение дайджеста");

      //данные для проверки подписи
      final Asn1BerEncodeBuffer encBufSignedAttr = new Asn1BerEncodeBuffer();
      info.signedAttrs.encode(encBufSignedAttr);
      data = encBufSignedAttr.getMsgCopy();
    }

    // проверка подписи
    final Signature signature = Signature.getInstance(JCP.GOST_EL_SIGN_NAME);
    signature.initVerify(cert);
    signature.update(data);
    
    return signature.verify(sign);
  }
  
public static byte[] getBytesFromFile(File file) throws IOException {
    InputStream is = new FileInputStream(file);
    long length = file.length();
    if (length > Integer.MAX_VALUE) {
        return null;
    }
 
    byte[] bytes = new byte[(int)length];
 
    // Read in the bytes
    int offset = 0;
    int numRead = 0;
    while (offset < bytes.length && (numRead=is.read(bytes, offset, bytes.length-offset)) >= 0) {
        offset += numRead;
    }
 
    // Ensure all the bytes have been read in
    if (offset < bytes.length) {
        throw new IOException("Could not completely read file "+file.getName());
    }
 
    // Close the input stream and return bytes
    is.close();
    return bytes;
}

    /**
     * Метод печатает список алиасов
     * @throws KeyStoreException
     * @throws NoSuchAlgorithmException
     * @throws UnrecoverableKeyException
     */
    public static void prnListAlias(String StoreName, String keyPassword) 
           throws KeyStoreException, NoSuchAlgorithmException, UnrecoverableKeyException, IOException, CertificateException
  {
      initJcp();
      getFloppyStore(StoreName,keyPassword);
      try {
      Enumeration aliases = floppyStore.aliases();
        while (aliases.hasMoreElements())
        {
          String alias = (String)aliases.nextElement();
          System.out.print("alias: " + alias);
          System.out.println("");
        }
      } 
      catch (Exception ex) {} 
      floppyStore = null;
  }
    /**
     * Метод возвращает значение хеш для строки text
     * @param text принимает входную строку, для которой необходимо вычислить хеш
     * @return возвращает хеш
     */
    public static byte[] getDigest(byte[] text) 
            throws IOException, NoSuchAlgorithmException
    {
        //вычисление messageDigest
      final ByteArrayInputStream stream = new ByteArrayInputStream(text);
      final MessageDigest digest;
        digest = MessageDigest.getInstance(DIGEST_ALG_NAME);
      final DigestInputStream digestStream;
        digestStream = new DigestInputStream(stream, digest);
      while (digestStream.available() != 0) {
            digestStream.read();
        }
        
      //final Asn1Type open = messageDigestAttr.values.elements[0];
      //final Asn1OctetString hash = (Asn1OctetString)open;
      //if (!Array.toHexString(digest.digest()).equals(Array.toHexString(hash.value)))
       // throw new RuntimeException("Недопустимое значение дайджеста");
      return digest.digest();
      //return Array.toHexString(digest.digest());
    }
}

package isc.jcp;

import java.util.*;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.InputStreamReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.ParserConfigurationException;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

/**
 * Контейнер для полезных методов работы с XML.
 */
public class XmlUtils
{
  private static TransformerFactory transformerFactory = TransformerFactory.newInstance();
  private static DocumentBuilderFactory documentBuilderFactory;
  static
  {
    documentBuilderFactory = DocumentBuilderFactory.newInstance();
    documentBuilderFactory.setNamespaceAware(true);
  }
  
  /**
   * Сериализует XML DOM в строку.
   *
   * @param node вершина DOM
   * @return Cтрока с XML
   */
  public static String serializeNode(Node node)
  {
    return serializeNode(node, true, true);
  }
  
  /**
   * Сериализует XML DOM в строку.
   *
   * @param node вершина DOM
   * @param omitXmlDeclaration признак того, что в результат не нужно включить XML declaration (по умолчанию true)
   * @return Cтрока с XML
   */
  public static String serializeNode(Node node, boolean omitXmlDeclaration)
  {
    return serializeNode(node, omitXmlDeclaration, true);
  }

  /**
   * Сериализует XML DOM в строку.
   *
   * @param node вершина DOM
   * @param omitXmlDeclaration признак того, что в результат не нужно включить XML declaration (по умолчанию true)
   * @param indent признак необходимости добавлять отступы (по умолчанию true)
   * @return Cтрока с XML
   */  
  public static String serializeNode(Node node, boolean omitXmlDeclaration, boolean indent)
  {
    Transformer serializer;
    try
    {
      serializer = transformerFactory.newTransformer();
    }
    catch (TransformerConfigurationException e)
    {
      throw new RuntimeException(e);
    }

    serializer.setOutputProperty(OutputKeys.METHOD, "xml");
    serializer.setOutputProperty(OutputKeys.INDENT, (indent ? "yes" : "no"));
    serializer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, (omitXmlDeclaration ? "yes" : "no"));

    StringWriter writer = new StringWriter();
    try
    {
      serializer.transform(new DOMSource(node), new StreamResult(writer));
    }
    catch (TransformerException e)
    {
      throw new RuntimeException(e);
    }

    return writer.toString();
  }
  
  /**
   * Десериализует XML из строки в DOM.
   *
   * @param s строка, содержащая XML
   * @return XML-документ (DOM)
   */
  public static Document deserialize(String s)
  {
    return deserialize(new StringReader(s));
  }
  
  /**
   * Десериализует XML из <code>java.io.Reader</code> в DOM.
   *
   * @param reader экземпляр <code>java.io.Reader</code>, содержащий XML
   * @return XML-документ (DOM)
   */
  public static Document deserialize(Reader reader)
  {
    DocumentBuilder documentBuilder;
    try
    {
      synchronized (documentBuilderFactory)
      {
        documentBuilder = documentBuilderFactory.newDocumentBuilder();
      }
    }
    catch (ParserConfigurationException e)
    {
      throw new RuntimeException(e);
    }
    
    return deserialize(documentBuilder, reader);
  }

  /**
   * Десериализует XML из <code>java.io.Reader</code> в DOM, используя указанный <code>javax.xml.parsers.DocumentBuilder</code>.
   *
   * @param documentBuilder объект-реализация <code>javax.xml.parsers.DocumentBuilder</code>, который будет использован при десериализации XML
   * @param reader экземпляр <code>java.io.Reader</code>, содержащий XML
   * @return XML-документ (DOM)
   */
  public static Document deserialize(DocumentBuilder documentBuilder, Reader reader)
  {
    Document doc = null;  
    try
    {
      doc = documentBuilder.parse(new InputSource(reader));
    }
    catch (SAXException e)
    {
      throw new RuntimeException(e);
    }
    catch (IOException ioe)
    {
      throw new RuntimeException(ioe);
    }
    
    return doc;
  }

  /**
   * Вычисляет XPath-выражение.
   *
   * @param xpath подготовленный объект <code>javax.xml.xpath.XPath</code>
   * @param doc XML-документ (DOM)
   * @param xpathExpression XPath-выражение
   * @return Результирующий массив вершин DOM
   */
  public static Node[] evalXPath(XPath xpath, Document doc, String xpathExpression)
  {
    NodeList nodelist;
    try
    {
      nodelist = (NodeList)xpath.evaluate(xpathExpression, doc, XPathConstants.NODESET);
    }
    catch (XPathExpressionException e)
    {
      throw new RuntimeException("Error evaluating XPath expression " + xpathExpression + ": " + e.getMessage(), e);
    }

    Node[] result = new Node[nodelist.getLength()];
    for (int i = 0; i < nodelist.getLength(); i++)
      result[i] = nodelist.item(i);

    return result;
  }
  
  /**
   * Возвращает первый дочерний XML-элемент.
   *
   * @param elem родительский XML-элемент
   * @return Первый дочерний XML-элемент
   */
  public static Element getFirstChildElement(Element elem)
  {
    for (Node n = elem.getFirstChild(); n != null; n = n.getNextSibling())
    {
      if (n.getNodeType() == Node.ELEMENT_NODE)
      {
        return (Element)n;
      }
    }
    return null;
  }

  /**
   * Возвращает следующий после указанного дочерний XML-элемент.
   *
   * @param parentElem родительский XML-элемент
   * @param currentElem текущий дочерний XML-элемент
   * @return Следующий после указанного дочерний XML-элемент
   */
  public static Element getNextChildElement(Element parentElem, Element currentElem)
  {
    boolean currElemFound = false;
    
    for (Node n = parentElem.getFirstChild(); n != null; n = n.getNextSibling())
    {
      if (n.getNodeType() == Node.ELEMENT_NODE)
      {
        if (currElemFound)
          return (Element)n;
        else
          currElemFound = (currentElem == (Element)n);
      }
    }
    return null;
  }
}