Cách sử dụng TLS 1.2 trong Java 6

Question

Có vẻ như Java 6 hỗ trợ TLS tối đa v1.0, có cách nào để sử dụng TLS 1.2 trong Java 6 không?

Có lẽ bản vá hoặc bản cập nhật cụ thể của Java 6 sẽ có hỗ trợ cho nó?

Answer 1

Phiên bản Oracle Java 6 công khai không hỗ trợ TLSv1.2. Các bản phát hành trả tiền của Java 6 (sau EOL) có thể. (CẬP NHẬT - TLSv1.1 có sẵn cho Java 1.6 từ bản cập nhật 111 trở đi; source)

Liên hệ với bộ phận bán hàng của Oracle.

lựa chọn thay thế khác là:

• Sử dụng một thực hiện JCE thay thế như Bouncy Castle.

• Sử dụng IBM Java 6 ... nếu có sẵn cho nền tảng của bạn. Theo số "IBM SDK, Java Technology Edition fixes to mitigate against the POODLE security vulnerability (CVE-2014-3566)":

  "TLSv1.1 và TLSv1.2 chỉ khả dụng cho dịch vụ làm mới Java 6 10, làm mới dịch vụ Java 6.0.1 (J9 VM2.6) và phiên bản mới hơn".

---

Tuy nhiên, tôi muốn khuyên nâng cấp lên Java 8. Java 6 đã EOL'd trong tháng 2 năm 2013, và tiếp tục sử dụng nó có khả năng gây nguy hiểm. (Nói hoặc nhắc nhở ông chủ/khách hàng. Họ cần phải biết.)

Answer 2

Bạn phải tạo SSLSocketFactory của riêng mình dựa trên Lâu đài Bouncy. Sau khi sử dụng nó, chuyển đến HttpsConnextion phổ biến để sử dụng SocketFactory tùy chỉnh này.

1. Đầu tiên: Tạo một TLSConnectionFactory

Dưới đây là một lời khuyên:

1.1 Mở rộng SSLConnectionFactory

1.2 Ghi đè phương pháp này:

@Override 
public Socket createSocket(Socket socket, final String host, int port, boolean arg3) 

Phương pháp này sẽ gọi tiếp theo phương thức nội bộ,

1.3 Thực hiện phương thức nội bộ _createSSLSocket (máy chủ, tlsClientProtocol);

Ở đây bạn phải tạo một Ổ cắm bằng TlsClientProtocol. Bí quyết là ghi đè ... startHandshake() phương pháp gọi TlsClientProtocol

private SSLSocket _createSSLSocket(final String host , final TlsClientProtocol tlsClientProtocol) { 
    return new SSLSocket() {  
     .... Override and implement SSLSocket methods, particulary: 
      startHandshake() { 
      }  
    } 

Chú ý: Các mẫu đầy đủ cách sử dụng TLS Khách hàng Nghị định thư được giải thích tốt ở đây: Using BouncyCastle for a simple HTTPS query

2. Thứ hai: Sử dụng tùy chỉnh SSLConnextionFactory này trên HTTPSConnection phổ biến.

Điều này quan trọng! Trong các mẫu khác bạn có thể nhìn thấy trên web, u thấy các lệnh HTTP được mã hóa cứng .... vì vậy với một SSLConnectionFactory tùy chỉnh u không cần gì hơn ...

URL myurl = new URL("http:// ...URL tha only Works in TLS 1.2); 
    HttpsURLConnection con = (HttpsURLConnection)myurl.openConnection(); 
    con.setSSLSocketFactory(new TSLSocketConnectionFactory()); 

Answer 3

Dưới đây là một Nhà máy 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 

    } 
} 

Answer 4

Java 6, bây giờ hỗ trợ TLS 1.2, hãy kiểm tra dưới đây

http://www.oracle.com/technetwork/java/javase/overview-156328.html#R160_121