Защита Java-приложений: полное руководство по JSSE и SSL/TLS

// Указываем расположение хранилища ключей (keystore)
System.setProperty("javax.net.ssl.keyStore", "/path/to/keystore.jks");
System.setProperty("javax.net.ssl.keyStorePassword", "keystorePassword");

// Указываем расположение хранилища доверенных сертификатов (truststore)
System.setProperty("javax.net.ssl.trustStore", "/path/to/truststore.jks");
System.setProperty("javax.net.ssl.trustStorePassword", "truststorePassword");

// Включаем отладочную информацию JSSE (полезно при разработке)
System.setProperty("javax.net.debug", "ssl:handshake");

// Создание и инициализация SSL-контекста
SSLContext sslContext = SSLContext.getInstance("TLSv1.3");

// Создаем фабрики для менеджеров ключей и доверия
KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());

// Загружаем KeyStore и TrustStore
KeyStore keyStore = KeyStore.getInstance("JKS");
keyStore.load(new FileInputStream("/path/to/keystore.jks"), "keystorePassword".toCharArray());
kmf.init(keyStore, "keystorePassword".toCharArray());

KeyStore trustStore = KeyStore.getInstance("JKS");
trustStore.load(new FileInputStream("/path/to/truststore.jks"), "truststorePassword".toCharArray());
tmf.init(trustStore);

// Инициализируем SSL-контекст с настройками
sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);

// Получаем фабрику SSL-сокетов из контекста
SSLSocketFactory socketFactory = sslContext.getSocketFactory();

// Создаем SSL-сокет
SSLSocket socket = (SSLSocket) socketFactory.createSocket("example.com", 443);

// Настраиваем разрешенные протоколы (оставляем только безопасные)
socket.setEnabledProtocols(new String[] { "TLSv1.2", "TLSv1.3" });

// Настраиваем разрешенные наборы шифров
String[] enabledCipherSuites = getStrongCipherSuites(socket.getSupportedCipherSuites());
socket.setEnabledCipherSuites(enabledCipherSuites);

import javax.net.ssl.*;
import java.io.*;
import java.net.URL;

public class HttpsClient {
public static void main(String[] args) {
try {
// Создаем SSL-контекст с настройками по умолчанию
SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(null, null, null);

// Создаем соединение с HTTPS-сервером
URL url = new URL("https://api.example.com/data");
HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();

// Настраиваем SSL-сокетную фабрику для соединения
conn.setSSLSocketFactory(sslContext.getSocketFactory());

// Опционально: настраиваем хост-верификатор (для дополнительных проверок)
conn.setHostnameVerifier((hostname, session) -> {
// Здесь можно добавить дополнительную логику проверки хостов
return hostname.equals("api.example.com");
});

// Отправляем запрос и получаем ответ
conn.setRequestMethod("GET");
int responseCode = conn.getResponseCode();

// Читаем ответ
BufferedReader in = new BufferedReader(
new InputStreamReader(conn.getInputStream()));
String inputLine;
StringBuilder response = new StringBuilder();

while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();

// Выводим результат
System.out.println("Response Code: " + responseCode);
System.out.println("Response Body: " + response.toString());

} catch (Exception e) {
e.printStackTrace();
}
}
}

import javax.net.ssl.*;
import java.io.*;

