Показаны сообщения с ярлыком digital signature. Показать все сообщения
Показаны сообщения с ярлыком digital signature. Показать все сообщения

четверг, 25 мая 2017 г.

Использование BouncyCastle вместо TumarCSP

Казахская криптография очень похожа на российскую, те же алгоритмы, те же ГОСТы, все отличие - в OID и форматах приватных ключей.
К примеру, ГОСТ 34.310-2004 соответсвует ГОСТ Р 34.10-2001, ГОСТ 34.311-95 соответсвует ГОСТ Р 34.11-94.
Так что если есть задача реализовать вызов WS-Security веб-сервиса с подписью по алгоритму  http://www.w3.org/2001/04/xmldsig-more#gost34310-gost34311 и хэшом по алгоритму http://www.w3.org/2001/04/xmldsig-more#gost34311 ( AvangardPlat к примеру ), то можно обойтись стандартными средствами типа BouncyCastle ( проверял на версии 1.57, последней на данный момент ), по крайней мере для ряда алгоритмов.

Задача состоит по большому счету из 3 частей - разбор плючевой пары из некоего проприетарного формата TumarCSP, выбор другого набора S-блоков для функции хэширования, регистрация алгоритмов подписи и функции хэширования для xmlsec.

К сожалению, придется писать свой собственный маленький криптопровайдер, который будет большую часть своей работы делегировать BouncyCastle.

Начнем с OID, у компании, которая разрабатывает TumarCSP есть свой набор идентификаторов, которые конечно же никто в BouncyCastle или OpenSSL не добавит. Частично посмотреть можно здесь http://www.oid-info.com/get/1.3.6.1.4.1.6801.1

смотрим сертификат с помощью dumpasn1, публичный ключ 80 байт, и первые 16 какие-то подозрительные 06 02 00 00 3A AA 00 00 00 45 43 31 00 02 00 00 если смотреть в ascii., то 45 43 31 это EC1, а 0xAA3A - внутренний идентификатор Tumar для алгоритма 1.3.6.1.4.1.6801.1.5.8. То есть тут продублирована некая описательная часть ключа, которая нам уже известна, нам интересны следуюшие 64 байта, которые представляют собой координаты точки на эллиптической кривой.

285  99:             SEQUENCE {
287  14:               SEQUENCE {
289  10:                 OBJECT IDENTIFIER '1 3 6 1 4 1 6801 1 5 8'
301   0:                 NULL
       :                 }
303  81:               BIT STRING
       :                 06 02 00 00 3A AA 00 00 00 45 43 31 00 02 00 00
       :                 59 5A 9B 09 B7 6E AA 2C 3E F6 37 1C D0 15 42 18
       :                 39 EF 5B 15 D1 D8 11 E4 D7 E7 84 4C 00 2A 11 19
       :                 61 C5 C3 E5 F1 44 98 46 93 0D 62 96 44 F6 E7 E7
       :                 82 4A EF 5D B2 12 A9 8C F6 2D 31 56 27 8F 7A 6F
       :               }

ищем что такое 1.3.6.1.4.1.6801.1.5.8, находим, что это все равно что CryptoProObjectIdentifiers.gostR3410_2001_CryptoPro_A (1.2.643.2.2.35.1) прописываем идентификатор.

public class GammaOID {
    static private final ASN1ObjectIdentifier GOST_id = new ASN1ObjectIdentifier("1.3.6.1.4.1.6801.1");
    static private final ASN1ObjectIdentifier GOST_34310_2004 = GOST_id.branch("5");
    static final ASN1ObjectIdentifier GOST_34310_2004_parameter_A = GOST_34310_2004.branch("8");
}

Теперь можно создавать провайдера, прописав ему кастомную KeyFactory для алгоритма 1.3.6.1.4.1.6801.1.5.8

public class KzGostProvider extends Provider {

    public KzGostProvider() {
        super("GOST", 1.0, "Little kazakh provider");
        put("Alg.Alias.KeyFactory." + GammaOID.GOST_34310_2004_parameter_A, "KZGOST");
        put("KeyFactory.KZGOST", "com.gost.jce.KzGostKeyFactorySpi");
    }
}

в KzGostKeyFactorySpi нужно реализовать логику по разбору ключей. Мы будем разбирать только тип ключей GammaOID.GOST_34310_2004_parameter_A, это позволит немного упростить код. Возможно другие типы точно так же просто разбираются, не проверял.

public class KzGostKeyFactorySpi extends org.bouncycastle.jcajce.provider.asymmetric.ecgost.KeyFactorySpi {
    public PrivateKey generatePrivate(PrivateKeyInfo keyInfo) throws IOException {
        ASN1ObjectIdentifier algOid = keyInfo.getPrivateKeyAlgorithm().getAlgorithm();
        if (algOid.equals(GammaOID.GOST_34310_2004_parameter_A)) {
            return KzGostKeyUtils.populateFromPrivKeyInfo(keyInfo);
        } else {
            throw new IOException("algorithm identifier " + algOid + " in key not recognised");
        }
    }

    public PublicKey generatePublic(SubjectPublicKeyInfo keyInfo) throws IOException {
        ASN1ObjectIdentifier algOid = keyInfo.getAlgorithm().getAlgorithm();
        if (algOid.equals(GammaOID.GOST_34310_2004_parameter_A)) {
            return KzGostKeyUtils.populateFromPubKeyInfo(keyInfo);
        } else {
            throw new IOException("algorithm identifier " + algOid + " in key not recognised");
        }
    }
}

Вот где вся логика по чтению ключей, она большей частью взята из BouncyCastle, различие только в представлении публичного ключа - пришлось выкинуть первые 16 байт заголовка. Важно! x и y в публичном ключе нужно разворачивать, а в приватном - d не нужно. И BouncyCastle проверяет публичный ключ, но не делает этого для приватного. В приватник можно скормить все что угодно, оно якобы будет работать, но по факту подпись не будет проходить проверку.

public class KzGostKeyUtils {

    private static ASN1ObjectIdentifier OID = CryptoProObjectIdentifiers.gostR3410_2001_CryptoPro_A;

    public static BCECGOST3410PrivateKey populateFromPrivKeyInfo(PrivateKeyInfo kryInfo) throws IOException {

        ECNamedCurveParameterSpec spec = ECGOST3410NamedCurveTable.getParameterSpec(OID.toString());
        ECCurve var4 = spec.getCurve();
        EllipticCurve curve = EC5Util.convertCurve(var4, spec.getSeed());
        ECParameterSpec ecSpec = new ECNamedCurveSpec(ECGOST3410NamedCurves.getName(OID), curve, new ECPoint(spec.getG().getAffineXCoord().toBigInteger(), spec.getG().getAffineYCoord().toBigInteger()), spec.getN(), spec.getH());
        ASN1Encodable privateKey = kryInfo.parsePrivateKey();

        ASN1Sequence sequence = (ASN1Sequence) privateKey;
        // 0 - integer !
        // 1 - private key
        DEROctetString key = (DEROctetString) sequence.getObjectAt(1);
        byte[] keyOctets = key.getOctets();
        BigInteger d = new BigInteger(1, keyOctets);
        ECPrivateKeySpec keySpec = new ECPrivateKeySpec(d, ecSpec);
        return new BCECGOST3410PrivateKey(keySpec);

    }

