Apache Camel Http et SSL

J'ai essayé d'obtenir un 2-way ssl/https proxy de travail avec le Chameau. J'ai pu mettre en place la Jetée Composant à l'aide de 2-way ssl et je suis en train d'essayer de le faire fonctionner avec la Http4 composant pour compléter le côté client du proxy.

Quand j'route de la jetée de la circulation dans un journal composant, tout est bien et le 2 way ssl chaîne de confiance est très bien. Lorsque je jette dans la Http4 composant, il explose avec un de ses pairs authentifié pas exception à la règle. Je suis à l'aide de Chameau 2.7.0

Voici ce que j'ai jusqu'à présent

public static void main(String[] args) throws Exception {
CamelContext context = new DefaultCamelContext();
JettyHttpComponent jetty = context.getComponent("jetty", JettyHttpComponent.class);
SslSelectChannelConnector sslConnector = new SslSelectChannelConnector();
sslConnector.setPort(9443);
sslConnector.setKeystore("/home/brian/jboss.keystore");
sslConnector.setKeyPassword("changeit");
sslConnector.setTruststore("/home/brian/jboss.truststore");
sslConnector.setTrustPassword("changeit");
sslConnector.setPassword("changeit");
sslConnector.setNeedClientAuth(true);
Map<Integer, SslSelectChannelConnector> connectors = new HashMap<Integer, SslSelectChannelConnector>();
connectors.put(9443, sslConnector);
jetty.setSslSocketConnectors(connectors);
final Endpoint jettyEndpoint = jetty.createEndpoint("jetty:https://localhost:9443/service");
KeyStore keystore = KeyStore.getInstance("PKCS12");
keystore.load(new FileInputStream(new File("/home/brian/User2.p12")), "Password1234!".toCharArray());
X509KeyManager keyManager = new CTSKeyManager(keystore, "user2", "Password1234!".toCharArray());
KeyManager[] keyManagers = new KeyManager[] { keyManager };
X509TrustManager trustManager = new EasyTrustManager();
TrustManager[] trustManagers = new TrustManager[] { trustManager };
SSLContext sslcontext = SSLContext.getInstance("TLS");
sslcontext.init(keyManagers, trustManagers, null);
SchemeRegistry registry = new SchemeRegistry();
registry.register(new Scheme("https", 443, new SSLSocketFactory(sslcontext,
SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER)));
HttpComponent http4 = context.getComponent("http4", HttpComponent.class);
http4.setClientConnectionManager(new ThreadSafeClientConnManager(registry));
final Endpoint https4Endpoint = http4
.createEndpoint("https4://soafa-lite-staging:443/axis2/services/SigActService?bridgeEndpoint=true&throwExceptionOnFailure=false");
context.addRoutes(new RouteBuilder() {
@Override
public void configure() {
from(jettyEndpoint).to(https4Endpoint);
}
});
context.start();
context.stop();
}
private static class EasyTrustManager implements X509TrustManager {
@Override
public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
@Override
public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
@Override
public X509Certificate[] getAcceptedIssuers() {
return null;
}
};
private static class CTSKeyManager extends X509ExtendedKeyManager {
private final KeyStore keystore;
private final char[] privateKeyPassword;
private final String privateKeyAlias;
public CTSKeyManager(KeyStore keystore, String privateKeyAlias, char[] privateKeyPassword) {
this.keystore = keystore;
this.privateKeyAlias = privateKeyAlias;
this.privateKeyPassword = privateKeyPassword;
}
@Override
public String[] getServerAliases(String keyType, Principal[] issuers) {
String[] serverAliases = null;
try {
List<String> aliasList = new ArrayList<String>();
int count = 0;
Enumeration<String> aliases = keystore.aliases();
while (aliases.hasMoreElements()) {
String alias = aliases.nextElement();
aliasList.add(alias);
count++;
}
serverAliases = aliasList.toArray(new String[count]);
} catch (Exception e) {
}
return serverAliases;
}
@Override
public PrivateKey getPrivateKey(String alias) {
PrivateKey privateKey = null;
try {
privateKey = (PrivateKey) keystore.getKey(alias, privateKeyPassword);
} catch (Exception e) {
}
return privateKey;
}
@Override
public String[] getClientAliases(String keyType, Principal[] issuers) {
return privateKeyAlias == null ? null : new String[] { privateKeyAlias };
}
@Override
public X509Certificate[] getCertificateChain(String alias) {
X509Certificate[] x509 = null;
try {
Certificate[] certs = keystore.getCertificateChain(alias);
if (certs == null || certs.length == 0) {
return null;
}
x509 = new X509Certificate[certs.length];
for (int i = 0; i < certs.length; i++) {
x509[i] = (X509Certificate) certs[i];
}
} catch (Exception e) {
}
return x509;
}
@Override
public String chooseServerAlias(String keyType, Principal[] issuers, Socket socket) {
return privateKeyAlias;
}
@Override
public String chooseClientAlias(String[] keyType, Principal[] issuers, Socket socket) {
return privateKeyAlias;
}
@Override
public String chooseEngineClientAlias(String[] keyType, Principal[] issuers, SSLEngine engine) {
return privateKeyAlias;
}
@Override
public String chooseEngineServerAlias(String keyType, Principal[] issuers, SSLEngine engine) {
return privateKeyAlias;
}
}
}

