You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by "orpiske (via GitHub)" <gi...@apache.org> on 2023/04/26 11:37:25 UTC
[GitHub] [camel] orpiske commented on a diff in pull request #9939: CAMEL-17946 Introducing HTTPS support for AS2 component
orpiske commented on code in PR #9939:
URL: https://github.com/apache/camel/pull/9939#discussion_r1177740111
##########
components/camel-as2/camel-as2-component/src/test/resources/mendelson/key4.cer:
##########
@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
Review Comment:
This file should be provided via parameters instead of being kept in the code base (i.e.: `mvn -Das2.http.key=/path/to/key`).
##########
components/camel-as2/camel-as2-component/src/test/java/org/apache/camel/component/as2/MendelsonSslEndpointIT.java:
##########
@@ -0,0 +1,132 @@
+package org.apache.camel.component.as2;
+
+import java.nio.charset.Charset;
+
+import javax.net.ssl.HostnameVerifier;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.Exchange;
+import org.apache.camel.component.as2.api.AS2EncryptionAlgorithm;
+import org.apache.camel.component.as2.api.AS2MessageStructure;
+import org.apache.camel.component.as2.api.AS2SignatureAlgorithm;
+import org.apache.camel.component.as2.internal.AS2ApiName;
+import org.apache.camel.impl.DefaultCamelContext;
+import org.apache.http.conn.ssl.NoopHostnameVerifier;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Test class for testing connection to a public 3rd party AS2 server Mendelson. This class gives more info for
+ * camel-as2 connectivity to a remote server compared to HTTPS connection to localhost server. Eventually test method(s)
+ * will be committed with @Disabled annotation due to they can fail because the mendelson server goes offline or the
+ * certificate expires. I assume we don't want a build to fail because of such 3rd party connectivity dependency.
+ * Mendelson page: http://mendelson-e-c.com/as2_testserver
+ */
+public class MendelsonSslEndpointIT extends AbstractAS2ITSupport {
+
+ private static final Logger LOG = LoggerFactory.getLogger(MendelsonSslEndpointIT.class);
+ private MendelsonCertLoader mendelsonCertLoader;
+ private static HostnameVerifier hostnameVerifier;
+
+ private static final String[] SIGNED_RECEIPT_MIC_ALGORITHMS = new String[] { "sha1", "md5" };
+
+ private static final String EDI_MESSAGE = "UNB+UNOA:1+005435656:1+006415160:1+060515:1434+00000000000778'\n"
+ + "UNH+00000000000117+INVOIC:D:97B:UN'\n"
+ + "BGM+380+342459+9'\n"
+ + "DTM+3:20060515:102'\n"
+ + "RFF+ON:521052'\n"
+ + "NAD+BY+792820524::16++CUMMINS MID-RANGE ENGINE PLANT'\n"
+ + "NAD+SE+005435656::16++GENERAL WIDGET COMPANY'\n"
+ + "CUX+1:USD'\n"
+ + "LIN+1++157870:IN'\n"
+ + "IMD+F++:::WIDGET'\n"
+ + "QTY+47:1020:EA'\n"
+ + "ALI+US'\n"
+ + "MOA+203:1202.58'\n"
+ + "PRI+INV:1.179'\n"
+ + "LIN+2++157871:IN'\n"
+ + "IMD+F++:::Message from Camel AS2 via HTTPS'\n"
+ + "QTY+47:20:EA'\n"
+ + "ALI+JP'\n"
+ + "MOA+203:410'\n"
+ + "PRI+INV:20.5'\n"
+ + "UNS+S'\n"
+ + "MOA+39:2137.58'\n"
+ + "ALC+C+ABG'\n"
+ + "MOA+8:525'\n"
+ + "UNT+23+00000000000117'\n"
+ + "UNZ+1+00000000000778'\n";
+
+ @BeforeAll
+ public void setupTest() {
+ hostnameVerifier = new NoopHostnameVerifier();
+ mendelsonCertLoader = new MendelsonCertLoader();
+ mendelsonCertLoader.setupCertificateChain();
+ mendelsonCertLoader.setupSslContext();
+ }
+
+ @Disabled
+ @Test
+ public void testCreateEndpointAndSendViaHTTPS() throws Exception {
+ CamelContext camelContext = new DefaultCamelContext();
+ camelContext.start();
+
+ org.apache.http.entity.ContentType contentTypeEdifact
+ = org.apache.http.entity.ContentType.create("application/edifact", (Charset) null);
+
+ String methodName = "send";
+ AS2ApiName as2ApiNameClient = AS2ApiName.CLIENT;
+
+ AS2Configuration endpointConfiguration = new AS2Configuration();
+ endpointConfiguration.setApiName(as2ApiNameClient);
+ endpointConfiguration.setMethodName(methodName);
+ endpointConfiguration.setRequestUri("/as2/HttpReceiver");
+ endpointConfiguration.setSignedReceiptMicAlgorithms(SIGNED_RECEIPT_MIC_ALGORITHMS);
+
+ endpointConfiguration.setAs2MessageStructure(AS2MessageStructure.SIGNED_ENCRYPTED);
+ endpointConfiguration.setSigningAlgorithm(AS2SignatureAlgorithm.SHA3_256WITHRSA);
+ endpointConfiguration.setEncryptingAlgorithm(AS2EncryptionAlgorithm.DES_EDE3_CBC);
+ endpointConfiguration.setSigningCertificateChain(mendelsonCertLoader.getChain());
+ endpointConfiguration.setSigningPrivateKey(mendelsonCertLoader.getPrivateKey());
+ endpointConfiguration.setEncryptingCertificateChain(mendelsonCertLoader.getChain());
+
+ endpointConfiguration.setAs2Version("1.0");
+ endpointConfiguration.setAs2To("mendelsontestAS2");
+ endpointConfiguration.setAs2From("mycompanyAS2");
+ endpointConfiguration.setEdiMessageType(contentTypeEdifact);
+ endpointConfiguration.setFrom("dk2kEdi");
+ endpointConfiguration.setSubject("mysubject");
+ endpointConfiguration.setSigningAlgorithm(AS2SignatureAlgorithm.MD2WITHRSA);
+ endpointConfiguration.setEdiMessageTransferEncoding("7bit");
+ endpointConfiguration.setAttachedFileName("from_camel.txt");
+
+ endpointConfiguration.setSslContext(mendelsonCertLoader.getSslContext());
+ endpointConfiguration.setHostnameVerifier(hostnameVerifier);
+
+ AS2Component as2Component = new AS2Component();
+ as2Component.setCamelContext(camelContext);
+ as2Component.setConfiguration(endpointConfiguration);
+ as2Component.start();
+
+ AS2Endpoint endpoint = (AS2Endpoint) as2Component
+ .createEndpoint("as2://client/send?targetHostName=testas2.mendelson-e-c.com"
+ + "&targetPortNumber=8444&inBody=ediMessage&requestUri=/as2/HttpReceiver" +
+ "&ediMessageContentType=application/edifact" +
+ "&signingAlgorithm=SHA3_256WITHRSA");
+
+ Assertions.assertEquals("mycompanyAS2", endpoint.getAs2From());
+ Assertions.assertEquals("mendelsontestAS2", endpoint.getAs2To());
+ Assertions.assertEquals("dk2kEdi", endpoint.getFrom());
Review Comment:
These values taken for the assertion expectations should be configurable so that they are not bound to this specific AS2 instance.
##########
components/camel-as2/camel-as2-component/src/test/java/org/apache/camel/component/as2/MendelsonCertLoader.java:
##########
@@ -0,0 +1,183 @@
+package org.apache.camel.component.as2;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.security.KeyManagementException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.security.UnrecoverableKeyException;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
+import java.security.spec.InvalidKeySpecException;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+
+import javax.net.ssl.SSLContext;
+
+import org.apache.commons.io.IOUtils;
+import org.apache.http.conn.ssl.TrustAllStrategy;
+import org.apache.http.ssl.SSLContexts;
+
+/**
+ * That's a utility class for preparing Mendelson-specific certificate chain, private key, ssl context
+ */
+public class MendelsonCertLoader {
+
+ private static final String MENDELSON_CERT = "mendelson/key4.cer";
+ private static final String MENDELSON_PRIVATE_KEY = "mendelson/key3.pfx";
+
+ private final List<Certificate> chainAsList = new ArrayList<>();
+
+ private PrivateKey privateKey;
+ private SSLContext sslContext;
+
+ public void setupSslContext() {
+ try {
+ InputStream mendelsonPrivateKeyAsStream = getClass().getClassLoader().getResourceAsStream(MENDELSON_PRIVATE_KEY);
+ KeyStore keyStore = getKeyStore(mendelsonPrivateKeyAsStream);
+ sslContext = SSLContexts.custom().setKeyStoreType("PKCS12")
+ .loadTrustMaterial(keyStore, new TrustAllStrategy())
+ .build();
+ } catch (KeyStoreException e) {
+ e.printStackTrace();
+ } catch (KeyManagementException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ } catch (NoSuchAlgorithmException e) {
+ e.printStackTrace();
+ }
+
+ if (sslContext == null) {
+ throw new IllegalStateException("failed to configure SSL context");
+ }
+ }
+
+ private KeyStore getKeyStore(InputStream inputStream) throws IOException, NoSuchAlgorithmException {
+ String password = "test";
+ KeyStore ks;
+ try {
+ ks = KeyStore.getInstance("PKCS12");
+ ks.load(inputStream, password.toCharArray());
+ return ks;
+ } catch (KeyStoreException e) {
+ e.printStackTrace();
+ } catch (CertificateException e) {
+ e.printStackTrace();
+ }
+ throw new IllegalStateException("about to return null");
+ }
+
+ public void setupCertificateChain() {
+
+ InputStream mendelsonCertAsStream = getClass().getClassLoader().getResourceAsStream(MENDELSON_CERT);
+ if (mendelsonCertAsStream == null) {
+ //LOG.error("Couldn't read out client certificate as stream.");
+ throw new IllegalStateException("Couldn't read out certificate as stream.");
+ }
+
+ InputStream mendelsonPrivateKeyAsStream = getClass().getClassLoader().getResourceAsStream(MENDELSON_PRIVATE_KEY);
+ if (mendelsonPrivateKeyAsStream == null) {
+ //LOG.error("Couldn't read out private key as stream.");
+ throw new IllegalStateException("Couldn't read out key storage as stream.");
+ }
+
+ try {
+ Certificate mendelsonCert = getCertificateFromStream(mendelsonCertAsStream);
+ chainAsList.add(mendelsonCert);
+
+ //private key
+ privateKey = getPrivateKeyFromPKCSStream(mendelsonPrivateKeyAsStream);
+
+ } catch (IOException e) {
+ String errMsg = "Error while trying to load certificate to the keyload. IO error when reading a byte array. " + e;
+ System.out.println(errMsg);
+ } catch (NoSuchAlgorithmException e) {
+ String errMsg = "Error while trying to load certificate to the keyload. Requested algorithm isn't found. " + e;
+ System.out.println(errMsg);
+ } catch (CertificateException e) {
+ String errMsg = "Error while trying to load certificate to the keyload. There is a certificate problem. " + e;
+ System.out.println(errMsg);
+ } catch (InvalidKeySpecException e) {
+ String errMsg = "Can not init private key store " + e;
+ System.out.println(errMsg);
+ }
+ }
+
+ public SSLContext getSslContext() {
+ return sslContext;
+ }
+
+ public Certificate[] getChain() {
+ if (chainAsList.size() > 0) {
+ Certificate[] arrayCert = new Certificate[chainAsList.size()];
+
+ for (int i = 0; i < chainAsList.size(); i++) {
+ arrayCert[i] = chainAsList.get(i);
+ }
+ return arrayCert;
+ } else {
+ return null;
+ }
+ }
+
+ public PrivateKey getPrivateKey() {
+ return privateKey;
+ }
+
+ private List<Certificate> getCertificatesFromStream(InputStream inputStream) throws IOException, CertificateException {
+ CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
+ return (List<Certificate>) certificateFactory.generateCertificates(inputStream);
+ }
+
+ private Certificate getCertificateFromStream(InputStream inputStream) throws IOException, CertificateException {
+ CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
+ return certificateFactory.generateCertificate(inputStream);
+ }
+
+ //https://stackoverflow.com/questions/18644286/creating-privatekey-object-from-pkcs12
+ private PrivateKey getPrivateKeyFromPKCSStream(InputStream inputStream)
+ throws IOException, NoSuchAlgorithmException, InvalidKeySpecException {
+ String password = "test";
+ KeyStore ks = null;
+ try {
+ ks = KeyStore.getInstance("PKCS12");
+ } catch (KeyStoreException e) {
+ e.printStackTrace();
+ }
+ try {
+ ks.load(inputStream, password.toCharArray());
+ } catch (CertificateException e) {
+ e.printStackTrace();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ try {
+ return (PrivateKey) ks.getKey(
+ ks.aliases().nextElement(),
+ password.toCharArray());
+ } catch (KeyStoreException e) {
+ e.printStackTrace();
+ } catch (UnrecoverableKeyException e) {
+ e.printStackTrace();
+ }
Review Comment:
I believe all these exceptions being caught in this block should be logged.
##########
components/camel-as2/camel-as2-component/src/test/java/org/apache/camel/component/as2/MendelsonCertLoader.java:
##########
@@ -0,0 +1,183 @@
+package org.apache.camel.component.as2;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.security.KeyManagementException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.security.UnrecoverableKeyException;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
+import java.security.spec.InvalidKeySpecException;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+
+import javax.net.ssl.SSLContext;
+
+import org.apache.commons.io.IOUtils;
+import org.apache.http.conn.ssl.TrustAllStrategy;
+import org.apache.http.ssl.SSLContexts;
+
+/**
+ * That's a utility class for preparing Mendelson-specific certificate chain, private key, ssl context
+ */
+public class MendelsonCertLoader {
+
+ private static final String MENDELSON_CERT = "mendelson/key4.cer";
+ private static final String MENDELSON_PRIVATE_KEY = "mendelson/key3.pfx";
+
+ private final List<Certificate> chainAsList = new ArrayList<>();
+
+ private PrivateKey privateKey;
+ private SSLContext sslContext;
+
+ public void setupSslContext() {
+ try {
+ InputStream mendelsonPrivateKeyAsStream = getClass().getClassLoader().getResourceAsStream(MENDELSON_PRIVATE_KEY);
+ KeyStore keyStore = getKeyStore(mendelsonPrivateKeyAsStream);
+ sslContext = SSLContexts.custom().setKeyStoreType("PKCS12")
+ .loadTrustMaterial(keyStore, new TrustAllStrategy())
+ .build();
+ } catch (KeyStoreException e) {
+ e.printStackTrace();
+ } catch (KeyManagementException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ } catch (NoSuchAlgorithmException e) {
+ e.printStackTrace();
+ }
+
+ if (sslContext == null) {
+ throw new IllegalStateException("failed to configure SSL context");
+ }
+ }
+
+ private KeyStore getKeyStore(InputStream inputStream) throws IOException, NoSuchAlgorithmException {
+ String password = "test";
+ KeyStore ks;
+ try {
+ ks = KeyStore.getInstance("PKCS12");
+ ks.load(inputStream, password.toCharArray());
+ return ks;
+ } catch (KeyStoreException e) {
+ e.printStackTrace();
+ } catch (CertificateException e) {
+ e.printStackTrace();
+ }
+ throw new IllegalStateException("about to return null");
+ }
+
+ public void setupCertificateChain() {
+
+ InputStream mendelsonCertAsStream = getClass().getClassLoader().getResourceAsStream(MENDELSON_CERT);
+ if (mendelsonCertAsStream == null) {
+ //LOG.error("Couldn't read out client certificate as stream.");
+ throw new IllegalStateException("Couldn't read out certificate as stream.");
+ }
+
+ InputStream mendelsonPrivateKeyAsStream = getClass().getClassLoader().getResourceAsStream(MENDELSON_PRIVATE_KEY);
+ if (mendelsonPrivateKeyAsStream == null) {
+ //LOG.error("Couldn't read out private key as stream.");
+ throw new IllegalStateException("Couldn't read out key storage as stream.");
+ }
+
+ try {
+ Certificate mendelsonCert = getCertificateFromStream(mendelsonCertAsStream);
+ chainAsList.add(mendelsonCert);
+
+ //private key
+ privateKey = getPrivateKeyFromPKCSStream(mendelsonPrivateKeyAsStream);
+
+ } catch (IOException e) {
+ String errMsg = "Error while trying to load certificate to the keyload. IO error when reading a byte array. " + e;
+ System.out.println(errMsg);
+ } catch (NoSuchAlgorithmException e) {
+ String errMsg = "Error while trying to load certificate to the keyload. Requested algorithm isn't found. " + e;
+ System.out.println(errMsg);
+ } catch (CertificateException e) {
+ String errMsg = "Error while trying to load certificate to the keyload. There is a certificate problem. " + e;
+ System.out.println(errMsg);
+ } catch (InvalidKeySpecException e) {
+ String errMsg = "Can not init private key store " + e;
+ System.out.println(errMsg);
+ }
Review Comment:
I believe all the messages being sent to the `stdout` here should be handled by a logger.
##########
components/camel-as2/camel-as2-component/src/test/java/org/apache/camel/component/as2/MendelsonCertLoader.java:
##########
@@ -0,0 +1,183 @@
+package org.apache.camel.component.as2;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.security.KeyManagementException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.security.UnrecoverableKeyException;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
+import java.security.spec.InvalidKeySpecException;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+
+import javax.net.ssl.SSLContext;
+
+import org.apache.commons.io.IOUtils;
+import org.apache.http.conn.ssl.TrustAllStrategy;
+import org.apache.http.ssl.SSLContexts;
+
+/**
+ * That's a utility class for preparing Mendelson-specific certificate chain, private key, ssl context
+ */
+public class MendelsonCertLoader {
+
+ private static final String MENDELSON_CERT = "mendelson/key4.cer";
+ private static final String MENDELSON_PRIVATE_KEY = "mendelson/key3.pfx";
+
+ private final List<Certificate> chainAsList = new ArrayList<>();
+
+ private PrivateKey privateKey;
+ private SSLContext sslContext;
+
+ public void setupSslContext() {
+ try {
+ InputStream mendelsonPrivateKeyAsStream = getClass().getClassLoader().getResourceAsStream(MENDELSON_PRIVATE_KEY);
+ KeyStore keyStore = getKeyStore(mendelsonPrivateKeyAsStream);
+ sslContext = SSLContexts.custom().setKeyStoreType("PKCS12")
+ .loadTrustMaterial(keyStore, new TrustAllStrategy())
+ .build();
+ } catch (KeyStoreException e) {
+ e.printStackTrace();
+ } catch (KeyManagementException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ } catch (NoSuchAlgorithmException e) {
+ e.printStackTrace();
+ }
+
+ if (sslContext == null) {
+ throw new IllegalStateException("failed to configure SSL context");
+ }
+ }
+
+ private KeyStore getKeyStore(InputStream inputStream) throws IOException, NoSuchAlgorithmException {
+ String password = "test";
+ KeyStore ks;
+ try {
+ ks = KeyStore.getInstance("PKCS12");
+ ks.load(inputStream, password.toCharArray());
+ return ks;
+ } catch (KeyStoreException e) {
+ e.printStackTrace();
+ } catch (CertificateException e) {
+ e.printStackTrace();
+ }
+ throw new IllegalStateException("about to return null");
+ }
+
+ public void setupCertificateChain() {
+
+ InputStream mendelsonCertAsStream = getClass().getClassLoader().getResourceAsStream(MENDELSON_CERT);
+ if (mendelsonCertAsStream == null) {
+ //LOG.error("Couldn't read out client certificate as stream.");
+ throw new IllegalStateException("Couldn't read out certificate as stream.");
+ }
+
+ InputStream mendelsonPrivateKeyAsStream = getClass().getClassLoader().getResourceAsStream(MENDELSON_PRIVATE_KEY);
+ if (mendelsonPrivateKeyAsStream == null) {
+ //LOG.error("Couldn't read out private key as stream.");
+ throw new IllegalStateException("Couldn't read out key storage as stream.");
+ }
+
+ try {
+ Certificate mendelsonCert = getCertificateFromStream(mendelsonCertAsStream);
+ chainAsList.add(mendelsonCert);
+
+ //private key
+ privateKey = getPrivateKeyFromPKCSStream(mendelsonPrivateKeyAsStream);
+
+ } catch (IOException e) {
+ String errMsg = "Error while trying to load certificate to the keyload. IO error when reading a byte array. " + e;
+ System.out.println(errMsg);
+ } catch (NoSuchAlgorithmException e) {
+ String errMsg = "Error while trying to load certificate to the keyload. Requested algorithm isn't found. " + e;
+ System.out.println(errMsg);
+ } catch (CertificateException e) {
+ String errMsg = "Error while trying to load certificate to the keyload. There is a certificate problem. " + e;
+ System.out.println(errMsg);
+ } catch (InvalidKeySpecException e) {
+ String errMsg = "Can not init private key store " + e;
+ System.out.println(errMsg);
+ }
+ }
+
+ public SSLContext getSslContext() {
+ return sslContext;
+ }
+
+ public Certificate[] getChain() {
+ if (chainAsList.size() > 0) {
+ Certificate[] arrayCert = new Certificate[chainAsList.size()];
+
+ for (int i = 0; i < chainAsList.size(); i++) {
+ arrayCert[i] = chainAsList.get(i);
+ }
+ return arrayCert;
+ } else {
+ return null;
+ }
+ }
+
+ public PrivateKey getPrivateKey() {
+ return privateKey;
+ }
+
+ private List<Certificate> getCertificatesFromStream(InputStream inputStream) throws IOException, CertificateException {
+ CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
+ return (List<Certificate>) certificateFactory.generateCertificates(inputStream);
+ }
+
+ private Certificate getCertificateFromStream(InputStream inputStream) throws IOException, CertificateException {
+ CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
+ return certificateFactory.generateCertificate(inputStream);
+ }
+
+ //https://stackoverflow.com/questions/18644286/creating-privatekey-object-from-pkcs12
+ private PrivateKey getPrivateKeyFromPKCSStream(InputStream inputStream)
+ throws IOException, NoSuchAlgorithmException, InvalidKeySpecException {
+ String password = "test";
+ KeyStore ks = null;
+ try {
+ ks = KeyStore.getInstance("PKCS12");
+ } catch (KeyStoreException e) {
+ e.printStackTrace();
+ }
+ try {
+ ks.load(inputStream, password.toCharArray());
+ } catch (CertificateException e) {
+ e.printStackTrace();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ try {
+ return (PrivateKey) ks.getKey(
+ ks.aliases().nextElement(),
+ password.toCharArray());
+ } catch (KeyStoreException e) {
+ e.printStackTrace();
+ } catch (UnrecoverableKeyException e) {
+ e.printStackTrace();
+ }
+ throw new IllegalStateException("about to return null");
Review Comment:
Maybe provide a better error message here.
##########
components/camel-as2/camel-as2-component/src/test/java/org/apache/camel/component/as2/MendelsonCertLoader.java:
##########
@@ -0,0 +1,183 @@
+package org.apache.camel.component.as2;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.security.KeyManagementException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.security.UnrecoverableKeyException;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
+import java.security.spec.InvalidKeySpecException;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+
+import javax.net.ssl.SSLContext;
+
+import org.apache.commons.io.IOUtils;
+import org.apache.http.conn.ssl.TrustAllStrategy;
+import org.apache.http.ssl.SSLContexts;
+
+/**
+ * That's a utility class for preparing Mendelson-specific certificate chain, private key, ssl context
+ */
+public class MendelsonCertLoader {
Review Comment:
I am not entirely sure we want this file as it is. This is tied to an specific instance of a service. Instead, I think it would be better to make it generic and configurable, so that anyone willing to test with a different instance could do so.
##########
components/camel-as2/camel-as2-component/pom.xml:
##########
@@ -64,6 +64,12 @@
<artifactId>camel-jetty</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>commons-io</groupId>
+ <artifactId>commons-io</artifactId>
+ <version>2.10.0</version>
+ <scope>test</scope>
+ </dependency>
Review Comment:
This likely needs to be correctly aligned w/ the `commons-io` version we use.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@camel.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org