    public static BCECGOST3410PublicKey populateFromPubKeyInfo(SubjectPublicKeyInfo info) throws IOException {
        DERBitString bits = info.getPublicKeyData();

        String algorithm = "ECGOST3410";
        byte[] keyEnc = new byte[64];

        // skip first 16 byte - some type of header, not related.
        System.arraycopy(bits.getBytes(), 16, keyEnc, 0, 64);
        byte[] x = new byte[32];
        byte[] y = new byte[32];

        for (int i = 0; i != x.length; i++) {
            x[i] = keyEnc[32 - 1 - i];
        }

        for (int i = 0; i != y.length; i++) {
            y[i] = keyEnc[64 - 1 - i];
        }

        ECNamedCurveParameterSpec spec = ECGOST3410NamedCurveTable.getParameterSpec(OID.toString());
        ECCurve curve = spec.getCurve();
        EllipticCurve ellipticCurve = EC5Util.convertCurve(curve, spec.getSeed());
        org.bouncycastle.math.ec.ECPoint q = curve.createPoint(new BigInteger(1, x), new BigInteger(1, y));
        ECPublicKeyParameters publicKeyParameters = new ECPublicKeyParameters(q, ECUtil.getDomainParameters(null, spec));
        ECPoint p = new ECPoint(spec.getG().getAffineXCoord().toBigInteger(), spec.getG().getAffineYCoord().toBigInteger());
        ECNamedCurveSpec ecSpec = new ECNamedCurveSpec(
                spec.getName(),
                ellipticCurve,
                p, spec.getN(), spec.getH());

        return new BCECGOST3410PublicKey(algorithm, publicKeyParameters, ecSpec);
    }

Можно тестировать загрузку ключей из pkcs12

    @Before
    public void setUp() throws Exception {
        Security.addProvider(new BouncyCastleProvider());
        Security.addProvider(new KzGostProvider());
        XmlSecAlgorithmRegistrator.register(); //это будет описано далее
    }

    @Test
    public void testReadTumarKey() throws Exception{

        Set<Object> keySet = Security.getProvider("GOSTKZ").keySet();
        for(Object o : keySet){
            if(o.toString().contains("1.3.6.1.4.1.6801.1.5.8")) {
                System.out.println(o + " -> " + Security.getProvider("GOSTKZ").get(o));
            }
        }

        String keyPath = "key/GOST/pkcs12_sign.p12";
        KeyStore ks = KeyStore.getInstance("PKCS12");
        ks.load(new FileInputStream(keyPath), password.toCharArray());
        Assert.assertNotNull(ks);
        Enumeration<String> aliases = ks.aliases();
        String a;
        PrivateKey privateKey = null;
        X509Certificate cert = null;
        while (aliases.hasMoreElements()){
            a = aliases.nextElement();
            System.out.println(a);
            if(ks.isKeyEntry(a)) {
                privateKey = (PrivateKey) ks.getKey(a, password.toCharArray());
                Assert.assertNotNull(privateKey);
                cert = (X509Certificate) ks.getCertificate(a);
                Assert.assertNotNull(cert);
            }
        }
   }

Но это только треть работы. Приступаем к формированию подписи с помошью org.apache.santuario.xmlsec (2.0.8) последней на данный момент версии.
Нам нужно зарестрировать алгоритмы для xmlsec

public class XmlSecAlgorithmRegistrator {

    public static final String signatureUrl = "http://www.w3.org/2001/04/xmldsig-more#gost34310-gost34311";
    public static final String digestUrl = "http://www.w3.org/2001/04/xmldsig-more#gost34311";

    public static void register() throws ClassNotFoundException, AlgorithmAlreadyRegisteredException, XMLSignatureException, ParserConfigurationException {
        Init.init();
        DocumentBuilderFactory documentbuilderfactory = DocumentBuilderFactory.newInstance();
        documentbuilderfactory.setNamespaceAware(true);

        SignatureAlgorithm.register(signatureUrl, "com.gost.xmlsec.XmlSecSignatureGost34310$Gost34310Gost34311XmlSec");
        SignatureAlgorithm.register(digestUrl, "com.gost.xmlsec.XmlSecSignatureGost34310$Gost34311XmlSec");


        String throwable = "http://www.xmlsecurity.org/NS/#configuration";
        Document document = documentbuilderfactory.newDocumentBuilder().newDocument();
        {
            Element element = document.createElementNS(throwable, "Algorithm");
            element.setAttribute("URI", signatureUrl);
            element.setAttribute("Description", "GOST 34310 Digital Signature Algorithm with GOST 34311 Digest");
            element.setAttribute("AlgorithmClass", "Signature");
            element.setAttribute("RequirementLevel", "OPTIONAL");
            element.setAttribute("JCEName", "ECGOST34310");
            JCEMapper.Algorithm algorithm = new JCEMapper.Algorithm(element);
            JCEMapper.register(signatureUrl, algorithm);
        }
        {
            Element element = document.createElementNS(throwable, "Algorithm");
            element.setAttribute("URI", digestUrl);
            element.setAttribute("Description", "GOST 34311 Digest");
            element.setAttribute("AlgorithmClass", "MessageDigest");
            element.setAttribute("RequirementLevel", "OPTIONAL");
            element.setAttribute("JCEName", "ECGOST34311");
            JCEMapper.Algorithm algorithm = new JCEMapper.Algorithm(element);
            JCEMapper.register(digestUrl, algorithm);
        }

    }

}

тут примечательны строки 
        SignatureAlgorithm.register(signatureUrl, "com.gost.xmlsec.XmlSecSignatureGost34310$Gost34310Gost34311XmlSec");
        SignatureAlgorithm.register(digestUrl, "com.gost.xmlsec.XmlSecSignatureGost34310$Gost34311XmlSec");

в которых происходит регистрация классов оберток для реализаций алгоритмов, и 
            element.setAttribute("JCEName", "ECGOST34310"); 
            element.setAttribute("JCEName", "ECGOST34311");
в которых происходит указание на то. какой класс из JCE провайдера использовать.

public abstract class XmlSecSignatureGost34310 extends org.apache.xml.security.algorithms.SignatureAlgorithmSpi {
    private Signature signatureAlgorithm = null;

    public abstract String engineGetURI();

