代码之家 › 专栏 › 技术社区 › L. Cornelius Dol

如何为Java服务器提供多个SSL证书

certificate ssl java

L. Cornelius Dol · 技术社区 · 16 年前

我有一个用Java编写的内部HTTP服务器;我可以处理完整的源代码。HTTP服务器可以配置任意数量的网站,每个网站都有一个单独的侦听套接字,该套接字由以下内容创建:

skt=SSLServerSocketFactory.getDefault().createServerSocket(prt,bcklog,adr);

使用Java密钥工具创建的标准密钥存储库,我无法在我的生命中找到如何获得与不同的监听套接字相关联的不同证书,以便每个配置的Web站点都有自己的证书。

我现在正处于这方面的紧要关头,所以最欣赏的是一些演示代码示例。不过,我还是很欣赏关于JSSE如何在这方面结合在一起的任何好的概述(我已经搜索了Sun的JSSE文档,直到我的大脑受伤为止(字面意思是,尽管它可能和咖啡因戒断一样多))。

编辑

是否没有简单的方法使用别名将密钥存储区中的服务器证书与侦听套接字相关联?以便:

客户有一个密钥库来管理所有证书,以及
不需要在多家钥匙店等地方胡乱摆弄。

我(今天下午早些时候)的印象是,我只需要 chooseServerAlias(...) 返回非空,这是我想要的别名的名称-有人对这一推理有任何想法吗?

解决方案

我使用的解决方案,基于 slyvarking 其答案是创建一个临时密钥存储,并用从单一外部密钥存储中提取的所需密钥/证书填充它。以下代码适用于任何感兴趣的人(svrctfals是我的“服务器证书别名”值):

    SSLServerSocketFactory              ssf;                                    // server socket factory
    SSLServerSocket                     skt;                                    // server socket

    // LOAD EXTERNAL KEY STORE
    KeyStore mstkst;
    try {
        String   kstfil=GlobalSettings.getString("javax.net.ssl.keyStore"        ,System.getProperty("javax.net.ssl.keyStore"        ,""));
        String   ksttyp=GlobalSettings.getString("javax.net.ssl.keyStoreType"    ,System.getProperty("javax.net.ssl.keyStoreType"    ,"jks"));
        char[]   kstpwd=GlobalSettings.getString("javax.net.ssl.keyStorePassword",System.getProperty("javax.net.ssl.keyStorePassword","")).toCharArray();

        mstkst=KeyStore.getInstance(ksttyp);
        mstkst.load(new FileInputStream(kstfil),kstpwd);
        }
    catch(java.security.GeneralSecurityException thr) {
        throw new IOException("Cannot load keystore ("+thr+")");
        }

    // CREATE EPHEMERAL KEYSTORE FOR THIS SOCKET USING DESIRED CERTIFICATE
    try {
        SSLContext        ctx=SSLContext.getInstance("TLS");
        KeyManagerFactory kmf=KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        KeyStore          sktkst;
        char[]            blkpwd=new char[0];

        sktkst=KeyStore.getInstance("jks");
        sktkst.load(null,blkpwd);
        sktkst.setKeyEntry(svrctfals,mstkst.getKey(svrctfals,blkpwd),blkpwd,mstkst.getCertificateChain(svrctfals));
        kmf.init(sktkst,blkpwd);
        ctx.init(kmf.getKeyManagers(),null,null);
        ssf=ctx.getServerSocketFactory();
        }
    catch(java.security.GeneralSecurityException thr) {
        throw new IOException("Cannot create secure socket ("+thr+")");
        }

    // CREATE AND INITIALIZE SERVER SOCKET
    skt=(SSLServerSocket)ssf.createServerSocket(prt,bcklog,adr);
    ...
    return skt;

3 回复 | 直到 9 年前

L. Cornelius Dol 11 年前

最简单的方法是对所有域名使用一个证书。将所有其他站点名称放在SAN中(主题备用名称)。

如果您喜欢为每个域名使用一个证书,您可以编写自己的密钥管理器,并使用别名来标识域,这样您就可以使用单个密钥库。在我们的系统中,我们约定keystore别名始终等于证书中的cn。所以我们可以这样做,

SSLContext sctx1 = SSLContext.getInstance("SSLv3");
sctx1.init(new X509KeyManager[] { 
    new MyKeyManager("/config/master.jks","changeme".toCharArray(),"site1.example.com")
    },null, null);
SSLServerSocketFactory ssf = (SSLServerSocketFactory) sctx1.getServerSocketFactory();
ServerSocket ss1 = ssf.createServerSocket(1234);

...

SSLContext sctx2 = SSLContext.getInstance("SSLv3");
sctx2.init(new X509KeyManager[] { 
    new MyKeyManager("/config/master.jks","changeme".toCharArray(),"site2.example.com") 
    },null, null);
ssf = (SSLServerSocketFactory) sctx2.getServerSocketFactory();
ServerSocket ss2 = ssf.createServerSocket(5678);

…

public static class MyKeyManager implements X509KeyManager {
    private KeyStore keyStore;
    private String alias;
    private char[] password;

    MyKeyManager(String keyStoreFile, char[] password, String alias)
        throws IOException, GeneralSecurityException
    {
        this.alias = alias;
        this.password = password;
        InputStream stream = new FileInputStream(keyStoreFile);
        keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
        keyStore.load(stream, password);
    }

    public PrivateKey getPrivateKey(String alias) {
        try {
            return (PrivateKey) keyStore.getKey(alias, password);
        } catch (Exception e) {
            return null;
        }
    }

