core/java/android/net/SSLCertificateSocketFactory.java

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package android.net;
  18
  19 import android.os.SystemProperties;
  20 import android.util.Log;
  21 import com.android.org.conscrypt.OpenSSLContextImpl;
  22 import com.android.org.conscrypt.OpenSSLSocketImpl;
  23 import com.android.org.conscrypt.SSLClientSessionCache;
  24 import java.io.IOException;
  25 import java.net.InetAddress;
  26 import java.net.Socket;
  27 import java.net.SocketException;
  28 import java.security.KeyManagementException;
  29 import java.security.PrivateKey;
  30 import java.security.cert.X509Certificate;
  31 import javax.net.SocketFactory;
  32 import javax.net.ssl.HostnameVerifier;
  33 import javax.net.ssl.HttpsURLConnection;
  34 import javax.net.ssl.KeyManager;
  35 import javax.net.ssl.SSLException;
  36 import javax.net.ssl.SSLPeerUnverifiedException;
  37 import javax.net.ssl.SSLSession;
  38 import javax.net.ssl.SSLSocket;
  39 import javax.net.ssl.SSLSocketFactory;
  40 import javax.net.ssl.TrustManager;
  41 import javax.net.ssl.X509TrustManager;
  42
  43 /**
  44  * SSLSocketFactory implementation with several extra features:
  45  *
  46  * <ul>
  47  * <li>Timeout specification for SSL handshake operations
  48  * <li>Hostname verification in most cases (see WARNINGs below)
  49  * <li>Optional SSL session caching with {@link SSLSessionCache}
  50  * <li>Optionally bypass all SSL certificate checks
  51  * </ul>
  52  *
  53  * The handshake timeout does not apply to actual TCP socket connection.
  54  * If you want a connection timeout as well, use {@link #createSocket()}
  55  * and {@link Socket#connect(SocketAddress, int)}, after which you
  56  * must verify the identity of the server you are connected to.
  57  *
  58  * <p class="caution"><b>Most {@link SSLSocketFactory} implementations do not
  59  * verify the server's identity, allowing man-in-the-middle attacks.</b>
  60  * This implementation does check the server's certificate hostname, but only
  61  * for createSocket variants that specify a hostname.  When using methods that
  62  * use {@link InetAddress} or which return an unconnected socket, you MUST
  63  * verify the server's identity yourself to ensure a secure connection.</p>
  64  *
  65  * <p>One way to verify the server's identity is to use
  66  * {@link HttpsURLConnection#getDefaultHostnameVerifier()} to get a
  67  * {@link HostnameVerifier} to verify the certificate hostname.
  68  *
  69  * <p>On development devices, "setprop socket.relaxsslcheck yes" bypasses all
  70  * SSL certificate and hostname checks for testing purposes.  This setting
  71  * requires root access.
  72  */
  73 public class SSLCertificateSocketFactory extends SSLSocketFactory {
  74     private static final String TAG = "SSLCertificateSocketFactory";
  75
  76     private static final TrustManager[] INSECURE_TRUST_MANAGER = new TrustManager[] {
  77         new X509TrustManager() {
  78             public X509Certificate[] getAcceptedIssuers() { return null; }
  79             public void checkClientTrusted(X509Certificate[] certs, String authType) { }
  80             public void checkServerTrusted(X509Certificate[] certs, String authType) { }
  81         }
  82     };
  83
  84     private SSLSocketFactory mInsecureFactory = null;
  85     private SSLSocketFactory mSecureFactory = null;
  86     private TrustManager[] mTrustManagers = null;
  87     private KeyManager[] mKeyManagers = null;
  88     private byte[] mNpnProtocols = null;
  89     private byte[] mAlpnProtocols = null;
  90     private PrivateKey mChannelIdPrivateKey = null;
  91
  92     private final int mHandshakeTimeoutMillis;
  93     private final SSLClientSessionCache mSessionCache;
  94     private final boolean mSecure;
  95
  96     /** @deprecated Use {@link #getDefault(int)} instead. */
  97     @Deprecated
  98     public SSLCertificateSocketFactory(int handshakeTimeoutMillis) {
  99         this(handshakeTimeoutMillis, null, true);
 100     }
 101
 102     private SSLCertificateSocketFactory(
 103             int handshakeTimeoutMillis, SSLSessionCache cache, boolean secure) {
 104         mHandshakeTimeoutMillis = handshakeTimeoutMillis;
 105         mSessionCache = cache == null ? null : cache.mSessionCache;
 106         mSecure = secure;
 107     }
 108
 109     /**
 110      * Returns a new socket factory instance with an optional handshake timeout.
 111      *
 112      * @param handshakeTimeoutMillis to use for SSL connection handshake, or 0
 113      *         for none.  The socket timeout is reset to 0 after the handshake.
 114      * @return a new SSLSocketFactory with the specified parameters
 115      */
 116     public static SocketFactory getDefault(int handshakeTimeoutMillis) {
 117         return new SSLCertificateSocketFactory(handshakeTimeoutMillis, null, true);
 118     }
 119
 120     /**
 121      * Returns a new socket factory instance with an optional handshake timeout
 122      * and SSL session cache.
 123      *
 124      * @param handshakeTimeoutMillis to use for SSL connection handshake, or 0
 125      *         for none.  The socket timeout is reset to 0 after the handshake.
 126      * @param cache The {@link SSLSessionCache} to use, or null for no cache.
 127      * @return a new SSLSocketFactory with the specified parameters
 128      */
 129     public static SSLSocketFactory getDefault(int handshakeTimeoutMillis, SSLSessionCache cache) {
 130         return new SSLCertificateSocketFactory(handshakeTimeoutMillis, cache, true);
 131     }
 132
 133     /**
 134      * Returns a new instance of a socket factory with all SSL security checks
 135      * disabled, using an optional handshake timeout and SSL session cache.
 136      *
 137      * <p class="caution"><b>Warning:</b> Sockets created using this factory
 138      * are vulnerable to man-in-the-middle attacks!</p>
 139      *
 140      * @param handshakeTimeoutMillis to use for SSL connection handshake, or 0
 141      *         for none.  The socket timeout is reset to 0 after the handshake.
 142      * @param cache The {@link SSLSessionCache} to use, or null for no cache.
 143      * @return an insecure SSLSocketFactory with the specified parameters
 144      */
 145     public static SSLSocketFactory getInsecure(int handshakeTimeoutMillis, SSLSessionCache cache) {
 146         return new SSLCertificateSocketFactory(handshakeTimeoutMillis, cache, false);
 147     }
 148
 149     /**
 150      * Returns a socket factory (also named SSLSocketFactory, but in a different
 151      * namespace) for use with the Apache HTTP stack.
 152      *
 153      * @param handshakeTimeoutMillis to use for SSL connection handshake, or 0
 154      *         for none.  The socket timeout is reset to 0 after the handshake.
 155      * @param cache The {@link SSLSessionCache} to use, or null for no cache.
 156      * @return a new SocketFactory with the specified parameters
 157      *
 158      * @deprecated Use {@link #getDefault()} along with a {@link javax.net.ssl.HttpsURLConnection}
 159      *     instead. The Apache HTTP client is no longer maintained and may be removed in a future
 160      *     release. Please visit <a href="http://android-developers.blogspot.com/2011/09/androids-http-clients.html">this webpage</a>
 161      *     for further details.
 162      *
 163      * @removed
 164      */
 165     @Deprecated
 166     public static org.apache.http.conn.ssl.SSLSocketFactory getHttpSocketFactory(
 167             int handshakeTimeoutMillis, SSLSessionCache cache) {
 168         return new org.apache.http.conn.ssl.SSLSocketFactory(
 169                 new SSLCertificateSocketFactory(handshakeTimeoutMillis, cache, true));
 170     }
 171
 172     /**
 173      * Verify the hostname of the certificate used by the other end of a
 174      * connected socket.  You MUST call this if you did not supply a hostname
 175      * to {@link #createSocket()}.  It is harmless to call this method
 176      * redundantly if the hostname has already been verified.
 177      *
 178      * <p>Wildcard certificates are allowed to verify any matching hostname,
 179      * so "foo.bar.example.com" is verified if the peer has a certificate
 180      * for "*.example.com".
 181      *
 182      * @param socket An SSL socket which has been connected to a server
 183      * @param hostname The expected hostname of the remote server
 184      * @throws IOException if something goes wrong handshaking with the server
 185      * @throws SSLPeerUnverifiedException if the server cannot prove its identity
 186      *
 187      * @hide
 188      */
 189     public static void verifyHostname(Socket socket, String hostname) throws IOException {
 190         if (!(socket instanceof SSLSocket)) {
 191             throw new IllegalArgumentException("Attempt to verify non-SSL socket");
 192         }
 193
 194         if (!isSslCheckRelaxed()) {
 195             // The code at the start of OpenSSLSocketImpl.startHandshake()
 196             // ensures that the call is idempotent, so we can safely call it.
 197             SSLSocket ssl = (SSLSocket) socket;
 198             ssl.startHandshake();
 199
 200             SSLSession session = ssl.getSession();
 201             if (session == null) {
 202                 throw new SSLException("Cannot verify SSL socket without session");
 203             }
 204             if (!HttpsURLConnection.getDefaultHostnameVerifier().verify(hostname, session)) {
 205                 throw new SSLPeerUnverifiedException("Cannot verify hostname: " + hostname);
 206             }
 207         }
 208     }
 209
 210     private SSLSocketFactory makeSocketFactory(
 211             KeyManager[] keyManagers, TrustManager[] trustManagers) {
 212         try {
 213             OpenSSLContextImpl sslContext = OpenSSLContextImpl.getPreferred();
 214             sslContext.engineInit(keyManagers, trustManagers, null);
 215             sslContext.engineGetClientSessionContext().setPersistentCache(mSessionCache);
 216             return sslContext.engineGetSocketFactory();
 217         } catch (KeyManagementException e) {
 218             Log.wtf(TAG, e);
 219             return (SSLSocketFactory) SSLSocketFactory.getDefault();  // Fallback
 220         }
 221     }
 222
 223     private static boolean isSslCheckRelaxed() {
 224         return "1".equals(SystemProperties.get("ro.debuggable")) &&
 225             "yes".equals(SystemProperties.get("socket.relaxsslcheck"));
 226     }
 227
 228     private synchronized SSLSocketFactory getDelegate() {
 229         // Relax the SSL check if instructed (for this factory, or systemwide)
 230         if (!mSecure || isSslCheckRelaxed()) {
 231             if (mInsecureFactory == null) {
 232                 if (mSecure) {
 233                     Log.w(TAG, "*** BYPASSING SSL SECURITY CHECKS (socket.relaxsslcheck=yes) ***");
 234                 } else {
 235                     Log.w(TAG, "Bypassing SSL security checks at caller's request");
 236                 }
 237                 mInsecureFactory = makeSocketFactory(mKeyManagers, INSECURE_TRUST_MANAGER);
 238             }
 239             return mInsecureFactory;
 240         } else {
 241             if (mSecureFactory == null) {
 242                 mSecureFactory = makeSocketFactory(mKeyManagers, mTrustManagers);
 243             }
 244             return mSecureFactory;
 245         }
 246     }
 247
 248     /**
 249      * Sets the {@link TrustManager}s to be used for connections made by this factory.
 250      */
 251     public void setTrustManagers(TrustManager[] trustManager) {
 252         mTrustManagers = trustManager;
 253
 254         // Clear out all cached secure factories since configurations have changed.
 255         mSecureFactory = null;
 256         // Note - insecure factories only ever use the INSECURE_TRUST_MANAGER so they need not
 257         // be cleared out here.
 258     }
 259
 260     /**
 261      * Sets the <a href="http://technotes.googlecode.com/git/nextprotoneg.html">Next
 262      * Protocol Negotiation (NPN)</a> protocols that this peer is interested in.
 263      *
 264      * <p>For servers this is the sequence of protocols to advertise as
 265      * supported, in order of preference. This list is sent unencrypted to
 266      * all clients that support NPN.
 267      *
 268      * <p>For clients this is a list of supported protocols to match against the
 269      * server's list. If there is no protocol supported by both client and
 270      * server then the first protocol in the client's list will be selected.
 271      * The order of the client's protocols is otherwise insignificant.
 272      *
 273      * @param npnProtocols a non-empty list of protocol byte arrays. All arrays
 274      *     must be non-empty and of length less than 256.
 275      */
 276     public void setNpnProtocols(byte[][] npnProtocols) {
 277         this.mNpnProtocols = toLengthPrefixedList(npnProtocols);
 278     }
 279
 280     /**
 281      * Sets the
 282      * <a href="http://tools.ietf.org/html/draft-ietf-tls-applayerprotoneg-01">
 283      * Application Layer Protocol Negotiation (ALPN)</a> protocols that this peer
 284      * is interested in.
 285      *
 286      * <p>For servers this is the sequence of protocols to advertise as
 287      * supported, in order of preference. This list is sent unencrypted to
 288      * all clients that support ALPN.
 289      *
 290      * <p>For clients this is a list of supported protocols to match against the
 291      * server's list. If there is no protocol supported by both client and
 292      * server then the first protocol in the client's list will be selected.
 293      * The order of the client's protocols is otherwise insignificant.
 294      *
 295      * @param protocols a non-empty list of protocol byte arrays. All arrays
 296      *     must be non-empty and of length less than 256.
 297      * @hide
 298      */
 299     public void setAlpnProtocols(byte[][] protocols) {
 300         this.mAlpnProtocols = toLengthPrefixedList(protocols);
 301     }
 302
 303     /**
 304      * Returns an array containing the concatenation of length-prefixed byte
 305      * strings.
 306      */
 307     static byte[] toLengthPrefixedList(byte[]... items) {
 308         if (items.length == 0) {
 309             throw new IllegalArgumentException("items.length == 0");
 310         }
 311         int totalLength = 0;
 312         for (byte[] s : items) {
 313             if (s.length == 0 || s.length > 255) {
 314                 throw new IllegalArgumentException("s.length == 0 || s.length > 255: " + s.length);
 315             }
 316             totalLength += 1 + s.length;
 317         }
 318         byte[] result = new byte[totalLength];
 319         int pos = 0;
 320         for (byte[] s : items) {
 321             result[pos++] = (byte) s.length;
 322             for (byte b : s) {
 323                 result[pos++] = b;
 324             }
 325         }
 326         return result;
 327     }
 328
 329     /**
 330      * Returns the <a href="http://technotes.googlecode.com/git/nextprotoneg.html">Next
 331      * Protocol Negotiation (NPN)</a> protocol selected by client and server, or
 332      * null if no protocol was negotiated.
 333      *
 334      * @param socket a socket created by this factory.
 335      * @throws IllegalArgumentException if the socket was not created by this factory.
 336      */
 337     public byte[] getNpnSelectedProtocol(Socket socket) {
 338         return castToOpenSSLSocket(socket).getNpnSelectedProtocol();
 339     }
 340
 341     /**
 342      * Returns the
 343      * <a href="http://tools.ietf.org/html/draft-ietf-tls-applayerprotoneg-01">Application
 344      * Layer Protocol Negotiation (ALPN)</a> protocol selected by client and server, or null
 345      * if no protocol was negotiated.
 346      *
 347      * @param socket a socket created by this factory.
 348      * @throws IllegalArgumentException if the socket was not created by this factory.
 349      * @hide
 350      */
 351     public byte[] getAlpnSelectedProtocol(Socket socket) {
 352         return castToOpenSSLSocket(socket).getAlpnSelectedProtocol();
 353     }
 354
 355     /**
 356      * Sets the {@link KeyManager}s to be used for connections made by this factory.
 357      */
 358     public void setKeyManagers(KeyManager[] keyManagers) {
 359         mKeyManagers = keyManagers;
 360
 361         // Clear out any existing cached factories since configurations have changed.
 362         mSecureFactory = null;
 363         mInsecureFactory = null;
 364     }
 365
 366     /**
 367      * Sets the private key to be used for TLS Channel ID by connections made by this
 368      * factory.
 369      *
 370      * @param privateKey private key (enables TLS Channel ID) or {@code null} for no key (disables
 371      *        TLS Channel ID). The private key has to be an Elliptic Curve (EC) key based on the
 372      *        NIST P-256 curve (aka SECG secp256r1 or ANSI X9.62 prime256v1).
 373      *
 374      * @hide
 375      */
 376     public void setChannelIdPrivateKey(PrivateKey privateKey) {
 377         mChannelIdPrivateKey = privateKey;
 378     }
 379
 380     /**
 381      * Enables <a href="http://tools.ietf.org/html/rfc5077#section-3.2">session ticket</a>
 382      * support on the given socket.
 383      *
 384      * @param socket a socket created by this factory
 385      * @param useSessionTickets {@code true} to enable session ticket support on this socket.
 386      * @throws IllegalArgumentException if the socket was not created by this factory.
 387      */
 388     public void setUseSessionTickets(Socket socket, boolean useSessionTickets) {
 389         castToOpenSSLSocket(socket).setUseSessionTickets(useSessionTickets);
 390     }
 391
 392     /**
 393      * Turns on <a href="http://tools.ietf.org/html/rfc6066#section-3">Server
 394      * Name Indication (SNI)</a> on a given socket.
 395      *
 396      * @param socket a socket created by this factory.
 397      * @param hostName the desired SNI hostname, null to disable.
 398      * @throws IllegalArgumentException if the socket was not created by this factory.
 399      */
 400     public void setHostname(Socket socket, String hostName) {
 401         castToOpenSSLSocket(socket).setHostname(hostName);
 402     }
 403
 404     /**
 405      * Sets this socket's SO_SNDTIMEO write timeout in milliseconds.
 406      * Use 0 for no timeout.
 407      * To take effect, this option must be set before the blocking method was called.
 408      *
 409      * @param socket a socket created by this factory.
 410      * @param timeout the desired write timeout in milliseconds.
 411      * @throws IllegalArgumentException if the socket was not created by this factory.
 412      *
 413      * @hide
 414      */
 415     public void setSoWriteTimeout(Socket socket, int writeTimeoutMilliseconds)
 416             throws SocketException {
 417         castToOpenSSLSocket(socket).setSoWriteTimeout(writeTimeoutMilliseconds);
 418     }
 419
 420     private static OpenSSLSocketImpl castToOpenSSLSocket(Socket socket) {
 421         if (!(socket instanceof OpenSSLSocketImpl)) {
 422             throw new IllegalArgumentException("Socket not created by this factory: "
 423                     + socket);
 424         }
 425
 426         return (OpenSSLSocketImpl) socket;
 427     }
 428
 429     /**
 430      * {@inheritDoc}
 431      *
 432      * <p>This method verifies the peer's certificate hostname after connecting
 433      * (unless created with {@link #getInsecure(int, SSLSessionCache)}).
 434      */
 435     @Override
 436     public Socket createSocket(Socket k, String host, int port, boolean close) throws IOException {
 437         OpenSSLSocketImpl s = (OpenSSLSocketImpl) getDelegate().createSocket(k, host, port, close);
 438         s.setNpnProtocols(mNpnProtocols);
 439         s.setAlpnProtocols(mAlpnProtocols);
 440         s.setHandshakeTimeout(mHandshakeTimeoutMillis);
 441         s.setChannelIdPrivateKey(mChannelIdPrivateKey);
 442         if (mSecure) {
 443             verifyHostname(s, host);
 444         }
 445         return s;
 446     }
 447
 448     /**
 449      * Creates a new socket which is not connected to any remote host.
 450      * You must use {@link Socket#connect} to connect the socket.
 451      *
 452      * <p class="caution"><b>Warning:</b> Hostname verification is not performed
 453      * with this method.  You MUST verify the server's identity after connecting
 454      * the socket to avoid man-in-the-middle attacks.</p>
 455      */
 456     @Override
 457     public Socket createSocket() throws IOException {
 458         OpenSSLSocketImpl s = (OpenSSLSocketImpl) getDelegate().createSocket();
 459         s.setNpnProtocols(mNpnProtocols);
 460         s.setAlpnProtocols(mAlpnProtocols);
 461         s.setHandshakeTimeout(mHandshakeTimeoutMillis);
 462         s.setChannelIdPrivateKey(mChannelIdPrivateKey);
 463         return s;
 464     }
 465
 466     /**
 467      * {@inheritDoc}
 468      *
 469      * <p class="caution"><b>Warning:</b> Hostname verification is not performed
 470      * with this method.  You MUST verify the server's identity after connecting
 471      * the socket to avoid man-in-the-middle attacks.</p>
 472      */
 473     @Override
 474     public Socket createSocket(InetAddress addr, int port, InetAddress localAddr, int localPort)
 475             throws IOException {
 476         OpenSSLSocketImpl s = (OpenSSLSocketImpl) getDelegate().createSocket(
 477                 addr, port, localAddr, localPort);
 478         s.setNpnProtocols(mNpnProtocols);
 479         s.setAlpnProtocols(mAlpnProtocols);
 480         s.setHandshakeTimeout(mHandshakeTimeoutMillis);
 481         s.setChannelIdPrivateKey(mChannelIdPrivateKey);
 482         return s;
 483     }
 484
 485     /**
 486      * {@inheritDoc}
 487      *
 488      * <p class="caution"><b>Warning:</b> Hostname verification is not performed
 489      * with this method.  You MUST verify the server's identity after connecting
 490      * the socket to avoid man-in-the-middle attacks.</p>
 491      */
 492     @Override
 493     public Socket createSocket(InetAddress addr, int port) throws IOException {
 494         OpenSSLSocketImpl s = (OpenSSLSocketImpl) getDelegate().createSocket(addr, port);
 495         s.setNpnProtocols(mNpnProtocols);
 496         s.setAlpnProtocols(mAlpnProtocols);
 497         s.setHandshakeTimeout(mHandshakeTimeoutMillis);
 498         s.setChannelIdPrivateKey(mChannelIdPrivateKey);
 499         return s;
 500     }
 501
 502     /**
 503      * {@inheritDoc}
 504      *
 505      * <p>This method verifies the peer's certificate hostname after connecting
 506      * (unless created with {@link #getInsecure(int, SSLSessionCache)}).
 507      */
 508     @Override
 509     public Socket createSocket(String host, int port, InetAddress localAddr, int localPort)
 510             throws IOException {
 511         OpenSSLSocketImpl s = (OpenSSLSocketImpl) getDelegate().createSocket(
 512                 host, port, localAddr, localPort);
 513         s.setNpnProtocols(mNpnProtocols);
 514         s.setAlpnProtocols(mAlpnProtocols);
 515         s.setHandshakeTimeout(mHandshakeTimeoutMillis);
 516         s.setChannelIdPrivateKey(mChannelIdPrivateKey);
 517         if (mSecure) {
 518             verifyHostname(s, host);
 519         }
 520         return s;
 521     }
 522
 523     /**
 524      * {@inheritDoc}
 525      *
 526      * <p>This method verifies the peer's certificate hostname after connecting
 527      * (unless created with {@link #getInsecure(int, SSLSessionCache)}).
 528      */
 529     @Override
 530     public Socket createSocket(String host, int port) throws IOException {
 531         OpenSSLSocketImpl s = (OpenSSLSocketImpl) getDelegate().createSocket(host, port);
 532         s.setNpnProtocols(mNpnProtocols);
 533         s.setAlpnProtocols(mAlpnProtocols);
 534         s.setHandshakeTimeout(mHandshakeTimeoutMillis);
 535         s.setChannelIdPrivateKey(mChannelIdPrivateKey);
 536         if (mSecure) {
 537             verifyHostname(s, host);
 538         }
 539         return s;
 540     }
 541
 542     @Override
 543     public String[] getDefaultCipherSuites() {
 544         return getDelegate().getDefaultCipherSuites();
 545     }
 546
 547     @Override
 548     public String[] getSupportedCipherSuites() {
 549         return getDelegate().getSupportedCipherSuites();
 550     }
 551 }