public class SSLServer {
public static void main(String[] args) {
try {
// Указываем параметры хранилища ключей
System.setProperty("javax.net.ssl.keyStore", "/path/to/server.keystore");
System.setProperty("javax.net.ssl.keyStorePassword", "password");

// Создаем фабрику SSL-серверных сокетов
SSLServerSocketFactory ssf = (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
SSLServerSocket serverSocket = (SSLServerSocket) ssf.createServerSocket(8443);

// Ограничиваем протоколы только безопасными версиями
serverSocket.setEnabledProtocols(new String[] { "TLSv1.2", "TLSv1.3" });

System.out.println("SSL Server started on port 8443");

// Бесконечный цикл для обработки подключений
while (true) {
SSLSocket clientSocket = (SSLSocket) serverSocket.accept();
System.out.println("Client connected: " + clientSocket.getInetAddress());

// Запускаем обработку клиента в отдельном потоке
new Thread(() -> handleClient(clientSocket)).start();
}
} catch (Exception e) {
e.printStackTrace();
}
}

private static void handleClient(SSLSocket socket) {
try {
// Получаем информацию о SSL-сессии
SSLSession session = socket.getSession();
System.out.println("SSL Protocol: " + session.getProtocol());
System.out.println("Cipher Suite: " + session.getCipherSuite());

// Получаем потоки для чтения и записи
BufferedReader in = new BufferedReader(
new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);

// Обрабатываем запросы клиента
String inputLine;
while ((inputLine = in.readLine()) != null) {
System.out.println("Client message: " + inputLine);
out.println("Server response: " + inputLine);

if (inputLine.equals("exit")) {
break;
}
}

// Закрываем соединение
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}

// На стороне сервера
SSLServerSocket serverSocket = (SSLServerSocket) ssf.createServerSocket(8443);
// Требуем обязательную аутентификацию клиента
serverSocket.setNeedClientAuth(true);

// На стороне клиента
// Настраиваем хранилище ключей клиента
System.setProperty("javax.net.ssl.keyStore", "/path/to/client.keystore");
System.setProperty("javax.net.ssl.keyStorePassword", "clientpassword");
// Настраиваем хранилище доверенных сертификатов
System.setProperty("javax.net.ssl.trustStore", "/path/to/client.truststore");
System.setProperty("javax.net.ssl.trustStorePassword", "clienttrustpassword");

// Создаем собственную реализацию TrustManager
TrustManager[] trustAllCertificates = new TrustManager[] { 
new X509TrustManager() {
public java.security.cert.X509Certificate[] getAcceptedIssuers() {
return null;
}

public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String authType) {
// Здесь можно реализовать пользовательскую логику проверки клиентских сертификатов
}

public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType) {
// Здесь можно реализовать пользовательскую логику проверки серверных сертификатов
try {
if (certs != null && certs.length > 0) {
certs[0].checkValidity();
// Дополнительная логика проверки...
} else {
throw new CertificateException("Certificate chain is empty");
}
} catch (CertificateExpiredException | CertificateNotYetValidException e) {
throw new CertificateException("Certificate not valid", e);
}
}
}
};

// Инициализируем SSL-контекст с нашим TrustManager
SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(null, trustAllCertificates, new java.security.SecureRandom());

// Используем его для создания соединений
HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());

# Создание хранилища ключей и генерация самоподписанного сертификата
keytool -genkeypair -alias myapp -keyalg RSA -keysize 2048 -validity 365 \
-keystore myapp.keystore -storepass keystorepass \
-dname "CN=MyApp, OU=Development, O=MyCompany, L=City, S=State, C=Country"

# Экспорт сертификата для добавления в truststore
keytool -export -alias myapp -file myapp.crt -keystore myapp.keystore -storepass keystorepass

# Создание truststore и импорт доверенного сертификата
keytool -import -trustcacerts -alias server -file server.crt \
-keystore client.truststore -storepass truststorepass

// Загружаем keystore для клиентской аутентификации
KeyStore keyStore = KeyStore.getInstance("PKCS12");
keyStore.load(new FileInputStream("client.p12"), "keystorepass".toCharArray());

// Создаем и инициализируем KeyManagerFactory
KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
kmf.init(keyStore, "keystorepass".toCharArray());

// Загружаем truststore с доверенными сертификатами
KeyStore trustStore = KeyStore.getInstance("PKCS12");
trustStore.load(new FileInputStream("truststore.p12"), "truststorepass".toCharArray());

// Создаем и инициализируем TrustManagerFactory
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init(trustStore);

// Получаем менеджеры
KeyManager[] keyManagers = kmf.getKeyManagers();
TrustManager[] trustManagers = tmf.getTrustManagers();

// Создаем и настраиваем SSL-контекст
SSLContext sslContext = SSLContext.getInstance("TLSv1.3");
sslContext.init(keyManagers, trustManagers, new SecureRandom());

public class CustomTrustManager implements X509TrustManager {
private final X509TrustManager defaultTrustManager;
private final Set<String> trustedDomains;

public CustomTrustManager(X509TrustManager defaultTrustManager, Set<String> trustedDomains) {
this.defaultTrustManager = defaultTrustManager;
this.trustedDomains = trustedDomains;
}

@Override
public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
defaultTrustManager.checkClientTrusted(chain, authType);
}

@Override
public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
// Сначала стандартная проверка
defaultTrustManager.checkServerTrusted(chain, authType);

// Затем дополнительная проверка домена
if (chain.length == 0) {
throw new CertificateException("Empty certificate chain");
}

X509Certificate serverCert = chain[0];
String subjectName = serverCert.getSubjectX500Principal().getName();
String domain = extractCNFromSubject(subjectName);

if (!trustedDomains.contains(domain)) {
throw new CertificateException("Domain not in trusted list: " + domain);
}
}

@Override
public X509Certificate[] getAcceptedIssuers() {
return defaultTrustManager.getAcceptedIssuers();
}

private String extractCNFromSubject(String subject) {
// Извлекаем Common Name (CN) из Subject DN
Matcher matcher = Pattern.compile("CN=([^,]+)").matcher(subject);
return matcher.find() ? matcher.group(1) : "";
}
}

// Диагностика: вывод информации о сертификате сервера
openssl s_client -connect example.com:443 -showcerts

// Импорт недостающих сертификатов в truststore
keytool -import -trustcacerts -alias root -file root.crt -keystore truststore.jks