Aussi loin que je peux dire, la confiance doit être fine entre tous les fichiers de clés/truststores utilisé sur les deux côtés de la les connexions proxy.

Voici ma trace de la pile

[ qtp25584663-14] HttpProducer DEBUG Exécution de la méthode http POST: https4://soafa-lite-staging:443/axis2/services/SigActService?bridgeEndpoint=true&throwExceptionOnFailure=faux 
[ qtp25584663-14] DefaultErrorHandler DEBUG Échec de la livraison pour exchangeId: ID-ubuntu-46528-1303140195358-0-1. Sur la tentative de livraison: 0 capturés: javax.net.le protocole ssl.SSLPeerUnverifiedException: peer pas authentifié 
[ qtp25584663-14] DefaultErrorHandler ERREUR: Échec de livraison pour exchangeId: ID-ubuntu-46528-1303140195358-0-1. Épuisé après tentative de livraison: 1 prise: javax.net.le protocole ssl.SSLPeerUnverifiedException: peer pas authentifié 
javax.net.le protocole ssl.SSLPeerUnverifiedException: peer pas authentifié 
au com.soleil.net.le protocole ssl.interne.le protocole ssl.SSLSessionImpl.getPeerCertificates(SSLSessionImpl.java:352) 
au org.apache.http.conn.le protocole ssl.AbstractVerifier.vérifier(AbstractVerifier.java:128) 
au org.apache.http.conn.le protocole ssl.SSLSocketFactory.connectSocket(SSLSocketFactory.java:390) 
au org.apache.http.impl.conn.DefaultClientConnectionOperator.openConnection(DefaultClientConnectionOperator.java:148) 
au org.apache.http.impl.conn.AbstractPoolEntry.ouvert(AbstractPoolEntry.java:149) 
au org.apache.http.impl.conn.AbstractPooledConnAdapter.ouvert(AbstractPooledConnAdapter.java:121) 
au org.apache.http.impl.client.DefaultRequestDirector.tryConnect(DefaultRequestDirector.java:561) 
au org.apache.http.impl.client.DefaultRequestDirector.execute(DefaultRequestDirector.java:415) 
au org.apache.http.impl.client.AbstractHttpClient.execute(AbstractHttpClient.java:820) 
au org.apache.http.impl.client.AbstractHttpClient.execute(AbstractHttpClient.java:754) 
au org.apache.http.impl.client.AbstractHttpClient.execute(AbstractHttpClient.java:732) 
au org.apache.à dos de chameau.composante.http4.HttpProducer.execute(HttpProducer.java:187) 
au org.apache.à dos de chameau.composante.http4.HttpProducer.processus(HttpProducer.java:101) 
au org.apache.camel.impl.converter.AsyncProcessorTypeConverter$ProcessorToAsyncProcessorBridge.process(AsyncProcessorTypeConverter.java:50) 
au org.apache.à dos de chameau.util.AsyncProcessorHelper.processus(AsyncProcessorHelper.java:77) 
au org.apache.à dos de chameau.le processeur.SendProcessor$2.doInAsyncProducer(SendProcessor.java:104) 
au org.apache.à dos de chameau.impl.ProducerCache.doInAsyncProducer(ProducerCache.java:272) 
au org.apache.à dos de chameau.le processeur.SendProcessor.processus(SendProcessor.java:98) 
au org.apache.à dos de chameau.util.AsyncProcessorHelper.processus(AsyncProcessorHelper.java:77) 
au org.apache.à dos de chameau.le processeur.DelegateAsyncProcessor.processNext(DelegateAsyncProcessor.java:98) 
au org.apache.à dos de chameau.le processeur.DelegateAsyncProcessor.processus(DelegateAsyncProcessor.java:89) 
au org.apache.à dos de chameau.le processeur.l'intercepteur.TraceInterceptor.processus(TraceInterceptor.java:99) 
au org.apache.à dos de chameau.util.AsyncProcessorHelper.processus(AsyncProcessorHelper.java:77) 
au org.apache.camel.processor.RedeliveryErrorHandler.processErrorHandler(RedeliveryErrorHandler.java:299) 
au org.apache.à dos de chameau.le processeur.RedeliveryErrorHandler.processus(RedeliveryErrorHandler.java:208) 
au org.apache.à dos de chameau.le processeur.DefaultChannel.processus(DefaultChannel.java:269) 
au org.apache.à dos de chameau.le processeur.UnitOfWorkProcessor.processus(UnitOfWorkProcessor.java:109) 
au org.apache.à dos de chameau.util.AsyncProcessorHelper.processus(AsyncProcessorHelper.java:77) 
au org.apache.à dos de chameau.le processeur.DelegateAsyncProcessor.processNext(DelegateAsyncProcessor.java:98) 
au org.apache.à dos de chameau.le processeur.DelegateAsyncProcessor.processus(DelegateAsyncProcessor.java:89) 
au org.apache.à dos de chameau.de la gestion.InstrumentationProcessor.processus(InstrumentationProcessor.java:68) 
au org.apache.à dos de chameau.composante.la jetée.CamelContinuationServlet.service(CamelContinuationServlet.java:109) 
au javax.servlet.http.HttpServlet.service(HttpServlet.java:820) 
au org.eclipse.la jetée.servlet.ServletHolder.la poignée(ServletHolder.java:534) 
au org.eclipse.la jetée.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1351) 
au org.eclipse.la jetée.les servlets.MultiPartFilter.doFilter(MultiPartFilter.java:97) 
au org.apache.à dos de chameau.composante.la jetée.CamelMultipartFilter.doFilter(CamelMultipartFilter.java:41) 
au org.eclipse.la jetée.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1322) 
au org.eclipse.la jetée.servlet.ServletHandler.doHandle(ServletHandler.java:473) 
au org.eclipse.la jetée.serveur.gestionnaire d'.ContextHandler.doHandle(ContextHandler.java:929) 
au org.eclipse.la jetée.servlet.ServletHandler.doScope(ServletHandler.java:403) 
au org.eclipse.la jetée.serveur.gestionnaire d'.ContextHandler.doScope(ContextHandler.java:864) 
au org.eclipse.la jetée.serveur.gestionnaire d'.ScopedHandler.la poignée(ScopedHandler.java:117) 
au org.eclipse.la jetée.serveur.gestionnaire d'.HandlerWrapper.la poignée(HandlerWrapper.java:114) 
au org.eclipse.la jetée.serveur.Serveur.la poignée(Serveur de.java:352) 
au org.eclipse.la jetée.serveur.HttpConnection.handleRequest(HttpConnection.java:596) 
au org.eclipse.la jetée.serveur.HttpConnection$RequestHandler.contenu(HttpConnection.java:1068) 
au org.eclipse.la jetée.http.HttpParser.parseNext(HttpParser.java:805) 
au org.eclipse.la jetée.http.HttpParser.parseAvailable(HttpParser.java:218) 
au org.eclipse.la jetée.serveur.HttpConnection.la poignée(HttpConnection.java:426) 
au org.eclipse.la jetée.io.nio.SelectChannelEndPoint.la poignée(SelectChannelEndPoint.java:508) 
au org.eclipse.la jetée.io.nio.SelectChannelEndPoint.l'accès$000(SelectChannelEndPoint.java:34) 
au org.eclipse.la jetée.io.nio.SelectChannelEndPoint$1.exécuter(SelectChannelEndPoint.java:40) 
au org.eclipse.la jetée.util.fil de discussion.QueuedThreadPool$2.exécuter(QueuedThreadPool.java:451) 
à java.lang.Fil de discussion.exécution(Thread.java:662)