    public XmlSecSignatureGost34310() throws XMLSignatureException {
        String s = JCEMapper.translateURItoJCEID(this.engineGetURI());
        try {
            this.signatureAlgorithm = Signature.getInstance(s);
        } catch (NoSuchAlgorithmException var4) {
            throw new XMLSignatureException("algorithms.NoSuchAlgorithm", new Object[]{s, var4.getLocalizedMessage()});
        }
    }

    protected void engineSetParameter(AlgorithmParameterSpec spec) throws XMLSignatureException {
        try {
            this.signatureAlgorithm.setParameter(spec);
        } catch (InvalidAlgorithmParameterException e) {
            throw new XMLSignatureException(e);
        }
    }
    .... куча методов - оберток, делегирующих методы signatureAlgorithm

    protected String engineGetJCEAlgorithmString() {
        return this.signatureAlgorithm.getAlgorithm();
    }

    protected String engineGetJCEProviderName() {
        return this.signatureAlgorithm.getProvider().getName();
    }

    protected void engineSetHMACOutputLength(int i) throws XMLSignatureException {
        throw new XMLSignatureException("algorithms.HMACOutputLengthOnlyForHMAC");
    }

    protected void engineInitSign(Key key, AlgorithmParameterSpec algorithmparameterspec) throws XMLSignatureException {
        throw new XMLSignatureException("algorithms.CannotUseAlgorithmParameterSpecOnSignatureGost34310");
    }

    public static class Gost34310Gost34311XmlSec extends XmlSecSignatureGost34310 {

        public String engineGetURI() {
            return "http://www.w3.org/2001/04/xmldsig-more#gost34310-gost34311";
        }

        public Gost34310Gost34311XmlSec() throws XMLSignatureException {
        }
    }
    public static class Gost34311XmlSec extends XmlSecSignatureGost34310 {

        public String engineGetURI() {
            return "http://www.w3.org/2001/04/xmldsig-more#gost34311";
        }

        public Gost34311XmlSec() throws XMLSignatureException {
        }
    }
}

и в провайдер добавляются строки 

        put("Signature.ECGOST34310", "com.gost.jce.ECGOST34310SignatureSpi"); // signature ECGOST3410 with digest GOST3411 with D-Test SBlock
        put("MessageDigest.ECGOST34311", "com.gost.jce.ECGOST34311Digest"); // hash GOST3411 with D-Test SBlock

которые отсылают к конкретной реализации подписи и хэша. Если бы Tumar использовал для хэширования те же самые S-блоки, что и BouncyCastle (D-A) то создавать отдельных файлов не потребовалось бы, а так приходится заменять digest GOST3411Digest другим экземпляром, созданным с правильными S-блоками, иначе другое значение хэша и подпись не пройдет проверку.

Тут через рефлекшн подменяется поле digest.
public class ECGOST34310SignatureSpi extends org.bouncycastle.jcajce.provider.asymmetric.ecgost.SignatureSpi {

    public ECGOST34310SignatureSpi() throws Exception {
            final Field digest = SignatureSpi.class.getDeclaredField("digest");
            digest.setAccessible(true);
            digest.set(this, new GOST3411Digest(GOST28147Engine.getSBox("D-test")));
        }catch (NoSuchFieldException ex){
            logger.error("tested with BouncyCastle 1.57, check private field  `digest` in org.bouncycastle.jcajce.provider.asymmetric.ecgost.SignatureSpi", ex);
           throw ex;
        }catch (SecurityException | IllegalAccessException ex){
            logger.error(ex);
            throw ex;
        }
    }
}

А тут просто тривиальная реализация с правильным digest.
public class ECGOST34311Digest extends MessageDigest {
    private GOST3411Digest digest = new GOST3411Digest(GOST28147Engine.getSBox("D-test"));

    public ECGOST34311Digest() {
        super("GOST3411");
    }

    protected ECGOST34311Digest(String algorithm) {
        super(algorithm);
    }

    @Override
    protected void engineUpdate(byte input) {
        digest.update(input);
    }

    @Override
    protected void engineUpdate(byte[] input, int offset, int len) {
        digest.update(input, offset, len);
    }

    @Override
    protected byte[] engineDigest() {
        byte[] hash = new byte[digest.getDigestSize()];
        digest.doFinal(hash, 0);
        return hash;
    }

    @Override
    protected void engineReset() {
        digest.reset();
    }
}

В принципе, теперь почти все готово для тестирования, нужно только написать классы-обертки для формирования и проверки подписи.

public class XmlSecRequestHelper {

    public static String signRequest(String requestXml, X509Certificate cert, PrivateKey privateKey) throws Exception {
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        dbf.setNamespaceAware(true);
        DocumentBuilder documentBuilder = dbf.newDocumentBuilder();
        Document doc = documentBuilder.parse(new ByteArrayInputStream(requestXml.getBytes(UTF_8)));

        Element tbsEl = (Element) doc.getElementsByTagName("body").item(0);
        tbsEl.setIdAttribute("id", true);

        XMLSignature xmlSignature = new XMLSignature(doc, "", XmlSecAlgorithmRegistrator.signatureUrl);

        Transforms transforms = new Transforms(doc);
        transforms.addTransform(TRANSFORM_ENVELOPED_SIGNATURE);
        transforms.addTransform(TRANSFORM_C14N_WITH_COMMENTS);

        doc.getElementsByTagName("security").item(0).appendChild(xmlSignature.getElement());

        xmlSignature.addDocument("#signedContent", transforms, XmlSecAlgorithmRegistrator.digestUrl);
        xmlSignature.addKeyInfo(cert);
        xmlSignature.sign(privateKey);

        StringWriter os = new StringWriter();
        TransformerFactory tf = TransformerFactory.newInstance();
        Transformer trans = tf.newTransformer();
        trans.transform(new DOMSource(doc), new StreamResult(os));
        os.close();
        return os.toString();
    }


    public static boolean checkSignature(String requestXml) throws XMLSecurityException, IOException, SAXException, ParserConfigurationException {

        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        dbf.setNamespaceAware(true);
        DocumentBuilder documentBuilder = dbf.newDocumentBuilder();
        Document doc = documentBuilder.parse(new ByteArrayInputStream(requestXml.getBytes(UTF_8)));
        Element sigElement = (Element) doc.getElementsByTagName("ds:Signature").item(0);
        ((Element) doc.getElementsByTagName("body").item(0)).setIdAttribute("id", true);
        XMLSignature signature = new XMLSignature(sigElement, "");
        KeyInfo ki = signature.getKeyInfo();
        return signature.checkSignatureValue(ki.getX509Certificate());
    }
}

