1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
package com.intellij.execution.rmi.ssl;
import com.intellij.openapi.util.text.StringUtilRt;
import org.jetbrains.annotations.NotNull;
import javax.net.ssl.*;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.security.*;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.util.UUID;
public class SslSocketFactory extends SSLSocketFactory {
public static final String SSL_CA_CERT_PATH = "sslCaCertPath";
public static final String SSL_CLIENT_CERT_PATH = "sslClientCertPath";
public static final String SSL_CLIENT_KEY_PATH = "sslClientKeyPath";
public static final String SSL_TRUST_EVERYBODY = "sslTrustEverybody";
private SSLSocketFactory myFactory;
public SslSocketFactory() throws GeneralSecurityException, IOException {
super();
SSLContext ctx = SSLContext.getInstance("TLS");
TrustManager[] tms;
KeyManager[] kms;
try {
String caCertPath = System.getProperty(SSL_CA_CERT_PATH);
String clientCertPath = System.getProperty(SSL_CLIENT_CERT_PATH);
String clientKeyPath = System.getProperty(SSL_CLIENT_KEY_PATH);
boolean trustEverybody = StringUtilRt.parseBoolean(System.getProperty(SSL_TRUST_EVERYBODY), false);
tms = trustEverybody ? new TrustManager[]{new MyTrustEverybodyManager()} :
caCertPath == null ? new TrustManager[]{} : new TrustManager[]{new MyTrustManager(caCertPath)};
kms = clientCertPath != null && clientKeyPath != null
? new KeyManager[]{new MyKeyManager(clientCertPath, clientKeyPath)}
: new KeyManager[]{};
}
catch (Exception e) {
throw new RuntimeException(e);
}
ctx.init(kms, tms, null);
myFactory = ctx.getSocketFactory();
}
public Socket createSocket(InetAddress host, int port) throws IOException {
return myFactory.createSocket(host, port);
}
public Socket createSocket(String host, int port) throws IOException {
return myFactory.createSocket(host, port);
}
public Socket createSocket(String host, int port, InetAddress localHost, int localPort) throws IOException {
return myFactory.createSocket(host, port, localHost, localPort);
}
public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException {
return myFactory.createSocket(address, port, localAddress, localPort);
}
public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException {
return myFactory.createSocket(socket, host, port, autoClose);
}
public String[] getDefaultCipherSuites() {
return myFactory.getDefaultCipherSuites();
}
public String[] getSupportedCipherSuites() {
return myFactory.getSupportedCipherSuites();
}
@NotNull
public static X509Certificate readCertificate(@NotNull String filePath) throws CertificateException, IOException {
CertificateFactory factory = CertificateFactory.getInstance("X.509");
InputStream inStream = new FileInputStream(filePath);
X509Certificate ca = (X509Certificate)factory.generateCertificate(inStream);
inStream.close();
return ca;
}
@NotNull
public static PrivateKey readPrivateKey(@NotNull String filePath) throws IOException {
return new PrivateKeyReader(filePath).getPrivateKey();
}
private static class MyTrustManager implements X509TrustManager {
@NotNull private final String myCaCertPath;
private X509TrustManager trustManager;
private MyTrustManager(@NotNull String caCertPath) throws Exception {
myCaCertPath = caCertPath;
KeyStore ks = createStore();
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init(ks);
for (TrustManager tm : tmf.getTrustManagers()) {
if (tm instanceof X509TrustManager) {
trustManager = (X509TrustManager)tm;
break;
}
}
if (trustManager == null) {
throw new RuntimeException("No X509TrustManager found");
}
}
@NotNull
public KeyStore createStore() throws CertificateException, IOException, KeyStoreException, NoSuchAlgorithmException {
KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
ks.load(null);
X509Certificate caCert = readCertificate(myCaCertPath);
ks.setCertificateEntry(UUID.randomUUID().toString(), caCert);
return ks;
}
public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
}
public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
if (trustManager == null) throw new RuntimeException("No X509TrustManager found");
trustManager.checkServerTrusted(x509Certificates, s);
}
@NotNull
public X509Certificate[] getAcceptedIssuers() {
return new X509Certificate[0];
}
}
private static class MyTrustEverybodyManager implements X509TrustManager {
public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
}
public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
}
@NotNull
public X509Certificate[] getAcceptedIssuers() {
return new X509Certificate[0];
}
}
private static class MyKeyManager extends X509ExtendedKeyManager {
private final String myAlias = UUID.randomUUID().toString();
private final X509Certificate[] myCertificates;
private final PrivateKey myPrivateKey;
private MyKeyManager(@NotNull String certPath, @NotNull String keyPath) throws Exception {
myCertificates = new X509Certificate[]{readCertificate(certPath)};
myPrivateKey = readPrivateKey(keyPath);
}
public String[] getClientAliases(String s, Principal[] principals) {
return new String[]{};
}
public String chooseClientAlias(String[] strings, Principal[] principals, Socket socket) {
return myAlias;
}
public String[] getServerAliases(String s, Principal[] principals) {
return new String[]{};
}
public String chooseServerAlias(String s, Principal[] principals, Socket socket) {
return null;
}
public X509Certificate[] getCertificateChain(String s) {
return myCertificates;
}
public PrivateKey getPrivateKey(String s) {
return myPrivateKey;
}
}
}
|