OriginalL'auteur Brian | 2011-04-18

Ok de travail maintenant, comme il s'avère, j'ai eu une incompréhension fondamentale des systèmes d'extrémité et des protocoles au sein de Chameau. J'aurais été de l'enregistrement d'un schéma de la https4 protocole et de la configuration de mon SSLSocketFactory/SSLContext sur elle. Depuis qu'il a Été l'enregistrement d'un schéma de https, il n'a jamais été utiliser par les Http4 composant.

Voici ma solution de travail avec 2 mises en garde.

Pourquoi je ne peux pas passer une SchemeRegistry à la ThreadSafeClientConnManager et il n'est pas utilisé lors de la construction de la HttpClient? J'ai de la HttpClientConfigurer au lieu
Jetty a un problème où le fichier de clés et Truststore doivent être établies par le chemin sur la SslSelectChannelConnector au lieu de via SSLContext (bug est dans au moins jetty 7.2.2 et 7.4.0 ->dernier)

Code:

public class CamelProxy {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
CamelContext context = new DefaultCamelContext();
final Endpoint jettyEndpoint = configureJetty(context);
final Endpoint https4Endpoint = configureHttpClient(context);
context.addRoutes(new RouteBuilder() {
@Override
public void configure() {
from(jettyEndpoint).to("log:com.smithforge.request?showAll=true").to(https4Endpoint);
}
});
context.start();
context.stop();
}
private static Endpoint configureHttpClient(CamelContext context) throws Exception {
KeyStore keystore = KeyStore.getInstance("PKCS12");
keystore.load(new FileInputStream(new File("/home/brian/User2.p12")), "Password1234!".toCharArray());
KeyStore truststore = KeyStore.getInstance("JKS");
truststore.load(new FileInputStream(new File("/home/brian/jboss.truststore")), "changeit".toCharArray());
KeyManagerFactory keyFactory = KeyManagerFactory.getInstance("SunX509");
keyFactory.init(keystore, "Password1234!".toCharArray());
TrustManagerFactory trustFactory = TrustManagerFactory.getInstance("SunX509");
trustFactory.init(truststore);
SSLContext sslcontext = SSLContext.getInstance("TLSv1");
sslcontext.init(keyFactory.getKeyManagers(), trustFactory.getTrustManagers(), null);
SSLSocketFactory factory = new SSLSocketFactory(sslcontext, SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
SchemeRegistry registry = new SchemeRegistry();
final Scheme scheme = new Scheme("https4", 443, factory);
registry.register(scheme);
HttpComponent http4 = context.getComponent("http4", HttpComponent.class);
http4.setHttpClientConfigurer(new HttpClientConfigurer() {
@Override
public void configureHttpClient(HttpClient client) {
client.getConnectionManager().getSchemeRegistry().register(scheme);
}
});
http4.setClientConnectionManager(new ThreadSafeClientConnManager());
return http4
.createEndpoint("https4://soafa-lite-staging:443/axis2/services/SigActService?bridgeEndpoint=true&throwExceptionOnFailure=false");
}
private static Endpoint configureJetty(CamelContext context) throws Exception {
JettyHttpComponent jetty = context.getComponent("jetty", JettyHttpComponent.class);
SslSelectChannelConnector sslConnector = new SslSelectChannelConnector();
sslConnector.setPort(4443);
sslConnector.setKeystore("/home/brian/jboss.keystore");
sslConnector.setKeyPassword("changeit");
sslConnector.setTruststore("/home/brian/jboss.truststore");
sslConnector.setTrustPassword("changeit");
sslConnector.setPassword("changeit");
sslConnector.setNeedClientAuth(true);
sslConnector.setAllowRenegotiate(true);
Map<Integer, SslSelectChannelConnector> connectors = new HashMap<Integer, SslSelectChannelConnector>();
connectors.put(4443, sslConnector);
jetty.setSslSocketConnectors(connectors);
return jetty.createEndpoint("jetty:https://localhost:4443/service");
}
//.to("log:com.smithforge.response?showHeaders=true");
}