и остаток теста

          String request ="<request><header><security/></header><body id=\"signedContent\"><serviceId>753</serviceId><accountId>7688</accountId><amount>123</amount><commission>10</commission></body></request>";

        String signedRequest = XmlSecRequestHelper.signRequest(request, cert, privateKey );
        System.out.println(signedRequest);

        String terminalId = "000";
        String userId = "111";
        String password = "xxx";

        String url = "https://xxx.xxx.xxx.xxx:8080/";
        HttpsURLConnection connection = (HttpsURLConnection) new URL(url).openConnection();
        connection.setHostnameVerifier(new HostnameVerifier() {
            @Override
            public boolean verify(String s, SSLSession sslSession) {
                return true;
            }
        });
        connection.setSSLSocketFactory(getSSLContext().getSocketFactory()); // getSSLContext возвращает кастомный SSL контекст, поскольку сервер использует самоподписанный сертификат
        connection.setDoOutput(true);
        connection.setRequestMethod("POST");
        connection.setRequestProperty("Content-Type", "application/xml");
        connection.setRequestProperty("ProtocolVersion", "1");
        connection.setRequestProperty("OperationType", "1");
        connection.setRequestProperty("Authorization", "Basic " + java.util.Base64.getEncoder().encodeToString((terminalId + "|" + userId + ":" + password).getBytes(UTF_8)));

        try( DataOutputStream wr = new DataOutputStream( connection.getOutputStream())) {
            wr.write( signedRequest.getBytes(UTF_8) );
            wr.flush();
        }
        Reader in = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));
        Map<String, List<String>> headers = connection.getHeaderFields();

        for(Map.Entry<String, List<String>> entry : headers.entrySet()){
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
        System.out.println("--------------------------------------------");
        StringBuffer sb = new StringBuffer();

        for (int c; (c = in.read()) >= 0;) {
            System.out.print((char) c);
            sb.append((char)c);
        }
        String prolog = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
        int ind = sb.indexOf(prolog);
        sb.insert(ind + prolog.length(), "\n"); // если это топо, но работает, то это не так уж и тупо?
        System.out.println("signature valid : " + XmlSecRequestHelper.checkSignature(sb.toString()));

Как результат - запрос отправляется, подпись валидна, TumarCSP не используется.


четверг, 20 ноября 2014 г.

Реализация взаимодействия с веб-сервисом и формирование гостовой подписи с помощью OpenSSL

В данной статье описывается как прикрутить OpenSSL для организации подписи (платежные шлюзы билайна и мосэнергосбыта). Подпись и проверку подписи будем делать вручную, перехватывая сообщения перед отправкой/после получения. поскольку реализация веб-сервиса не оставляет другого выбора.
Будем использовать apache CXF 2.7.8 для работы с веб-сервисом. Для подписи будем использовать OpenSSL, предварительно сконвертировав ключи в pkcs12 формат, как описано в предыдущей статье.

и немного кода:

        logger.info("---------------WS-URL---------------");
        logger.info(config.getString("ws.service.url"));
        logger.info("-------------------------------------");

        QName SERVICE_NAME = new QName("http://tempuri.org", "PaymentGateService");
        QName PORT_NAME = new QName("http://tempuri.org", "PaymentGatePort");

        Service paymnetService = Service.create(SERVICE_NAME);
        paymnetService.addPort(PORT_NAME, SOAPBinding.SOAP11HTTP_BINDING, Config.getWsAddress());
        PaymentGate iface = paymnetService.getPort(PORT_NAME, PaymentGate.class);

        SignatureInterceptor transformOutInterceptor = new SignatureInterceptor();
        Client client = ClientProxy.getClient(iface);
        HTTPConduit http = (HTTPConduit) client.getConduit();
        final TrustManager[] trustAllCerts = new TrustManager[]{new X509TrustManager() {
            @Override
            public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                return null;
            }
            @Override
            public void checkClientTrusted(X509Certificate[] certs, String authType) {
            }
            @Override
            public void checkServerTrusted(X509Certificate[] certs, String authType) {
            }
        }
        };
        TLSClientParameters parameters = new TLSClientParameters();
        parameters.setTrustManagers(trustAllCerts);
        parameters.setDisableCNCheck(true);
        http.setTlsClientParameters(parameters);

        HTTPClientPolicy httpClientPolicy = new HTTPClientPolicy();

        httpClientPolicy.setConnectionTimeout(10000);
        httpClientPolicy.setAllowChunking(false);
        httpClientPolicy.setReceiveTimeout(40000);

        http.setClient(httpClientPolicy);

        client.getOutInterceptors().add(new LoggingOutInterceptor());
        client.getOutInterceptors().add(transformOutInterceptor);
        client.getInInterceptors().add(new SignatureVerificationInterseptor());
        System.setProperty("com.sun.xml.ws.transport.http.client.HttpTransportPipe.dump", String.valueOf(Config.isHttpDump()));

Для формирования подписи нам нужно получить сообщение целиком в том виде, в котором оно будет отправлено. Каноникализация производится неявным образом, путем удаления всего форматирования xml документа. используем следующий код, частично скопированный из исходников CXF. Из тонких моментов - инвертация полученной подписи. Видимо есть различия в том, как CryptoPro и OpenSSL возвращают результат подписи, кто-то в Big-endian, кто-то в Little-endian
public class SignatureInterceptor extends AbstractOutDatabindingInterceptor {
    private final static Logger logger = LoggerFactory.getLogger(SignatureInterceptor.class);

    public SignatureInterceptor() {
        super(Phase.PRE_LOGICAL);
        getBefore().add(HolderOutInterceptor.class.getName());
    }

    public void handleMessage(Message message) throws Fault {
        try {
            OutputStream out = new ByteArrayOutputStream();
            Exchange exchange = message.getExchange();
            Service service = exchange.getService();
            XMLOutputFactory instance = XMLOutputFactory.newInstance();
            XMLStreamWriter xmlWriter = instance.createXMLStreamWriter(out);

            DataWriter<XMLStreamWriter> dataWriter = getDataWriter(message, service, XMLStreamWriter.class);
            OperationInfo op = exchange.getBindingOperationInfo().getOperationInfo();
            List<MessagePartInfo> parts = op.getInput().getMessageParts();
            MessageContentsList objs = MessageContentsList.getContentsList(message);
            for (MessagePartInfo part : parts) {
                if (objs.hasValue(part)) {
                    Object o = objs.get(part);
                    if (!part.getConcreteName().getLocalPart().equals("digitalSignature")) {
                        dataWriter.write(o, part, xmlWriter);
                    }
                }
            }
            xmlWriter.flush();
            logger.debug("SIGNATURE BEGIN");
            logger.debug(out.toString());
            String signature = sign(out.toString());
            logger.debug(signature);
            logger.debug("signature length = " + signature.length());
            logger.debug("SIGNATURE END");
            xmlWriter.close();
            for (MessagePartInfo part : parts) {
                if (part.getConcreteName().getLocalPart().equals("digitalSignature")) {
                    DigitalSignature ds = new DigitalSignature();
                    ds.setSignature(signature);
                    objs.put(part, ds);
                }
            }
        } catch (Exception ex) {
            throw new Fault(ex);
        }
    }