// Программное решение для отладки: временное логирование сертификатов
SSLContext.setDefault(createTrustAllContext());

// Метод для создания permissive SSLContext (ТОЛЬКО ДЛЯ ОТЛАДКИ!)
private static SSLContext createTrustAllContext() throws Exception {
TrustManager[] trustAllCerts = new TrustManager[] {
new X509TrustManager() {
public X509Certificate[] getAcceptedIssuers() { return null; }
public void checkClientTrusted(X509Certificate[] certs, String authType) {
System.out.println("Client cert: " + Arrays.toString(certs));
}
public void checkServerTrusted(X509Certificate[] certs, String authType) {
System.out.println("Server cert chain: ");
for (X509Certificate cert : certs) {
System.out.println(" Subject: " + cert.getSubjectX500Principal());
System.out.println(" Issuer: " + cert.getIssuerX500Principal());
System.out.println(" Valid until: " + cert.getNotAfter());
}
}
}
};
SSLContext sc = SSLContext.getInstance("TLS");
sc.init(null, trustAllCerts, new SecureRandom());
return sc;
}

// Правильная настройка сертификата с SAN
keytool -genkeypair -alias myserver -keyalg RSA -keysize 2048 \
-keystore server.keystore -storepass password \
-ext SAN=dns:myserver.example.com,dns:localhost,ip:127.0.0.1

// Программная настройка проверки имени хоста (для HTTP)
HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
conn.setHostnameVerifier(new HostnameVerifier() {
@Override
public boolean verify(String hostname, SSLSession session) {
// Собственная логика проверки имени хоста
try {
Certificate[] certs = session.getPeerCertificates();
X509Certificate serverCert = (X509Certificate) certs[0];

// Проверяем SAN и CN
Collection<List<?>> altNames = serverCert.getSubjectAlternativeNames();
if (altNames != null) {
for (List<?> altName : altNames) {
if ((Integer)altName.get(0) == 2) { // DNS Name
String dnsName = (String)altName.get(1);
if (hostname.equalsIgnoreCase(dnsName)) {
return true;
}
}
}
}

// Проверка CN как запасной вариант
String cn = extractCNFromSubject(
serverCert.getSubjectX500Principal().getName());
return hostname.equalsIgnoreCase(cn);
} catch (Exception e) {
return false;
}
}
});

// Проверка поддерживаемых протоколов и шифров
SSLContext context = SSLContext.getDefault();
SSLParameters params = context.getSupportedSSLParameters();

System.out.println("Supported protocols: " + 
Arrays.toString(params.getProtocols()));
System.out.println("Supported cipher suites: " + 
Arrays.toString(params.getCipherSuites()));

// Обеспечение совместимости с устаревшими системами (если необходимо)
SSLSocket socket = (SSLSocket) factory.createSocket(host, port);
socket.setEnabledProtocols(new String[] { 
"TLSv1.3", "TLSv1.2", "TLSv1.1", "TLSv1" // Включаем более старые протоколы
});

// Расширение поддерживаемых алгоритмов через JCE Unlimited Strength
// Для Java 8 требуется установка JCE Unlimited Strength Jurisdiction Policy Files
// Для Java 9+ это включено по умолчанию, но может потребоваться активация:
Security.setProperty("crypto.policy", "unlimited");

// Повторное использование SSL-сессий
SSLSessionContext clientSessionContext = 
sslContext.getClientSessionContext();
// Увеличиваем кеш сессий и время их жизни
clientSessionContext.setSessionCacheSize(1000);
clientSessionContext.setSessionTimeout(3600); // в секундах

// Использование пула соединений (например, с Apache HttpClient)
PoolingHttpClientConnectionManager cm = 
new PoolingHttpClientConnectionManager();
cm.setMaxTotal(200);
cm.setDefaultMaxPerRoute(20);

CloseableHttpClient httpClient = HttpClients.custom()
.setConnectionManager(cm)
.build();

// Включение Session Tickets для TLS 1.3 (с Java 11+)
System.setProperty("jdk.tls.client.enableSessionTicketExtension", "true");
System.setProperty("jdk.tls.server.enableSessionTicketExtension", "true");

// Временное переопределение настроек безопасности при необходимости
// (используйте только в переходный период!)

// Включение TLSv1.0 и TLSv1.1 (отключены в Java 11+)
System.setProperty("jdk.tls.client.protocols", "TLSv1.3,TLSv1.2,TLSv1.1,TLSv1");

// Для критических систем: фиксация версии Security Provider
// Добавляем в начало списка провайдеров наш собственный с фиксированной конфигурацией
Security.insertProviderAt(new LegacyCompatibleProvider(), 1);

// Создание стратегии постепенной миграции и отслеживание изменений в JDK
// через java.security.debug
System.setProperty("java.security.debug", "certpath");