Réponse à la mise en garde 1. Chameau toujours registres nouvelle https et https4 systèmes à la SchemeRegistry de la ThreadSafeClientConnManager après son ajout à la HttpComponent qui est mauvais, il convient de respecter les régimes qui sont déjà là. C'est pourquoi le ClientConfigurer est nécessaire de modifier la SchemeRegistry après la registerPort() la méthode de HttpComponent est fait de vissage avec elle
SchemeRegistry ,le régime sont des méthodes obsolètes maintenant, pouvez-vous me faire une base de code sans ces méthodes obsolètes.

OriginalL'auteur Brian

J'ai eu à travailler un proxy ssl avec le code suivant

La route

public class MyRouteBuilder extends RouteBuilder {
public void configure() {
configureSslForJetty();
configureSslForHttp4();
from("jetty:https://0.0.0.0:4443/topython/?matchOnUriPrefix=true")
.to("https4://backend.fake.com:4444/?q=ssl&bridgeEndpoint=true&throwExceptionOnFailure=false");
}
...

Configuration de la jetée (fournir un certificat lorsque nous agissons en tant que serveur)

private void configureSslForJetty()
{
KeyStoreParameters ksp = new KeyStoreParameters();
ksp.setResource("c:\\Projects\\blah\\fakefilter.jks");
ksp.setPassword("123456");
KeyManagersParameters kmp = new KeyManagersParameters();
kmp.setKeyStore(ksp);
kmp.setKeyPassword("export-password");
SSLContextParameters scp = new SSLContextParameters();
scp.setKeyManagers(kmp);
JettyHttpComponent jettyComponent = getContext().getComponent("jetty", JettyHttpComponent.class);
jettyComponent.setSslContextParameters(scp);
}

De Configuration pour https4 (ce certificat signataires faisons-nous confiance quand ils agissent en tant que client)

private void configureSslForHttp4()
{
KeyStoreParameters trust_ksp = new KeyStoreParameters();
trust_ksp.setResource("c:\\Projects\\blah\\fakeca.jks");
trust_ksp.setPassword("123456");
TrustManagersParameters trustp = new TrustManagersParameters();
trustp.setKeyStore(trust_ksp);
SSLContextParameters scp = new SSLContextParameters();
scp.setTrustManagers(trustp);
HttpComponent httpComponent = getContext().getComponent("https4", HttpComponent.class);
httpComponent.setSslContextParameters(scp);
}

}

