public class CycCertOptions implements KeyCertOptions, Cloneable {
private final MyKeyManager keyManager = new MyKeyManager();
private final MyKeyManagerFactory factory = new MyKeyManagerFactory(keyManager);
public CycCertOptions() {
super();
//loadKeyStore();
}
public CycCertOptions(CycCertOptions other) {
super();
//loadKeyStore();
}
public void loadKeyStore() {
try {
keyManager.load();
} catch(UnrecoverableKeyException | KeyStoreException e) {
}
}
@Override
public KeyManagerFactory getKeyManagerFactory(Vertx vertx) throws Exception {
//return factory;
return keyManager.getKeyManagerFactory();
}
@Override
public CycCertOptions clone() {
return new CycCertOptions(this);
}
static class MyKeyManager extends X509ExtendedKeyManager {
KeystoreManager ksMgr = null;
private volatile X509ExtendedKeyManager wrapped;
KeyManagerFactory keyManagerFactory = null;
public MyKeyManager() {
try {
ksMgr = new KeystoreManager();
keyManagerFactory =
KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
keyManagerFactory.init(ksMgr.getKeyStore(), ksMgr.getKeystorePassword());
wrapped = (X509ExtendedKeyManager) keyManagerFactory.getKeyManagers()[0];
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public void load() throws UnrecoverableKeyException, KeyStoreException {
try {
keyManagerFactory =
KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
keyManagerFactory.init(ksMgr.getKeyStore(), ksMgr.getKeystorePassword());
wrapped = (X509ExtendedKeyManager) keyManagerFactory.getKeyManagers()[0];
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException(e);
}
}
public KeyManagerFactory getKeyManagerFactory() {
return keyManagerFactory;
}
@Override
public String chooseEngineServerAlias(String s, Principal[] principals, SSLEngine engine) {
throw new UnsupportedOperationException();
}
@Override
public String[] getServerAliases(String s, Principal[] principals) {
throw new UnsupportedOperationException();
}
@Override
public X509Certificate[] getCertificateChain(String s) {
return wrapped == null ? null : wrapped.getCertificateChain(s);
}
@Override
public PrivateKey getPrivateKey(String s) {
return wrapped == null ? null : wrapped.getPrivateKey(s);
}
@Override
public String[] getClientAliases(String s, Principal[] principals) {
throw new UnsupportedOperationException();
}
@Override
public String chooseClientAlias(String[] strings, Principal[] principals, Socket socket) {
throw new UnsupportedOperationException();
}
@Override
public String chooseServerAlias(String s, Principal[] principals, Socket socket) {
throw new UnsupportedOperationException();
}
}
static class MyKeyManagerFactory extends KeyManagerFactory {
MyKeyManagerFactory(final KeyManager keyManager) {
super(new KeyManagerFactorySpi() {
@Override
protected void engineInit(KeyStore keyStore, char[] chars) throws KeyStoreException,
NoSuchAlgorithmException, UnrecoverableKeyException {
throw new UnsupportedOperationException();
}
@Override
protected void engineInit(ManagerFactoryParameters managerFactoryParameters) throws
InvalidAlgorithmParameterException {
throw new UnsupportedOperationException();
}
@Override
protected KeyManager[] engineGetKeyManagers() {
return new KeyManager[]{keyManager};
}
}, new Provider("", 0.0, "") {
}, "");
}
}
}
public class KeystoreManager {
private static final char[] KEYSTORE_PASSWORD = "abc".toCharArray();
private KeyStore mKeyStore = null;
public KeystoreManager() {
if( mKeyStore == null) {
this.mKeyStore = createStore();
}
}
public KeyStore getKeyStore() {
return mKeyStore;
}
public char[] getKeystorePassword() {
return KEYSTORE_PASSWORD;
}
public KeyStore createStore() {
try {
mKeyStore = KeyStore.getInstance(KeyStore.getDefaultType());
mKeyStore.load(null, KEYSTORE_PASSWORD);
reloadServerCertificate("/home/cyc/test_certs/certs/foo.der", "/home/cyc/test_certs/private/fooKey.der");
} catch (IOException | NoSuchAlgorithmException | CertificateException | KeyStoreException e) {
throw new RuntimeException("Unable to create empty keyStore", e);
}
return mKeyStore;
}
public void reloadServerCertificate(String certFilename, String keyFilename) {
try {
clearKeyStore();
//load key
InputStream keyInputStream = fullStream(keyFilename);
byte[] key = new byte[keyInputStream.available()];
keyInputStream.read(key, 0, keyInputStream.available());
keyInputStream.close();
//load certificate
InputStream certStream = fullStream(certFilename);
loadServerCertificate(certStream, key);
certStream.close();
} catch(Exception ex) {
System.out.println("Error while reloading the certificate :" + ex.getLocalizedMessage());
}
}
public void loadServerCertificate(InputStream certstream, byte[] keyStr) {
try {
Certificate[] certs = getCertificateChain(certstream);
PrivateKey pKey = getPrivateKey(keyStr);
mKeyStore.setKeyEntry("test", pKey, KEYSTORE_PASSWORD, certs);
} catch (Exception ex) {
System.out.println("Error while adding the server certificate!!!" + ex.getLocalizedMessage());
}
}
private Certificate[] getCertificateChain(InputStream certstream) {
Certificate[] certs = null;
try {
CertificateFactory cf = CertificateFactory.getInstance("X.509");
Collection c = cf.generateCertificates(certstream) ;
certs = new Certificate[c.toArray().length];
if (c.size() == 1) {
certstream = fullStream ("/home/cyc/test_certs/certs/foo.der");
System.out.println("One certificate, no chain.");
Certificate cert = cf.generateCertificate(certstream) ;
certs[0] = cert;
} else {
System.out.println("Certificate chain length: "+c.size());
certs = (Certificate[])c.toArray();
}
} catch (Exception ex) {
}
return certs;
}
private PrivateKey getPrivateKey(byte[] keyStr) throws Exception {
KeyFactory kf = KeyFactory.getInstance("RSA");
PKCS8EncodedKeySpec keysp = new PKCS8EncodedKeySpec( keyStr );
return kf.generatePrivate(keysp);
}
private void clearKeyStore() {
try {
for (Enumeration<String> e = mKeyStore.aliases();
e.hasMoreElements(); ) {
final String alias = e.nextElement();
mKeyStore.deleteEntry(alias);
}
} catch (KeyStoreException e) {
}
}
private static InputStream fullStream(String fname) throws IOException {
FileInputStream fis = null;
DataInputStream dis = null;
try {
fis = new FileInputStream(fname);
dis = new DataInputStream(fis);
byte[] bytes = new byte[dis.available()];
dis.readFully(bytes);
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
return bais;
} finally {
fis.close();
dis.close();
}
}
}
In the main -
Launcher.main(Stream.concat(Stream.of("run", TestMain.class.getName()), Stream.of(args)).toArray(String[]::new));
Verticle loading -
@Override
public void start() {
try {
Vertx vertx = Vertx.vertx();
HttpServerOptions serverOpts = getHttpServerOptions();
vertx.createHttpServer(serverOpts)
.requestHandler(this::handle)
.listen(listenPort);
} catch(Exception ex) {
System.out.println("Error while running - " + ex.getLocalizedMessage());
}
}
private void handle(HttpServerRequest req) {
}
private static HttpServerOptions getHttpServerOptions() {
List<String> cipherSuites = Arrays.asList(
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"
);
HttpServerOptions httpServerOptions = new HttpServerOptions()
.setReuseAddress(true)
.setUsePooledBuffers(true)
.setSsl(true)
.setKeyCertOptions(new CycCertOptions())
.addEnabledSecureTransportProtocol("TLSv1.2")
.addEnabledSecureTransportProtocol("TLSv1.3")
.setJdkSslEngineOptions(new JdkSSLEngineOptions());
cipherSuites.forEach(httpServerOptions::addEnabledCipherSuite);
return httpServerOptions;
}
static String javaCipherNameToOpenSSLName(String name) {
return name.replace("TLS_", "")
.replace("WITH_AES_", "AES")
.replace('_', '-');
}
Does this help ?.