Bom dia.
Alguem pode me dar uma dica como resolvo a mensagem abaixo. Pesquisei e não consegui resolver.
No caso da GNRE precisa desta informação? e como Ficaria? //arquivo que contém a cadeia de certificados do serviço a ser consumido
// socketFactory.setFileCacerts(this.getClass().getResource(“C:/Certificados/nfe-cacerts”)); //mudei este trecho para a classe abaixo.
br.gov.pe.gnre.www.webservice.gnreconfiguf.GnreConfigUFStub$GnreDadosMsg@101f935
<ns1:TConfigUf xmlns:ns1=“http://www.gnre.pe.gov.br” xmlns=“http://www.gnre.pe.gov.br”>ns1:ambiente1</ns1:ambiente>ns1:ufMG</ns1:uf>ns1:situacaoConsultans1:codigo198</ns1:codigo>ns1:descricaoEste serviço deve usar uma conexão HTTPS Segura! Tente novamente utilizando seu Certificado Digital.</ns1:descricao></ns1:situacaoConsulta></ns1:TConfigUf>
import java.io.FileInputStream;
import java.net.URL;
import java.security.KeyStore;
import java.security.PrivateKey;
import java.util.Map;
import java.security.cert.X509Certificate;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.util.AXIOMUtil;
import org.apache.commons.httpclient.protocol.Protocol;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.HashMap;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import br.gov.pe.gnre.www.webservice.gnreconfiguf.GnreConfigUFStub;
public class TestGnreConfigUF_01 {
/**
* @param args
*/
public static void main(String[] args) {
try{
URL url = new URL("http://www.gnre.pe.gov.br/gnreWS/services/GnreConfigUF");
SelecionaCertificado selecionaCertificado = new SelecionaCertificado(null, true);
selecionaCertificado.setVisible(true);
Map map = selecionaCertificado.getDadosCertificado();
String caminhoCertificado = (String) map.get("caminhoCertificado");
char[] senha = (char[]) map.get("senha");
/**
* Informações do Certificado Digital.
*/
//busca os dados do certificado digital
KeyStore ks = KeyStore.getInstance("PKCS12");
ks.load(new FileInputStream(caminhoCertificado), senha);
String alias = ks.aliases().nextElement();
X509Certificate certificate = (X509Certificate) ks.getCertificate(alias);
PrivateKey privatekey = (PrivateKey) ks.getKey(alias, senha);
SocketFactoryDinamico socketFactory = new SocketFactoryDinamico(certificate, privatekey);
//arquivo que contém a cadeia de certificados do serviço a ser consumido
// socketFactory.setFileCacerts(this.getClass().getResource("C:/Certificados/nfe-cacerts")); //mudei este trecho para a classe abaixo.
// getClass().getResourceAsStream(): procura o resource no mesmo diretorio do .class.
//getClass().getClassLoader().getResourceAsStream(): procura no CLASSPATH.
//define o protocolo a ser utilizado na conexão
Protocol protocol = new Protocol("https", socketFactory, 443);
Protocol.registerProtocol("https", protocol);
StringBuilder xmls = new StringBuilder();
xmls.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>")
.append("<TConsultaConfigUf xmlns=\"http://www.gnre.pe.gov.br\">")
.append("<ambiente>1</ambiente><uf>MG</uf><receita courier=\"N\">100048</receita>")
.append("</TConsultaConfigUf></gnreDadosMsg");
String xml = xmls.toString();
OMElement ome = AXIOMUtil.stringToOM(xml);
GnreConfigUFStub.GnreDadosMsg dadosMsg = new GnreConfigUFStub.GnreDadosMsg();
dadosMsg.setExtraElement(ome);
GnreConfigUFStub.GnreCabecMsg cabecMsg = new GnreConfigUFStub.GnreCabecMsg();
cabecMsg.setVersaoDados("1.00");
GnreConfigUFStub stub = new GnreConfigUFStub(url.toString());
System.out.println(dadosMsg);
stub.consultar(dadosMsg, cabecMsg);
//NfeStatusServico2Stub.NfeStatusServicoNF2Result result = stub.nfeStatusServicoNF2(dadosMsg, nfeCabecMsgE);
GnreConfigUFStub.GnreRespostaMsg result = stub.consultar(dadosMsg, cabecMsg);
ByteArrayInputStream in = new ByteArrayInputStream(result.getExtraElement().toString().getBytes());
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setNamespaceAware(true);
// Document doc = dbf.newDocumentBuilder().parse(in);
System.out.println(result.getExtraElement().toString());
} catch (Exception e) {
error(e.toString());
}
}
private static void error(String log) {
System.out.println("ERROR: " + log);
}
}
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.Principal;
import java.security.PrivateKey;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.SocketFactory;
import javax.net.ssl.KeyManager;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509KeyManager;
import org.apache.commons.httpclient.ConnectTimeoutException;
import org.apache.commons.httpclient.params.HttpConnectionParams;
import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;
public class SocketFactoryDinamico implements ProtocolSocketFactory {
private SSLContext ssl = null;
private X509Certificate certificate;
private PrivateKey privateKey;
private InputStream fileCacerts;
public SocketFactoryDinamico(X509Certificate certificate,
PrivateKey privateKey) {
this.certificate = certificate;
this.privateKey = privateKey;
}
private SSLContext createSSLContext() {
try {
KeyManager[] keyManagers = createKeyManagers();
TrustManager[] trustManagers = createTrustManagers();
SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(keyManagers, trustManagers, null);
return sslContext;
} catch (KeyManagementException e) {
error(e.toString());
} catch (KeyStoreException e) {
error(e.toString());
} catch (NoSuchAlgorithmException e) {
error(e.toString());
} catch (CertificateException e) {
error(e.toString());
} catch (IOException e) {
error(e.toString());
}
return null;
}
private SSLContext getSSLContext() {
if (ssl == null) {
ssl = createSSLContext();
}
return ssl;
}
public Socket createSocket(String host, int port, InetAddress localAddress,
int localPort, HttpConnectionParams params) throws IOException,
UnknownHostException, ConnectTimeoutException {
if (params == null) {
throw new IllegalArgumentException("Parameters may not be null");
}
int timeout = params.getConnectionTimeout();
SocketFactory socketfactory = getSSLContext().getSocketFactory();
if (timeout == 0) {
return socketfactory.createSocket(host, port, localAddress,
localPort);
}
Socket socket = socketfactory.createSocket();
SocketAddress localaddr = new InetSocketAddress(localAddress, localPort);
SocketAddress remoteaddr = new InetSocketAddress(host, port);
socket.bind(localaddr);
try {
socket.connect(remoteaddr, timeout);
} catch (Exception e) {
error(e.toString());
throw new ConnectTimeoutException("Poss�vel timeout de conex�o", e);
}
return socket;
}
public Socket createSocket(String host, int port, InetAddress clientHost,
int clientPort) throws IOException, UnknownHostException {
return getSSLContext().getSocketFactory().createSocket(host, port,
clientHost, clientPort);
}
public Socket createSocket(String host, int port) throws IOException,
UnknownHostException {
return getSSLContext().getSocketFactory().createSocket(host, port);
}
public Socket createSocket(Socket socket, String host, int port,
boolean autoClose) throws IOException, UnknownHostException {
return getSSLContext().getSocketFactory().createSocket(socket, host,
port, autoClose);
}
public KeyManager[] createKeyManagers() {
HSKeyManager keyManager = new HSKeyManager(certificate, privateKey);
return new KeyManager[] { keyManager };
}
public TrustManager[] createTrustManagers() throws KeyStoreException,
NoSuchAlgorithmException, CertificateException, IOException {
KeyStore trustStore = KeyStore.getInstance("JKS");
trustStore.load(fileCacerts, "changeit".toCharArray());
TrustManagerFactory trustManagerFactory = TrustManagerFactory
.getInstance(TrustManagerFactory.getDefaultAlgorithm());
trustManagerFactory.init(trustStore);
return trustManagerFactory.getTrustManagers();
}
class HSKeyManager implements X509KeyManager {
private X509Certificate certificate;
private PrivateKey privateKey;
public HSKeyManager(X509Certificate certificate, PrivateKey privateKey) {
this.certificate = certificate;
this.privateKey = privateKey;
}
public String chooseClientAlias(String[] arg0, Principal[] arg1,
Socket arg2) {
return certificate.getIssuerDN().getName();
}
public String chooseServerAlias(String arg0, Principal[] arg1,
Socket arg2) {
return null;
}
public X509Certificate[] getCertificateChain(String arg0) {
return new X509Certificate[] { certificate };
}
public String[] getClientAliases(String arg0, Principal[] arg1) {
return new String[] { certificate.getIssuerDN().getName() };
}
public PrivateKey getPrivateKey(String arg0) {
return privateKey;
}
public String[] getServerAliases(String arg0, Principal[] arg1) {
return null;
}
}
public void setFileCacerts(InputStream fileCacerts) {
this.fileCacerts = fileCacerts;
System.setProperty("javax.net.ssl.trustStoreType", "JKS");
System.setProperty("javax.net.ssl.trustStore", "C:/Certificados/nfe-cacerts");
}
/**
* Log Error.
* @param log
*/
private static void error(String log) {
System.out.println("ERROR: " + log);
}
}