Choses intéressant de noter

vous avez besoin pour configurer le composant https4 pas http4
-Djavax.net.debug=ssl dans la ligne de commande fourni beaucoup de journalisation

OriginalL'auteur xverges

0

Dirait que vous rencontrez des problèmes avec 'dangereux renégociation ssl'. Veuillez vérifier que vous utilisez la dernière version de JDK/JRE (au moins 1.6.0_24).

Je suis sur le dernier plus grand JRE/JDK
Le client est configuré pour envoyer un certificat? Pourriez-vous commenter la sslConnector.setNeedClientAuth(vrai) en ligne et de voir si tout fonctionne correctement?
J'ai obtenu une réponse partielle, toujours de débogage, mais je ressemble à apache camel n'est pas à l'aide de la SSLContext qui a été fourni à la Http4 composant. J'ai débogué autant que le org.apache.http.conn.le protocole ssl.SSLSocketFactory et je peux voir la KeyManager est vide et le TrustManager contient les certificats de java fichier cacerts, PAS mon truststore que je fournis avec le SSLContext. N'utilisant pas de Chameau, j'ai eu à travailler avec un autonome incorporé jetée à l'aide de clientAuth et un HttpClient, donc je savais que c'était quelque chose de mauvais que le Chameau était en train de faire lorsqu'il configuré ces composants pour moi.
Il ressemble à apache camel n'est pas à l'aide de la SSLContext qui a été fourni à la Http4 composant je pense que vous avez pour obtenir le composant https4 en context.getComponent("https4",HttpComponent.class);, pas http4 (comme je l'ai fait pour plusieurs inutile d'heures...)

OriginalL'auteur hooknc

Vous devez vous connecter pour publier un commentaire.