    private static String sign(String content) throws SignatureException{
        File f = null;
        File fOut = null;
        try {
            f = File.createTempFile("input", "data");
            FileOutputStream foutStream = new FileOutputStream(f);
            IOUtils.write(content, foutStream);
            foutStream.flush();
            IOUtils.closeQuietly(foutStream);
            fOut = File.createTempFile("input", "sng");

            ProcessBuilder pb = new ProcessBuilder(Config.getInstance().getString("crypto.command"),
                    "dgst",
                    "-engine",
                    "gost",
                    "-binary",
                    "-md_gost94",
                    "-out",
                    fOut.getAbsolutePath(),
                    "-sign",
                    Config.getInstance().getString("crypto.private.key"),
                    f.getAbsolutePath());

            logger.debug(StringUtils.join(pb.command(), " "));

            Process p = pb.start();
            InputStream is = p.getErrorStream();
            p.waitFor();
            if (p.exitValue() != 0) {
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                IOUtils.copy(is, out);
                logger.error(out.toString("UTF-8"));
                IOUtils.closeQuietly(is);
                IOUtils.closeQuietly(out);
                throw new SignatureException("OpenSSL return error code: " + p.exitValue());
            }
            IOUtils.closeQuietly(is);
            FileInputStream fis = new FileInputStream(fOut);
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            IOUtils.copy(fis, bos);
            IOUtils.closeQuietly(fis);
            byte[] res = bos.toByteArray();
            IOUtils.closeQuietly(bos);
            // Инвертируем полученную подпись - иначе она считается невалидной.
            byte[] inverted = new byte[res.length];
            for(int i = 0; i< res.length; i++){
                inverted[res.length-i-1] = res[i];
            }
            return new String(Base64.encodeBase64(inverted, false));
        } catch (IOException ex) {
            throw new SignatureException(ex.getMessage(), ex);
        } catch (InterruptedException e) {
            logger.error("Signature process was interrupted, returning null...");
            return null;
        } finally {
            FileUtils.deleteQuietly(f);
            FileUtils.deleteQuietly(fOut);
        }
    }


}
И проверка подписи:
public class SignatureVerificationInterseptor extends LoggingInInterceptor {
    private final static Logger logger = LoggerFactory.getLogger(SignatureVerificationInterseptor.class);

    public SignatureVerificationInterseptor() {
        super();
    }

    @Override
    protected String formatLoggingMessage(LoggingMessage loggingMessage) {
        String soapXmlPayload = loggingMessage.getPayload().toString();

        try {
            String content = soapXmlPayload.substring(soapXmlPayload.indexOf("<soapenv:Body>") + "<soapenv:Body>".length(), 
                                                   soapXmlPayload.indexOf("</soapenv:Body>"));
            String signature = soapXmlPayload.substring(soapXmlPayload.indexOf("<signature>") + "<signature>".length(),
                                                   soapXmlPayload.indexOf("</signature>"));
            logger.debug("signature verifying");
            logger.debug(content);
            logger.debug(signature);
            if (!verify(content, signature)) {
                logger.debug(super.formatLoggingMessage(loggingMessage));
                throw new SignatureVerificationException("Signature verification error");
            }
        }catch (SignatureVerificationException ex){
            throw ex;
        }catch (Exception ex){
            logger.debug(super.formatLoggingMessage(loggingMessage));
            throw new RuntimeException("Signature not found in soap envelope");
        }
        return super.formatLoggingMessage(loggingMessage);
    }

    private static boolean verify(String content, String signature){
        File signatureFile = null;
        File datafile = null;
        try {
            signatureFile = File.createTempFile("output", "sng");
            FileOutputStream signatureStream = new FileOutputStream(signatureFile);
            byte[] sig = Base64.decodeBase64(signature.getBytes());
            // Инвертируем полученную подпись - иначе она считается невалидной.
            byte[] inverted = new byte[sig.length];
            for(int i = 0; i< sig.length; i++){
                inverted[sig.length-i-1] = sig[i];
            }
            IOUtils.write(inverted, signatureStream);
            signatureStream.flush();
            IOUtils.closeQuietly(signatureStream);


            datafile = File.createTempFile("output", "data");
            FileOutputStream dataStream = new FileOutputStream(datafile);
            IOUtils.write(content, dataStream);
            dataStream.flush();
            IOUtils.closeQuietly(dataStream);

            ProcessBuilder pb = new ProcessBuilder(Config.getInstance().getString("crypto.command"),
                    "dgst",
                    "-engine",
                    "gost",
                    "-binary",
                    "-verify",
                    Config.getInstance().getString("crypto.public.cert"),
                    "-signature",
                    signatureFile.getAbsolutePath(),
                    datafile.getAbsolutePath());

            logger.debug(StringUtils.join(pb.command(), " "));

            Process p = pb.start();
            InputStream is = p.getErrorStream();
            p.waitFor();
            if (p.exitValue() != 0) {
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                IOUtils.copy(is, out);
                logger.error(out.toString("UTF-8"));
                IOUtils.closeQuietly(is);
                IOUtils.closeQuietly(out);
                return false;
            }
            return true;
        }catch (Exception ex){
            logger.error(ex.getClass().toString() + " message:" + ex.getMessage(), ex);
            return false;
        } finally {
            FileUtils.deleteQuietly(signatureFile);
            FileUtils.deleteQuietly(datafile);
        }
    }

пятница, 15 июня 2012 г.

Использование OpenSource крипто библиотек для работы с ГОСТовыми сертификатами CryptoPro

В данной статье делается попытка ответить на вопрос: возможно ли использовать OpenSource библиотеки для работы с ГОСТовыми сертификатами?
Если коротко, то да.
Для проверки использовалась последняя на данный момент версия OpenSSL (1.0.1с), собранная из исходников с поддержкой gost engine
Для начала нужно установить КриптоПро CSP 3.6 R3, поскольку в нем реализована поддержка экспорта сертификатов в формате pfx. Эту часть работ нужно делать в операционной системе Windows. Не буду описывать подробно этот процесс, скажу лишь, что нужно сохранить приватный ключ в формате CryptoPro на флэшку и импортировать его в хранилище "Реестр". Выгрузив сертификат в файл, например store.pfx (включая приватный ключ), можно вывести приватный ключ в stdout командой
/usr/local/ssl/bin/openssl pkcs12 -info -engine gost -nodes -in ~/store.pfx 

