我使用ServerSocket和Socket对象编写了一个客户端/服务器Java程序。然后，我修改了代码以使用SSLServerSocket和'SSLSocket`，但是抛出的异常异常包括：
javax.net.ssl.SSLHandshakeException: no cipher suites in common
我希望能以编程方式做更多的事情。我也可以使用自签名证书。
我遵循的一个教程建议使用keytool Java应用程序创建一个证书，然后将该文件移到您的Java项目中。我已经用终端命令keytool -genkey -alias zastore -keyalg RSA -keystore za.store完成了。我将密码指定为password。
然后我希望调用函数System.setProperty，希望SSLSockets可以工作，但仍然不能。
这是我的服务器代码
public class Server implements Runnable
{
private SSLServerSocket serverSocket;
private int portNumber;
private Thread acceptThread;
private LinkedList<Connection> connections;
private ConnectionListener connectionListener;
public Server(int port, ConnectionListener connectionListener)
{
this.connectionListener = connectionListener;
portNumber = port;
connections = new LinkedList<Connection>();
try
{
System.setProperty("javax.net.ssl.trustStore", "za.store");
System.setProperty("javax.net.ssl.keyStorePassword", "password");
SSLServerSocketFactory sslssf = (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
serverSocket = (SSLServerSocket) sslssf.createServerSocket(portNumber,15);
}
catch (IOException e)
{
e.printStackTrace();
}
}
public void startListening()
{
acceptThread = new Thread(this);
acceptThread.start();
}
public void stopListening()
{
for(Connection c:connections)
{
c.stopListeningAndDisconnect();
}
try
{
serverSocket.close();
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Override
public void run()
{
try
{
while(true)
{
SSLSocket s = (SSLSocket) serverSocket.accept();
Connection c = new Connection(s,connectionListener);
connections.add(c);
System.out.println("New Connection Established From"+s.getInetAddress().toString());
}
}
catch(java.net.SocketException e)
{
System.out.println("Listening thread terminated with exception.");
}
catch(IOException e)
{
e.printStackTrace();
}
}
public void removeConnection(Connection c)
{
connections.remove(c);
}
public void printConnections()
{
System.out.println("Number of connections "+connections.toString());
for(int i=0; i<connections.size(); i++)
{
System.out.println(connections.toString());
}
}
}
然后是我的客户端代码的一小段，当按下按钮时，这些代码会连接：
@Override
public void actionPerformed(ActionEvent e)
{
if(e.getSource() == connect)
{
try
{
System.setProperty("javax.net.ssl.trustStore", "za.store");
System.setProperty("javax.net.ssl.keyStorePassword", "password");
SSLSocketFactory sslsf = (SSLSocketFactory)SSLSocketFactory.getDefault();
SSLSocket s = (SSLSocket)sslsf.createSocket(ipBox.getText(), Integer.parseInt(portBox.getText()));
Connection c = new Connection(s,parent);
parent.connectionSuccessful(c);
}
catch (NumberFormatException e1)
{
JOptionPane.showMessageDialog(this, "Error! Port number must be a number", "Error", JOptionPane.ERROR_MESSAGE);
}
catch (UnknownHostException e1)
{
JOptionPane.showMessageDialog(this, "Error! Unable to find that host", "Error", JOptionPane.ERROR_MESSAGE);
}
catch (IOException e1)
{
e1.printStackTrace();
}
}
}
一篇Stackoverflow文章建议我的服务器“没有证书”。我不知道这意味着什么，或者不知道如何获得一个并将其放置在正确的位置。
答案 0 :(得分：1)
以下错误可能是由于各种原因造成的：
javax.net.ssl.SSLHandshakeException: no cipher suites in common
调试时要检查的要点：
例如在以下示例中，我将Java 8与默认的密码套件一起使用。我生成的证书使用的是ECDSA和SHA384，因此在服务器和客户端之间建立TLS连接时，通过启用调试（TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384，我可以看到协商的密码套件为System.setProperty("javax.net.debug", "ssl");
以下是一个有效的示例：
第一步，需要创建密钥对和证书。为了进行测试，让我们创建一个自签名证书，并为服务器和客户端使用相同的证书：
keytool -genkeypair -alias server -keyalg EC \
-sigalg SHA384withECDSA -keysize 256 -keystore servercert.p12 \
-storetype pkcs12 -v -storepass abc123 -validity 10000 -ext san=ip:127.0.0.1
现在让我们创建服务器：
package com.sapbasu.javastudy;
import java.io.InputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.KeyStore;
import java.security.SecureRandom;
import java.util.Objects;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLServerSocket;
import javax.net.ssl.SSLServerSocketFactory;
import javax.net.ssl.TrustManagerFactory;
/*
* keytool -genkeypair -alias server -keyalg EC \
* -sigalg SHA384withECDSA -keysize 256 -keystore servercert.p12 \
* -storetype pkcs12 -v -storepass abc123 -validity 10000 -ext san=ip:127.0.0.1
*/
public class TLSServer {
public void serve(int port, String tlsVersion, String trustStoreName,
char[] trustStorePassword, String keyStoreName, char[] keyStorePassword)
throws Exception {
Objects.requireNonNull(tlsVersion, "TLS version is mandatory");
if (port <= 0) {
throw new IllegalArgumentException(
"Port number cannot be less than or equal to 0");
}
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
InputStream tstore = TLSServer.class
.getResourceAsStream("/" + trustStoreName);
trustStore.load(tstore, trustStorePassword);
tstore.close();
TrustManagerFactory tmf = TrustManagerFactory
.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init(trustStore);
KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
InputStream kstore = TLSServer.class
.getResourceAsStream("/" + keyStoreName);
keyStore.load(kstore, keyStorePassword);
KeyManagerFactory kmf = KeyManagerFactory
.getInstance(KeyManagerFactory.getDefaultAlgorithm());
kmf.init(keyStore, keyStorePassword);
SSLContext ctx = SSLContext.getInstance("TLS");
ctx.init(kmf.getKeyManagers(), tmf.getTrustManagers(),
SecureRandom.getInstanceStrong());
SSLServerSocketFactory factory = ctx.getServerSocketFactory();
try (ServerSocket listener = factory.createServerSocket(port)) {
SSLServerSocket sslListener = (SSLServerSocket) listener;
sslListener.setNeedClientAuth(true);
sslListener.setEnabledProtocols(new String[] {tlsVersion});
// NIO to be implemented
while (true) {
try (Socket socket = sslListener.accept()) {
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
out.println("Hello World!");
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
现在创建客户端：
package com.sapbasu.javastudy;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.Socket;
import java.security.KeyStore;
import java.security.SecureRandom;
import java.util.Objects;
import javax.net.SocketFactory;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLParameters;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.TrustManagerFactory;
public class TLSClient {
public String request(InetAddress serverHost, int serverPort,
String tlsVersion, String trustStoreName, char[] trustStorePassword,
String keyStoreName, char[] keyStorePassword) throws Exception {
Objects.requireNonNull(tlsVersion, "TLS version is mandatory");
Objects.requireNonNull(serverHost, "Server host cannot be null");
if (serverPort <= 0) {
throw new IllegalArgumentException(
"Server port cannot be lesss than or equal to 0");
}
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
InputStream tstore = TLSClient.class
.getResourceAsStream("/" + trustStoreName);
trustStore.load(tstore, trustStorePassword);
tstore.close();
TrustManagerFactory tmf = TrustManagerFactory
.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init(trustStore);
KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
InputStream kstore = TLSClient.class
.getResourceAsStream("/" + keyStoreName);
keyStore.load(kstore, keyStorePassword);
KeyManagerFactory kmf = KeyManagerFactory
.getInstance(KeyManagerFactory.getDefaultAlgorithm());
kmf.init(keyStore, keyStorePassword);
SSLContext ctx = SSLContext.getInstance("TLS");
ctx.init(kmf.getKeyManagers(), tmf.getTrustManagers(),
SecureRandom.getInstanceStrong());
SocketFactory factory = ctx.getSocketFactory();
try (Socket connection = factory.createSocket(serverHost, serverPort)) {
((SSLSocket) connection).setEnabledProtocols(new String[] {tlsVersion});
SSLParameters sslParams = new SSLParameters();
sslParams.setEndpointIdentificationAlgorithm("HTTPS");
((SSLSocket) connection).setSSLParameters(sslParams);
BufferedReader input = new BufferedReader(
new InputStreamReader(connection.getInputStream()));
return input.readLine();
}
}
}
最后，这是一个测试连接的JUnit测试：
package com.sapbasu.javastudy;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.net.InetAddress;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.junit.jupiter.api.Test;
public class TLSServerClientTest {
private static final int SERVER_PORT = 8444;
private static final String TLS_VERSION = "TLSv1.2";
private static final int SERVER_COUNT = 1;
private static final String SERVER_HOST_NAME = "127.0.0.1";
private static final String TRUST_STORE_NAME = "servercert.p12";
private static final char[] TRUST_STORE_PWD = new char[] {'a', 'b', 'c', '1',
'2', '3'};
private static final String KEY_STORE_NAME = "servercert.p12";
private static final char[] KEY_STORE_PWD = new char[] {'a', 'b', 'c', '1',
'2', '3'};
@Test
public void whenClientSendsServerRequest_givenServerIsUp_returnsHelloWorld()
throws Exception {
TLSServer server = new TLSServer();
TLSClient client = new TLSClient();
System.setProperty("javax.net.debug", "ssl");
ExecutorService serverExecutor = Executors.newFixedThreadPool(SERVER_COUNT);
serverExecutor.submit(() -> {
try {
server.serve(SERVER_PORT, TLS_VERSION, TRUST_STORE_NAME,
TRUST_STORE_PWD, KEY_STORE_NAME, KEY_STORE_PWD);
} catch (Exception e) {
e.printStackTrace();
}
});
try {
String returnedValue = client.request(
InetAddress.getByName(SERVER_HOST_NAME), SERVER_PORT, TLS_VERSION,
TRUST_STORE_NAME, TRUST_STORE_PWD, KEY_STORE_NAME, KEY_STORE_PWD);
assertEquals("Hello World!", returnedValue);
} catch (Exception e) {
e.printStackTrace();
throw e;
}
}
}
注意：证书（在此示例中为servercert.p12）应位于类路径中。在此示例中，我将其保留在Maven文件夹结构的test / resources文件夹中，以便JUnit测试可以在类路径中获取它。
使用TLS / SSL时，要使用的加密算法由密码套件确定。服务器支持一组密码套件（您可以根据需要和想要的安全级别启用或禁用某些套件）。客户端还支持一组密码套件。在建立连接期间，将在客户端和服务器之间协商要使用的密码套件。如果服务器支持该特定密码套件，则将优先考虑客户端的首选项。
您会找到Sun Providers最多Java 8 here支持的密码套件列表。
典型的密码套件名称如下：
TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
在这里
ECDHE 代表“椭圆曲线Diffie Hellman短暂”。这是一个密钥交换算法。椭圆变体（第一个E）用于表演，而暂时性变体（最后一个E）用于向前保密。前向保密性意味着，如果攻击者继续通过TLS记录所有通信，并且在以后的某个时间点以某种方式获得了私钥，则他/她将无法解密过去记录的通信。
ECDSA 是用于对密钥进行签名的数字签名算法，用于对共享密钥进行身份验证（验证完整性）。 ECDSA比其他认证算法（例如HMAC）更弱和更慢。但是它用于共享密钥身份验证，因为它不需要验证者知道用于创建身份验证标签的秘密密钥。服务器可以很好地使用其私钥来验证消息的完整性。
AES_128_GCM -一旦双方（通常是浏览器和Web服务器）之间共享了公共密钥，就使用对称块密码算法对双方之间的消息交换进行加密。在这种特殊情况下，将使用具有128位密钥和GCM身份验证模式的分组密码AES。
SHA256 -哈希算法
答案 1 :(得分：0)
您设置的系统属性错误。
服务器需要javax.net.keyStore（不是trustStore）和javax.net.keyStorePassword-有时是javax.net.keyStoreType，但您可能不需要。对于使用自签名证书的服务器，客户端需要 truststore 来包含该证书，并且根本不需要任何密钥库。尽管未记录，但是如果它们在同一系统上，则可以将服务器密钥库（包含privateKeyEntry）用作客户端信任库，而JSSE会自动将私有密钥的叶证书视为TrustedCert。在任何其他情况下，您都需要提取服务器的证书（非密钥），将其复制/发送到客户端，然后使用keytool -importcert将证书（非密钥）放入密钥库文件用作信任库；它既可以是自定义文件（由sysprops标识），也可以是JRE / lib / security / cacerts上的默认信任库（在当前Windows上，如果JRE在\Program Files[ (x86)]下，则默认为安装程序的默认信任库，因为Windows现在与尝试在那里更改文件的人）。
并且必须在加载JSSE类之前设置这些sysprops（如果使用）–在调用SSL[Server]SocketFactory时设置它们通常为时已晚。通常，它们是在使用-Dname=value选项调用Java的命令行上设置的。保证可以尽早完成。如果您不能这样做，请将setProperty调用放在main方法的开头，或者将其放在GUI的等效位置。
此清单为“非通用/共享密码”，因为没有密钥+证书，服务器将不支持进行服务器身份验证的密码套件，并且默认情况下，Java / JSSE仅启用进行服务器身份验证的密码套件因为其他人在很多/大多数情况下都不安全。
我确定我已经回答了第二部分，但是找不到骗子。第一部分出现在很多答案中，但通常在问题中没有清楚地呈现。