    public X509Certificate[] getCertificateChain(String alias) {
        try {
            java.security.cert.Certificate[] certs = keyStore.getCertificateChain(alias);
            if (certs == null || certs.length == 0)
                return null;
            X509Certificate[] x509 = new X509Certificate[certs.length];
            for (int i = 0; i < certs.length; i++)
                x509[i] = (X509Certificate)certs[i];
            return x509;
        } catch (Exception e) {
            return null;
        }          
    }

    public String chooseServerAlias(String keyType, Principal[] issuers,
                                    Socket socket) {
        return alias;
    }

    public String[] getClientAliases(String parm1, Principal[] parm2) {
        throw new UnsupportedOperationException("Method getClientAliases() not yet implemented.");
    }

    public String chooseClientAlias(String keyTypes[], Principal[] issuers, Socket socket) {
        throw new UnsupportedOperationException("Method chooseClientAlias() not yet implemented.");
    }

    public String[] getServerAliases(String parm1, Principal[] parm2) {
        return new String[] { alias };
    }

    public String chooseServerAlias(String parm1, Principal[] parm2) {
        return alias;
    }
}

erickson 16 年前

您将无法使用默认值 SSLServerSocketFactory .

相反, initialize 另一个 SSLContext 对于每个站点,每个使用 KeyManagerFactory configured 包含具有正确服务器证书的密钥项的密钥存储。(在初始化 密钥管理器目录 通过它 key managers 到 init 方法 SSL语境 )

后 SSL上下文 被正式化, get its SSLServerSocketFactory ,并使用它来创建您的侦听器。

KeyStore identity = KeyStore.getInstance(KeyStore.getDefaultType());
/* Load the keystore (a different one for each site). */
...
SSLContext ctx = SSLContext.getInstance("TLS");
KeyManagerFactory kmf = 
  KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
kmf.init(identity, password);
ctx.init(kmf.getKeyManagers(), null, null);
SSLServerSocketFactory factory = ctx.getServerSocketFactory();
ServerSocket server = factory.createSocket(port);

Community Mohan Dere 9 年前

我最近遇到了类似的情况。我有一个定制的嵌入式Java Web服务器,可以承载任意数量的网站。每个网站都有自己的域名。在服务器上为每个网站/域分配一个唯一的IP地址。为端口80上的每个IP地址创建一个套接字侦听器。

对于具有SSL证书的站点,我将密钥和证书导入到单个密钥库中。我为每个域的SSL证书分配了一个证书别名以匹配域名。在端口443上为每个具有SSL证书的域/网站分配一个新的套接字侦听器。

默认情况下,标准Java X509KEYMAMER和SUNX509实现 will pick the first aliases it finds for which there is a private key and a key of the right type for the chosen cipher suite (typically RSA) .不幸的是,所选别名不一定与请求的域对应,因此最终会出现证书错误。

为了规避这个问题,我用 ZZ Coder's suggestion 实现了一个自定义的X509KeyManager。实际上,对于我的服务器,我需要一个X509ExtendedKeyManager,它有一个额外的chooseEngineServerAlias()方法。

我的自定义密钥管理器依赖于主机名及其相应IP地址的哈希图。当发出新的SSL请求时,它会检查传入的IP地址并找到相应的主机名。然后,它尝试在密钥库中找到与主机名对应的别名。

private class MyKeyManager extends X509ExtendedKeyManager implements X509KeyManager {
    private KeyStore keyStore;
    private char[] password;
    private java.util.HashMap<InetAddress, String> hosts;

    public MyKeyManager(KeyStore keystore, char[] password, java.util.HashMap<InetAddress, String> hosts) 
    throws IOException, GeneralSecurityException {
        this.keyStore = keystore;
        this.password = password;
        this.hosts = hosts;
    }

    public String chooseEngineServerAlias(String keyType, Principal[] issuers, SSLEngine engine) {
        try{
            return hosts.get(InetAddress.getByName(engine.getPeerHost()));
        }
        catch(Exception e){
            return null;
        }
    }

    public String chooseServerAlias(String keyType, Principal[] issuers, Socket socket) {
        return hosts.get(socket.getLocalAddress());
    }

    public PrivateKey getPrivateKey(String alias) {
        try {
            return (PrivateKey) keyStore.getKey(alias, password);
        } 
        catch (Exception e) {
            return null;
        }
    }

    public X509Certificate[] getCertificateChain(String alias) {
        try {
            java.security.cert.Certificate[] certs = keyStore.getCertificateChain(alias);
            if (certs == null || certs.length == 0) return null;
            X509Certificate[] x509 = new X509Certificate[certs.length];
            for (int i = 0; i < certs.length; i++){
                x509[i] = (X509Certificate)certs[i];
            }
            return x509;
        } 
        catch (Exception e) {
            e.printStackTrace();
            return null;
        }          
    }

    public String[] getServerAliases(String keyType, Principal[] issuers) {
        throw new UnsupportedOperationException("Method getServerAliases() not yet implemented.");
    }

    public String[] getClientAliases(String keyType, Principal[] issuers) {
        throw new UnsupportedOperationException("Method getClientAliases() not yet implemented.");
    }

    public String chooseClientAlias(String keyTypes[], Principal[] issuers, Socket socket) {
        throw new UnsupportedOperationException("Method chooseClientAlias() not yet implemented.");
    }

    public String chooseEngineClientAlias(String[] strings, Principal[] prncpls, SSLEngine ssle) {
        throw new UnsupportedOperationException("Method chooseEngineClientAlias() not yet implemented.");
    }        
}

自定义密钥管理器用于初始化SSLContext。很酷的是,您只需要初始化一个sslcontext。

javax.net.ssl.KeyManager[] kms = new javax.net.ssl.KeyManager[]{
     new MyKeyManager(keystore, keypass, hosts)
};
TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
tmf.init(keystore);
javax.net.ssl.TrustManager[] tms = tmf.getTrustManagers();
SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(kms, tms, null);