  • -info вывести информацию о содержимом файла в формате pkcs12 (.pfx)
  • -engine использовать указанный криптографический модуль
  • -nodes не нужно шифровать приватный ключ
  • -in входной файл
Если вы получаете ошибку вида "unknown PBE algorithm"
Enter Import Password:
MAC Iteration 2000
MAC verified OK
PKCS7 Data
Shrouded Keybag: undefined, Iteration 2000
Bag Attributes
    Microsoft Local Key set: <No Values>
    localKeyID: 01 00 00 00
    friendlyName: REGISTRY\\1ba6dcf8-b953-4774-8a9e-de98de071f24
    Microsoft CSP Name: Crypto-Pro GOST R 34.10-2001 Cryptographic Service Provider
Error outputting keys and certificates
140669637789344:error:06074079:digital envelope routines:EVP_PBE_CipherInit:unknown pbe algorithm:evp_pbe.c:167:TYPE=1.2.840.113549.1.12.1.80
140669637789344:error:23077073:PKCS12 routines:PKCS12_pbe_crypt:pkcs12 algor cipherinit error:p12_decr.c:83:
140669637789344:error:2306A075:PKCS12 routines:PKCS12_item_decrypt_d2i:pkcs12 pbe crypt error:p12_decr.c:130:
То это означает, что вам потребуется другое средство для получения pfx файла, утилитка P12FromGostCSP.exe
Если вы получаете ошибку вида "unknown digest algorithm"

Enter Import Password:
MAC Iteration 2048
Mac verify error: invalid password?
140572666472096:error:2306B076:PKCS12 routines:PKCS12_gen_mac:unknown digest algorithm:p12_mutl.c:88:
140572666472096:error:2307E06D:PKCS12 routines:PKCS12_verify_mac:mac generation error:p12_mutl.c:122:

то скорее всего в вашем openssl нет поддержки ГОСТовых алгоритмов либо вы используете не ту копию openssl.

Если все прошло без ошибок, то в консоли вы получите приватный ключ и сертификат. Скопировав выведенный в консоль приватный ключ (вместе со словами -----BEGIN PRIVATE KEY----- и -----END PRIVATE KEY-----) в отдельный файл private.key мы сможем с его помощью создавать ЭЦП.

Команда для генерации примерно следующая:

/usr/local/ssl/bin/openssl cms -sign -inkey ~/private.key -in ~/file.txt -CAfile ~/CA.cer 
-signer ~/client.cer -engine gost -out ~/test.sign -outform DER -noattr -binary

  • -sign генерация подписи
  • -inkey путь к приватному ключу
  • -in подписываемый файл
  • -CAfile файл УЦ
  • -signer файл с сертификатом, которым осуществляется подпись
  • -engine использовать указанный криптографический модуль
  • -out файл, в который будет записана ЭЦП
  • -outform формат подписи
  • -noattr не добавлять дополнительных аттрибутов в подпись
  • -binary считать подписываемый файл массивом байт, а не текстом

К сожалению, Bouncy Castle (версии 1.46), хоть в нем и декларируется поддержка ГОСТовых алгоритмов, не может разобрать формат приватного ключа, так что использовать его для генерации ЭЦП на данный момент не представляется возможным.

UPD:
Bouncy Castle 1.55 уже умеет работать с такими приватными ключами

суббота, 9 июня 2012 г.

Создание ЭЦП с помощью CryptoPro

В данной статье описывается процесс создания ЭЦП c помощью библиотеки CryptoPro.
Для создания подписи необходим приватный ключ и сертификат. Рассмотрим гипотетическую ситуацию, когда приватный ключ прислан по почте, а не сгенерирован самостоятельно - порочная, но широко распространенная практика.
Предположим, что файл клиентского сертификата называется client.cer, сертификата УЦ - CA.cer, а приватный ключ находится в директории 999996.000

1. Установка CryptoPro CSP и CryptoPro JCP

Добываем каким-либо образом дистрибутивы, самый простой способ - скачать их с сайта CryptoPro, предварительно там зарегистрировавшись. Триальная версия полнофункциональна и работает 30 дней.
При установке CSP пакет cprocsp-rdr-gui скорее всего не установится, поскольку использует древние версии Motif, но он не нужен для работы, так что установка данного пакета не является обязательной.
Также нужно убедиться, что в системе есть libcurl.so (эта библиотека используется для получения CRL)
После установки необходимо проверить, что в файле /etc/opt/cprocsp/config.ini прописан правильный путь к libcurl.so, по умолчанию он ведет на /usr/local/lib/64/libcurl.so что является ошибкой.
После этого устанавливаем CryptoPro JCP (jcp_plus_jtls_1.0.53.jar)
После успешной установки нужно запустить ControlPane.sh из-под рута и поменять путь к хранилищу ключей на /var/opt/cprocsp/keys/{$user.name}

2. Установка приватного ключа и сертификатов

CryptoPro имеет свой собственный формат приватного ключа и свои собственные контейнеры для хранения ключей и сертификатов. Чтобы установить ключ и сертификаты в контейнеры, нужно проделать следующие действия:

  • Скопировать в корень дискеты или флэшки сертификат и приватный ключ. Под приватным ключом понимается директория 999996.000 и ее содержимое, файлы header.key, masks2.key, masks.key, name.key, primary2.key, primary.key
    $ cp -R /path/to/key/999996.000 /media/flashdrive/
    $ cp /path/to/cert/client.cer /media/flashdrive/
    
