Comment utiliser TLS 1.2 en Java 6
Il semble que Java 6 supporte TLS jusqu'à la version 1.0. Existe-t-il un moyen d'utiliser TLS 1.2 en Java 6?
Peut-être qu'un correctif ou une mise à jour particulière de Java 6 sera supporté?
Les versions publiques d'Oracle Java 6 ne prennent pas en charge TLSv1.2. Versions payantes de Java 6 (post-EOL) pourraient. (UPDATE - TLSv1.1 est disponible pour Java 1.6 à partir de la mise à jour 111; source )
Contactez le service commercial Oracle.
Les autres alternatives sont:
Utilisez une autre implémentation JCE telle que Bouncy Castle.
Utilisez un IBM Java 6 ... s'il est disponible pour votre plate-forme. Selon "IBM SDK, Java Technology Edition corrige la vulnérabilité de sécurité de POODLE (CVE-2014-3566)" :
"TLSv1.1 et TLSv1.2 sont disponibles uniquement pour l'actualisation du service Java 6 10, l'actualisation du service Java 6.0.1 1 (J9 VM2.6) et les versions ultérieures."
Cependant, je vous conseillerais de passer à Java 8. Java 6 a été supprimé en février 2013 et son utilisation présente des risques. (Dites ou rappelez au patron/au client. Ils ont besoin de savoir.)
Voici une usine TLSConnection:
package test.connection;
import Java.io.ByteArrayInputStream;
import Java.io.ByteArrayOutputStream;
import Java.io.DataOutputStream;
import Java.io.IOException;
import Java.io.InputStream;
import Java.io.OutputStream;
import Java.net.InetAddress;
import Java.net.InetSocketAddress;
import Java.net.Socket;
import Java.net.UnknownHostException;
import Java.security.Principal;
import Java.security.SecureRandom;
import Java.security.Security;
import Java.security.cert.CertificateException;
import Java.security.cert.CertificateFactory;
import Java.util.Hashtable;
import Java.util.LinkedList;
import Java.util.List;
import javax.net.ssl.HandshakeCompletedEvent;
import javax.net.ssl.HandshakeCompletedListener;
import javax.net.ssl.SSLPeerUnverifiedException;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSessionContext;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import javax.security.cert.X509Certificate;
import org.bouncycastle.crypto.tls.Certificate;
import org.bouncycastle.crypto.tls.CertificateRequest;
import org.bouncycastle.crypto.tls.DefaultTlsClient;
import org.bouncycastle.crypto.tls.ExtensionType;
import org.bouncycastle.crypto.tls.TlsAuthentication;
import org.bouncycastle.crypto.tls.TlsClientProtocol;
import org.bouncycastle.crypto.tls.TlsCredentials;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
/**
* This Class enables TLS V1.2 connection based on BouncyCastle Providers.
* Just to use:
* URL myurl = new URL( "http:// ...URL tha only Works in TLS 1.2);
HttpsURLConnection con = (HttpsURLConnection )myurl.openConnection();
con.setSSLSocketFactory(new TSLSocketConnectionFactory());
* @author AZIMUTS
*
*/
public class TSLSocketConnectionFactory extends SSLSocketFactory {
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Adding Custom BouncyCastleProvider
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
static {
if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null)
Security.addProvider(new BouncyCastleProvider());
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//HANDSHAKE LISTENER
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
public class TLSHandshakeListener implements HandshakeCompletedListener {
@Override
public void handshakeCompleted(HandshakeCompletedEvent event) {
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//SECURE RANDOM
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
private SecureRandom _secureRandom = new SecureRandom();
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Adding Custom BouncyCastleProvider
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
@Override
public Socket createSocket(Socket socket, final String Host, int port, boolean arg3)
throws IOException {
if (socket == null) {
socket = new Socket();
}
if (!socket.isConnected()) {
socket.connect(new InetSocketAddress(Host, port));
}
final TlsClientProtocol tlsClientProtocol = new TlsClientProtocol(socket.getInputStream(), socket.getOutputStream(), _secureRandom);
return _createSSLSocket(Host, tlsClientProtocol);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SOCKET FACTORY METHODS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@Override
public String[] getDefaultCipherSuites() {
return null;
}
@Override
public String[] getSupportedCipherSuites(){
return null;
}
@Override
public Socket createSocket(String Host, int port) throws IOException,UnknownHostException{
return null;
}
@Override
public Socket createSocket(InetAddress Host, int port) throws IOException {
return null;
}
@Override
public Socket createSocket(String Host, int port, InetAddress localHost,
int localPort) throws IOException, UnknownHostException {
return null;
}
@Override
public Socket createSocket(InetAddress address, int port,
InetAddress localAddress, int localPort) throws IOException{
return null;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//SOCKET CREATION
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private SSLSocket _createSSLSocket(final String Host , final TlsClientProtocol tlsClientProtocol) {
return new SSLSocket() {
private Java.security.cert.Certificate[] peertCerts;
@Override
public InputStream getInputStream() throws IOException {
return tlsClientProtocol.getInputStream();
}
@Override
public OutputStream getOutputStream() throws IOException {
return tlsClientProtocol.getOutputStream();
}
@Override
public synchronized void close() throws IOException {
tlsClientProtocol.close();
}
@Override
public void addHandshakeCompletedListener(HandshakeCompletedListener arg0) {
}
@Override
public boolean getEnableSessionCreation() {
return false;
}
@Override
public String[] getEnabledCipherSuites() {
return null;
}
@Override
public String[] getEnabledProtocols() {
// TODO Auto-generated method stub
return null;
}
@Override
public boolean getNeedClientAuth(){
return false;
}
@Override
public SSLSession getSession() {
return new SSLSession() {
@Override
public int getApplicationBufferSize() {
return 0;
}
@Override
public String getCipherSuite() {
throw new UnsupportedOperationException();
}
@Override
public long getCreationTime() {
throw new UnsupportedOperationException();
}
@Override
public byte[] getId() {
throw new UnsupportedOperationException();
}
@Override
public long getLastAccessedTime() {
throw new UnsupportedOperationException();
}
@Override
public Java.security.cert.Certificate[] getLocalCertificates() {
throw new UnsupportedOperationException();
}
@Override
public Principal getLocalPrincipal() {
throw new UnsupportedOperationException();
}
@Override
public int getPacketBufferSize() {
throw new UnsupportedOperationException();
}
@Override
public X509Certificate[] getPeerCertificateChain()
throws SSLPeerUnverifiedException {
// TODO Auto-generated method stub
return null;
}
@Override
public Java.security.cert.Certificate[] getPeerCertificates()throws SSLPeerUnverifiedException {
return peertCerts;
}
@Override
public String getPeerHost() {
throw new UnsupportedOperationException();
}
@Override
public int getPeerPort() {
return 0;
}
@Override
public Principal getPeerPrincipal() throws SSLPeerUnverifiedException {
return null;
//throw new UnsupportedOperationException();
}
@Override
public String getProtocol() {
throw new UnsupportedOperationException();
}
@Override
public SSLSessionContext getSessionContext() {
throw new UnsupportedOperationException();
}
@Override
public Object getValue(String arg0) {
throw new UnsupportedOperationException();
}
@Override
public String[] getValueNames() {
throw new UnsupportedOperationException();
}
@Override
public void invalidate() {
throw new UnsupportedOperationException();
}
@Override
public boolean isValid() {
throw new UnsupportedOperationException();
}
@Override
public void putValue(String arg0, Object arg1) {
throw new UnsupportedOperationException();
}
@Override
public void removeValue(String arg0) {
throw new UnsupportedOperationException();
}
};
}
@Override
public String[] getSupportedProtocols() {
return null;
}
@Override
public boolean getUseClientMode() {
return false;
}
@Override
public boolean getWantClientAuth() {
return false;
}
@Override
public void removeHandshakeCompletedListener(HandshakeCompletedListener arg0) {
}
@Override
public void setEnableSessionCreation(boolean arg0) {
}
@Override
public void setEnabledCipherSuites(String[] arg0) {
}
@Override
public void setEnabledProtocols(String[] arg0) {
}
@Override
public void setNeedClientAuth(boolean arg0) {
}
@Override
public void setUseClientMode(boolean arg0) {
}
@Override
public void setWantClientAuth(boolean arg0) {
}
@Override
public String[] getSupportedCipherSuites() {
return null;
}
@Override
public void startHandshake() throws IOException {
tlsClientProtocol.connect(new DefaultTlsClient() {
@Override
public Hashtable<Integer, byte[]> getClientExtensions() throws IOException {
Hashtable<Integer, byte[]> clientExtensions = super.getClientExtensions();
if (clientExtensions == null) {
clientExtensions = new Hashtable<Integer, byte[]>();
}
//Add Host_name
byte[] Host_name = Host.getBytes();
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
final DataOutputStream dos = new DataOutputStream(baos);
dos.writeShort(Host_name.length + 3); // entry size
dos.writeByte(0); // name type = hostname
dos.writeShort(Host_name.length);
dos.write(Host_name);
dos.close();
clientExtensions.put(ExtensionType.server_name, baos.toByteArray());
return clientExtensions;
}
@Override
public TlsAuthentication getAuthentication()
throws IOException {
return new TlsAuthentication() {
@Override
public void notifyServerCertificate(Certificate serverCertificate) throws IOException {
try {
CertificateFactory cf = CertificateFactory.getInstance("X.509");
List<Java.security.cert.Certificate> certs = new LinkedList<Java.security.cert.Certificate>();
for ( org.bouncycastle.asn1.x509.Certificate c : serverCertificate.getCertificateList()) {
certs.add(cf.generateCertificate(new ByteArrayInputStream(c.getEncoded())));
}
peertCerts = certs.toArray(new Java.security.cert.Certificate[0]);
} catch (CertificateException e) {
System.out.println( "Failed to cache server certs"+ e);
throw new IOException(e);
}
}
@Override
public TlsCredentials getClientCredentials(CertificateRequest arg0)
throws IOException {
return null;
}
};
}
});
}
};//Socket
}
}
Rappelez-vous que le mieux est de prouver que le meilleur est de tester votre site Web uniquement avec TLS 1.2. Si le Web expose TLS 1.0, TLS 1.1, en fonction de l'implémentation Java, se connectera à l'aide des versions tls 1.0 et 1.1. Testez-le sur un site qui expose uniquement TLS 1.2. Un exemple peut être le site sécurisé NIST https://www.nist.gov
Java 6, supporte maintenant TLS 1.2, voir ci-dessous
http://www.Oracle.com/technetwork/Java/javase/overview-156328.html#R160_121
Vous devez créer votre propre SSLSocketFactory basée sur Bouncy Castle. Après l’utiliser, passez au HttpsConnextion commun pour utiliser ce SocketFactory personnalisé.
1. Premièrement: Créer une TLSConnectionFactory
Voici un conseil:
1.1 Étendre SSLConnectionFactory
1.2 Remplacer cette méthode:
@Override
public Socket createSocket(Socket socket, final String Host, int port, boolean arg3)
Cette méthode appellera la méthode interne suivante,
1.3 Implémenter une méthode interne _createSSLSocket (Host, tlsClientProtocol);
Ici, vous devez créer un Socket en utilisant TlsClientProtocol. L'astuce consiste à remplacer ... méthode startHandshake () appelant TlsClientProtocol
private SSLSocket _createSSLSocket(final String Host , final TlsClientProtocol tlsClientProtocol) {
return new SSLSocket() {
.... Override and implement SSLSocket methods, particulary:
startHandshake() {
}
}
Important: L’exemple complet d’utilisation du protocole client TLS est bien expliqué ici: Utilisation de BouncyCastle pour une requête HTTPS simple
2. Deuxièmement: Utilisez cette SSLConnextionFactory personnalisée sur la connexion HTTPS commune.
C'est important ! Dans d'autres exemples, vous pouvez voir sur le Web, vous voyez des commandes HTTP codées en dur .... avec une SSLConnectionFactory personnalisée, vous n'avez besoin de rien de plus ...
URL myurl = new URL( "http:// ...URL tha only Works in TLS 1.2);
HttpsURLConnection con = (HttpsURLConnection )myurl.openConnection();
con.setSSLSocketFactory(new TSLSocketConnectionFactory());
Si vous avez besoin d'accéder à un ensemble spécifique de services distants, vous pouvez utiliser un proxy inverse intermediate pour effectuer tls1.2 à votre place. Cela vous éviterait d'essayer de corriger ou de mettre à niveau Java1.6.
par exemple .app -> proxy: http (5500) [tls-1.2] -> distant: https (443)
La configuration dans sa forme la plus simple (un port par service) pour Apache httpd est la suivante:
Listen 127.0.0.1:5000
<VirtualHost *:5500>
SSLProxyEngine On
ProxyPass / https://remote-domain/
ProxyPassReverse / https://remote-domain/
</VirtualHost>
Ensuite, au lieu d'accéder à https: // domaine-distant/ vous accédez à http: // localhost: 5500/