  • Выполнить команду по копированию ключа с флэшки на диск. Ключ попадет в пользовательское хранилище 'My'. Выполнять команду нужно под пользователем, который будет использовать данный контейнер для подписи. 999996 - название (alias) контейнера. gate@example.com - то, что прописано в поле E сертификата ( можно посмотреть командой keytool --printcert -file /path/to/cert/client.cer )
    $ csptest -keycopy -src '\\.\FLASH\gate@example.com' -dest '\\.\HDIMAGE\999996'
    Проверить, что все скопировалось, можно командой
    $ ls -al /var/opt/cprocsp/keys/<username>
  • Альтернативный путь, если нет дискеты или csptest выдает ошибку
    Error number 0x8009000f (2148073487). Object already exists.
    Руками скопировать приватный ключ в хранилище командой
    $ cp -R /path/to/key/999996.000 /var/opt/cprocsp/keys/<username>/
  • Ассоциировать сертификат с контейнером. Сертификат попадет в пользовательское хранилище 'My'
    $ certmgr -inst -file /path/to/file/client.cer -cont '\\.\HDIMAGE\999996'
  • Установить сертификат УЦ из-под пользователя root командой
    # certmgr -inst -store root -file /path/to/file/CA.cer
Контейнер должен быть готов к использованию, проверить это можно командами:
$ certmgr --list
Certmgr 0.9 prerelease (c) "CryptoPro",  2007-2010.
program for managing certificate(CRL) and stores

=============================================================================
1-------
Issuer         : DC=ru, DC=issuer, CN=EXAMPLE
Subject        : C=RU, S=RUSSIA, L=MOSCOW, O=ORGANIZATION, OU=IT, CN=GATE_DEMO, E=gate@example.com
Serial         : 0x2225000000007DF78065
PrivateKey Link: Yes. Container: HDIMAGE\\999996.000\D7BB
=============================================================================

[ErrorCode: 0x00000000]
Обратите внимание на строку "PrivateKey Link: Yes. Container: HDIMAGE\\999996.000\D7BB". Она показывает наличие связи сертификата и приватного ключа, если выводится "PrivateKey Link: No" это означает, что связь не установлена и использовать такой контейнер для подписи не удастся.
$ certmgr --list -store root
Certmgr 0.9 prerelease (c) "CryptoPro",  2007-2010.
program for managing certificate(CRL) and stores

=============================================================================
1-------
Issuer         : DC=ru, DC=issuer, CN=EXAMPLE
Subject        : DC=ru, DC=issuer, CN=EXAMPLE
Serial         : 0xE44263EF7B42044F9E20FFF14C6F1327
PrivateKey Link: No
=============================================================================

[ErrorCode: 0x00000000]

3. Генерация ЭЦП

Под ЭЦП обычно понимается отсоединенная (detached) подпись в формате pkcs#7. Т.е помимо самой подписи, в сообщение внедряется вся цепочка сертификатов. CryptoPro не предоставляет отдельного пакета CMS для легкой генерации криптографических сообщений, но в принципе в пакете JCP есть все необходимое, чтобы сформировать корректное сообщение самостоятельно. Код по большей части взят из примеров, которые идут в JCP.
    private static byte[] signWithCryptoProJcp(byte[] data) throws Exception{

        String alias = "999996";
        String caFile = "/path/to/CA.cer";
        String certFile = "/path/to/client.cer";

        //load keys for sign
        final PrivateKey[] keys = new PrivateKey[1];
        keys[0] = CMStools.loadKey(alias, null);

        //load certificates chain
        final Certificate[] certs = new Certificate[2];
// функция CMStools.loadCertificate() почему-то не работает, хотя сертификат есть в хранилище
// пришлось читать сертификат из файла
        certs[0] = CMStools.readCertificate(certFile);
        certs[1] = CMStools.readCertificate(caFile);
        return createCMS(data, keys, certs, true);
    }


    private static byte[] createCMS(byte[] data, PrivateKey[] keys,
                                   Certificate[] certs,
                                   boolean detached)
            throws Exception {
        //create CMS
//        Array.writeFile("/home/grigory/test.msg", data);
        final ContentInfo all = new ContentInfo();
        all.contentType = new Asn1ObjectIdentifier(new OID(CMStools.STR_CMS_OID_SIGNED).value);
        final SignedData cms = new SignedData();
        all.content = cms;
        cms.version = new CMSVersion(1);
        // digest
        cms.digestAlgorithms = new DigestAlgorithmIdentifiers(1);
        final DigestAlgorithmIdentifier a = new DigestAlgorithmIdentifier(
                new OID(CMStools.DIGEST_OID).value);
        a.parameters = new Asn1Null();
        cms.digestAlgorithms.elements[0] = a;
        if (detached)
            cms.encapContentInfo = new EncapsulatedContentInfo(
                    new Asn1ObjectIdentifier(
                            new OID(CMStools.STR_CMS_OID_DATA).value),
                    null);
        else
            cms.encapContentInfo =
                    new EncapsulatedContentInfo(new Asn1ObjectIdentifier(
                            new OID(CMStools.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();
            cms.signerInfos.elements[i] = 
                     new ru.CryptoPro.JCP.ASN.CryptographicMessageSyntax.SignerInfo();
            cms.signerInfos.elements[i].version = new CMSVersion(1);
            cms.signerInfos.elements[i].sid = new SignerIdentifier();

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

            final CertificateSerialNumber num = new CertificateSerialNumber(
                    ((X509Certificate) certs[i]).getSerialNumber());
            cms.signerInfos.elements[i].sid.set_issuerAndSerialNumber(
                    new IssuerAndSerialNumber(name, num));
            cms.signerInfos.elements[i].digestAlgorithm =
                    new DigestAlgorithmIdentifier(new OID(CMStools.DIGEST_OID).value);
            cms.signerInfos.elements[i].digestAlgorithm.parameters = new Asn1Null();
            cms.signerInfos.elements[i].signatureAlgorithm =
                    new SignatureAlgorithmIdentifier(new OID(CMStools.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);
//        Array.writeFile("/home/grigory/test.signature", asnBuf.getMsgCopy());
        return asnBuf.getMsgCopy();
    }
 
У CryptoPro есть замечательный сервис проверки ЭЦП, где можно проверить, что сгенерированная подпись верна.

четверг, 15 марта 2012 г.

Создание ЭЦП с помощью Signal COM

Цель этой статьи - разобраться, как использовать библиотеку Signal COM для создания ЭЦП. Под ЭЦП понимается подпись в формате PKCS#7, которая содержит помимо собственно подписи(ей) также информацию о сертификатах и не обязательные дополнительные атрибуты (время подписи и т.п)

  • Получение и установка дистрибутива

Вначале нужно получить дистрибутив библиотеки Signal COM, купив ее у производителя или скачав триальную версию с сайта. Нужны дистрибутивы Java CMS и JCP. Приобретать SDK настоятельно не рекомендую, поскольку содержание полностью соответствует таковому из триальной версии.

Установив дистрибутив, лучше в отдельную копию JDK, можно посмотреть, что же поменялось. Добавился новые jar файлы с реализацией криптопровайдера sccsp.jar и CMS sccms.jar, запись о регистрации криптопровайдера ru.signalcom.crypto.provider.SignalCOMProvider в файле java.security, подменились файлы local_policy.jar и US_export_policy.jar. По идее можно сразу приступать к работе.

  • Формирование хранилища

SignalCOM использует для хранения приватного ключа формат pkcs#8. Приватный ключ связан каким-то образом с генератором случайных чисел (при инициализации генератора случайных чисел требуется пароль от приватного ключа). Для работы в java удобнее всего сформировать хранилище в формате JKS или PKCS#12, для этого нужен приватный ключ и цепочка сертификатов.

Ниже приведен пример сборки хранилища для формата PKCS#12; формирование хранилища в формате JKS ничего принципиально от него ничем не отличается. Позднее, используя keytool, всегда можно сконвертировать хранилище в нужный формат, главное не забыть указать опцию -srcprovidername SC, поскольку не все провайдеры могут работать с гостовыми сертификатами. Также нужно учесть, что пароль на хранилище и приватный ключ будет одинаковым, даже если первоначально приватный ключ не имел пароля.

String root = "/home/gr/contact/TestKey";
        String certRoot = "/home/gr/contact/TestKey/CA";
        String clientCertRoot = "/home/gr/contact/TestKey/OpenKey";
        String passwd = "changeit";

        // Инициализация хранилища
        KeyStore store = KeyStore.getInstance("PKCS#12", "SC");
        store.load(null, null);

        // Чтение секретного ключа PKCS#8
        KeyFactory keyFac = KeyFactory.getInstance("PKCS#8", "SC");
        byte[] encoded = fread(root + FILE_SEPARATOR + "Keys" + FILE_SEPARATOR + "00000001.key");
        KeySpec privkeySpec = new PKCS8EncodedKeySpec(encoded);
        PrivateKey priv = keyFac.generatePrivate(privkeySpec);

        // Чтение сертификата УЦ
        CertificateFactory cf = CertificateFactory.getInstance("X.509", "SC");
        FileInputStream in = new FileInputStream(certRoot + FILE_SEPARATOR + "certca_1902.pem"); // CA 7
        X509Certificate cacert = (X509Certificate) cf.generateCertificate(in);
        in.close();

        // Чтение собственного сертификата
        in = new FileInputStream(clientCertRoot + FILE_SEPARATOR + "cert_9342.pem"); // CA 7
        X509Certificate cert = (X509Certificate) cf.generateCertificate(in);
        in.close();

        // Формирование цепочки сертификатов
        Certificate[] chain = new Certificate[2];
        chain[0] = cert;
        chain[1] = cacert;

        // Помещение в хранилище секретного ключа с цепочкой сертификатов
        store.setKeyEntry("Test key", priv, passwd.toCharArray(), chain);
        // Помещение в хранилище сертификата УЦ
        store.setCertificateEntry("Test CA", cacert);

        // Запись хранилища
        FileOutputStream out = new FileOutputStream(new File(root + FILE_SEPARATOR + "store.pfx"));
        store.store(out, passwd.toCharArray());
        out.close();

Пример конвертирования хранилища из формата PKCS#12 в JKS с использованием keytool

$keytool -importkeystore -srcstoretype pkcs12 -deststoretype JKS -srckeystore store.pfx -destkeystore test.jks -srcprovidername SC
  • Формирование подписи

После создания хранилища можно приступать к формированию подписи, это можно сделать с помощью следующего кода:

public static byte[] signPkcs7SignalCom(String pkcs12Store, String pass, String alias, 
                                        String keyPassword, byte[] data, SecureRandom random) throws SignatureException {
        try {
            FileInputStream in = null;
            ByteArrayInputStream inp = null;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            OutputStream sigOut = null;
            try{
                in = new FileInputStream(KEYSTORE_PATH + pkcs12Store);
                KeyStore keyStore = getKeystore(pkcs12Store, keyPassword, "PKCS12", "SC", random);
                keyStore.load(in, pass.toCharArray());
                List certs = new ArrayList();
                X509Certificate cert = (X509Certificate) keyStore.getCertificate(alias);
                //указываем, каким сертификатом будем подписывать
                certs.add(cert);
                PrivateKey priv = (PrivateKey) keyStore.getKey(alias, pass.toCharArray());

                SignedDataGenerator generator = new SignedDataGenerator(out);
                // экземпляр объекта SecureRandom должен быть предварительно проинициализирован!
                generator.addSigner(new Signer(priv, cert, random));
                generator.addCertificatesAndCRLs(CertStore.getInstance("Collection", new CollectionCertStoreParameters(certs)));
                //для создания отсоединенной подписи, т.е такой, которая не включает в себя данные, ставим true
                generator.setDetached(true);
                sigOut = generator.open();
                inp = new ByteArrayInputStream(data);
                byte[] buf = new byte[1024];
                int len;
                while ((len = inp.read(buf)) > 0) {
                    sigOut.write(buf, 0, len);
                }
                generator.close();
                byte[] signedData = out.toByteArray();
                // для тестовых целей можно провалидировать подпись, но в общем случае это не нужно
                //boolean res = verifyPkcs7Sign(signedData, data);
                return signedData;

            }finally{
                if(in != null)
                    in.close();
                if(inp != null)
                    inp.close();
                if(out!= null)
                    out.close();
                if(sigOut != null)
                    sigOut.close();
            }

        } catch (IOException e) {
            throw new SignatureException("Signing error", e);
        } catch (GeneralSecurityException e) {
            throw new SignatureException("Signing error", e);
        }catch (ru.signalcom.crypto.cms.CMSException e) {
            throw new SignatureException("Signing error", e);
        }
    }

Необычным тут является использование объекта SecureRandom, все остальное в принципе похоже на подписи с помощью остальных криптопровайдеров. SecureRandom нужно предварительно проинициализовать, используя следующий код:

        SecureRandom random = null;
        try {
            random = SecureRandom.getInstance("GOST28147PRNG", "SC");
            random.setSeed(new String(privateKeyDirectory + ";NonInteractive;Password=" + pass).getBytes());
        } catch (Exception e) {
            throw new SignatureException("Cannot init class secure random", e);
        }

privateKeyDirectory - путь до директории с файлами kek.opq masks.db3 mk.db3 rand.opq. причем для файла rand.opq должны быть выдано право на запись.

  • Валидация подписи

Для валидации подписи необходим сертификат, которым была осуществлена подпись и, если подпись была не присоединенной, исходные данные, которые были подписаны. В простейшем случае проверка подписи осуществляется так (этот код только проверяет, что подпись была осуществлена данным сертификатом, цепочка сертификатов не валидируется):

public static boolean verifyPkcs7SignatureSignalCom(String certKeystore, String keystorePass, 
                                                    String alias, byte[] signed, byte[] data) throws Exception {
        //List certStores = new ArrayList();

        FileInputStream inp = new FileInputStream(KEYSTORE_PATH + certKeystore);
        KeyStore store = KeyStore.getInstance("PKCS12", "SC");
        store.load(inp, keystorePass.toCharArray());
        inp.close();
        // получаем сертификат, которым производилась подпись
        X509Certificate cert = (X509Certificate) store.getCertificate(alias);
        if(cert ==null){
            throw new SignatureException("Certificate not found");
        }
        InputStream in = new ByteArrayInputStream(signed);
        ContentInfoParser cinfoParser = ContentInfoParser.getInstance(in);
        if (!(cinfoParser instanceof SignedDataParser)) {
            throw new RuntimeException("SignedData expected here");
        }
        SignedDataParser parser = (SignedDataParser) cinfoParser;
        InputStream content = parser.getContent();
        if (content == null) {
            // отсоединённая подпись
            if (data == null) {
                throw new RuntimeException("signature detached, please provide data to compare with");
            }
            parser.setContent(new ByteArrayInputStream(data));
        }
        parser.process();
        // почему-то не работает эта часть кода, хотя в документации сертификат получаелся именно таким способом
        //certStores.add(parser.getCertificatesAndCRLs());


        try {
            Collection signerInfos = parser.getSignerInfos();
            Iterator it = signerInfos.iterator();
            while (it.hasNext()) {
                SignerInfo signerInfo = it.next();
                // собственно валидация
                boolean res = signerInfo.verify(cert);
                return res;
            }
        } finally {
            parser.close();
            in.close();
        }

        return false;
    }