1 /* 2 * Copyright 2015 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 org.conscrypt; 18 19 import java.io.FileDescriptor; 20 import java.io.IOException; 21 import java.io.InputStream; 22 import java.io.OutputStream; 23 import java.net.InetAddress; 24 import java.net.SocketAddress; 25 import java.net.SocketException; 26 import java.nio.channels.SocketChannel; 27 import java.security.PrivateKey; 28 import java.security.cert.CertificateEncodingException; 29 import java.security.cert.CertificateException; 30 import javax.net.ssl.HandshakeCompletedListener; 31 import javax.net.ssl.SSLException; 32 import javax.net.ssl.SSLParameters; 33 import javax.net.ssl.SSLSession; 34 35 /** 36 * This class delegates all calls to an {@code org.conscrypt.OpenSSLSocketImpl}. 37 * This is to work around code that checks that the socket is an 38 * {@code org.apache.harmony.xnet.provider.jsse.OpenSSLSocketImpl} before 39 * calling methods, such as setting SNI. This is only for Pre-Kitkat devices. 40 * 41 * It delegates all public methods in Socket, SSLSocket, and OpenSSLSocket from 42 * JB. 43 */ 44 public class PreKitKatPlatformOpenSSLSocketImplAdapter 45 extends org.apache.harmony.xnet.provider.jsse.OpenSSLSocketImpl { 46 47 48 private final AbstractConscryptSocket delegate; 49 50 public PreKitKatPlatformOpenSSLSocketImplAdapter(AbstractConscryptSocket delegate) 51 throws IOException { 52 super(null); 53 this.delegate = delegate; 54 } 55 56 // Socket methods. 57 58 @Override 59 @SuppressWarnings("UnsynchronizedOverridesSynchronized") 60 public void close() throws IOException { 61 delegate.close(); 62 } 63 64 @Override 65 public InputStream getInputStream() throws IOException { 66 return delegate.getInputStream(); 67 } 68 69 @Override 70 public int getLocalPort() { 71 return delegate.getLocalPort(); 72 } 73 74 @Override 75 public OutputStream getOutputStream() throws IOException { 76 return delegate.getOutputStream(); 77 } 78 79 @Override 80 public int getPort() { 81 return delegate.getPort(); 82 } 83 84 @Override 85 public void connect(SocketAddress sockaddr, int timeout) throws IOException { 86 delegate.connect(sockaddr, timeout); 87 } 88 89 @Override 90 public void connect(SocketAddress sockaddr) throws IOException { 91 delegate.connect(sockaddr); 92 } 93 94 @Override 95 public void bind(SocketAddress sockaddr) throws IOException { 96 delegate.bind(sockaddr); 97 } 98 99 @Override 100 public SocketAddress getRemoteSocketAddress() { 101 return delegate.getRemoteSocketAddress(); 102 } 103 104 @Override 105 public SocketAddress getLocalSocketAddress() { 106 return delegate.getLocalSocketAddress(); 107 } 108 109 @Override 110 public InetAddress getLocalAddress() { 111 return delegate.getLocalAddress(); 112 } 113 114 @Override 115 public InetAddress getInetAddress() { 116 return delegate.getInetAddress(); 117 } 118 119 @Override 120 public String toString() { 121 return delegate.toString(); 122 } 123 124 @Override 125 public void setSoLinger(boolean on, int linger) throws SocketException { 126 delegate.setSoLinger(on, linger); 127 } 128 129 @Override 130 public void setTcpNoDelay(boolean on) throws SocketException { 131 delegate.setTcpNoDelay(on); 132 } 133 134 @Override 135 public void setReuseAddress(boolean on) throws SocketException { 136 delegate.setReuseAddress(on); 137 } 138 139 @Override 140 public void setKeepAlive(boolean on) throws SocketException { 141 delegate.setKeepAlive(on); 142 } 143 144 @Override 145 public void setTrafficClass(int tos) throws SocketException { 146 delegate.setTrafficClass(tos); 147 } 148 149 @Override 150 @SuppressWarnings("UnsynchronizedOverridesSynchronized") 151 public void setSoTimeout(int to) throws SocketException { 152 delegate.setSoTimeout(to); 153 } 154 155 @Override 156 @SuppressWarnings("UnsynchronizedOverridesSynchronized") 157 public void setSendBufferSize(int size) throws SocketException { 158 delegate.setSendBufferSize(size); 159 } 160 161 @Override 162 @SuppressWarnings("UnsynchronizedOverridesSynchronized") 163 public void setReceiveBufferSize(int size) throws SocketException { 164 delegate.setReceiveBufferSize(size); 165 } 166 167 @Override 168 public boolean getTcpNoDelay() throws SocketException { 169 return delegate.getTcpNoDelay(); 170 } 171 172 @Override 173 public boolean getReuseAddress() throws SocketException { 174 return delegate.getReuseAddress(); 175 } 176 177 @Override 178 public boolean getKeepAlive() throws SocketException { 179 return delegate.getKeepAlive(); 180 } 181 182 @Override 183 @SuppressWarnings("UnsynchronizedOverridesSynchronized") 184 public int getSoTimeout() throws SocketException { 185 return delegate.getSoTimeout(); 186 } 187 188 @Override 189 public int getSoLinger() throws SocketException { 190 return delegate.getSoLinger(); 191 } 192 193 @Override 194 @SuppressWarnings("UnsynchronizedOverridesSynchronized") 195 public int getSendBufferSize() throws SocketException { 196 return delegate.getSendBufferSize(); 197 } 198 199 @Override 200 @SuppressWarnings("UnsynchronizedOverridesSynchronized") 201 public int getReceiveBufferSize() throws SocketException { 202 return delegate.getReceiveBufferSize(); 203 } 204 205 @Override 206 public boolean isConnected() { 207 return delegate.isConnected(); 208 } 209 210 @Override 211 public boolean isClosed() { 212 return delegate.isClosed(); 213 } 214 215 @Override 216 public boolean isBound() { 217 return delegate.isBound(); 218 } 219 220 @Override 221 public boolean isOutputShutdown() { 222 return delegate.isOutputShutdown(); 223 } 224 225 @Override 226 public boolean isInputShutdown() { 227 return delegate.isInputShutdown(); 228 } 229 230 @Override 231 public void shutdownInput() throws IOException { 232 delegate.shutdownInput(); 233 } 234 235 @Override 236 public void shutdownOutput() throws IOException { 237 delegate.shutdownOutput(); 238 } 239 240 @Override 241 public void setOOBInline(boolean oobinline) throws SocketException { 242 delegate.setOOBInline(oobinline); 243 } 244 245 @Override 246 public boolean getOOBInline() throws SocketException { 247 return delegate.getOOBInline(); 248 } 249 250 @Override 251 public int getTrafficClass() throws SocketException { 252 return delegate.getTrafficClass(); 253 } 254 255 @Override 256 public void sendUrgentData(int value) throws IOException { 257 delegate.sendUrgentData(value); 258 } 259 260 @Override 261 public SocketChannel getChannel() { 262 return delegate.getChannel(); 263 } 264 265 @Override 266 public FileDescriptor getFileDescriptor$() { 267 return delegate.getFileDescriptor$(); 268 } 269 270 @Override 271 public void setPerformancePreferences(int connectionTime, int latency, int bandwidth) { 272 delegate.setPerformancePreferences(connectionTime, latency, bandwidth); 273 } 274 275 // SSLSocket methods. 276 277 @Override 278 public String[] getSupportedCipherSuites() { 279 return delegate.getSupportedCipherSuites(); 280 } 281 282 @Override 283 public String[] getEnabledCipherSuites() { 284 return delegate.getEnabledCipherSuites(); 285 } 286 287 @Override 288 public void setEnabledCipherSuites(String[] suites) { 289 delegate.setEnabledCipherSuites(suites); 290 } 291 292 @Override 293 public String[] getSupportedProtocols() { 294 return delegate.getSupportedProtocols(); 295 } 296 @Override 297 public String[] getEnabledProtocols() { 298 return delegate.getEnabledProtocols(); 299 } 300 301 @Override 302 public void setEnabledProtocols(String[] protocols) { 303 delegate.setEnabledProtocols(protocols); 304 } 305 306 @Override 307 public SSLSession getSession() { 308 return delegate.getSession(); 309 } 310 311 @Override 312 public void addHandshakeCompletedListener(HandshakeCompletedListener listener) { 313 delegate.addHandshakeCompletedListener(listener); 314 } 315 316 @Override 317 public void removeHandshakeCompletedListener(HandshakeCompletedListener listener) { 318 delegate.removeHandshakeCompletedListener(listener); 319 } 320 321 @Override 322 @SuppressWarnings("UnsynchronizedOverridesSynchronized") 323 public void startHandshake() throws IOException { 324 delegate.startHandshake(); 325 } 326 327 @Override 328 public void setUseClientMode(boolean mode) { 329 delegate.setUseClientMode(mode); 330 } 331 332 @Override 333 public boolean getUseClientMode() { 334 return delegate.getUseClientMode(); 335 } 336 337 @Override 338 public void setNeedClientAuth(boolean need) { 339 delegate.setNeedClientAuth(need); 340 } 341 342 @Override 343 public void setWantClientAuth(boolean want) { 344 delegate.setWantClientAuth(want); 345 } 346 347 @Override 348 public boolean getNeedClientAuth() { 349 return delegate.getNeedClientAuth(); 350 } 351 352 @Override 353 public boolean getWantClientAuth() { 354 return delegate.getWantClientAuth(); 355 } 356 357 @Override 358 public void setEnableSessionCreation(boolean flag) { 359 delegate.setEnableSessionCreation(flag); 360 } 361 362 @Override 363 public boolean getEnableSessionCreation() { 364 return delegate.getEnableSessionCreation(); 365 } 366 367 @Override 368 public SSLParameters getSSLParameters() { 369 return delegate.getSSLParameters(); 370 } 371 372 @Override 373 public void setSSLParameters(SSLParameters p) { 374 delegate.setSSLParameters(p); 375 } 376 377 // OpenSSLSocket methods. 378 @Override 379 public void clientCertificateRequested(byte[] keyTypeBytes, byte[][] asn1DerEncodedPrincipals) 380 throws CertificateEncodingException, SSLException { 381 throw new RuntimeException("Shouldn't be here!"); 382 } 383 384 @Override 385 public void handshakeCompleted() { 386 throw new RuntimeException("Shouldn't be here!"); 387 } 388 389 @Override 390 public void verifyCertificateChain(byte[][] bytes, String authMethod) 391 throws CertificateException { 392 throw new RuntimeException("Shouldn't be here!"); 393 } 394 395 @Override 396 public void setUseSessionTickets(boolean useSessionTickets) { 397 delegate.setUseSessionTickets(useSessionTickets); 398 } 399 400 @Override 401 public void setHostname(String hostname) { 402 delegate.setHostname(hostname); 403 } 404 405 @Override 406 public void setChannelIdEnabled(boolean enabled) { 407 delegate.setChannelIdEnabled(enabled); 408 } 409 410 @Override 411 public byte[] getChannelId() throws SSLException { 412 return delegate.getChannelId(); 413 } 414 415 @Override 416 public void setChannelIdPrivateKey(PrivateKey privateKey) { 417 delegate.setChannelIdPrivateKey(privateKey); 418 } 419 420 @Override 421 public void setSoWriteTimeout(int writeTimeoutMilliseconds) throws SocketException { 422 delegate.setSoWriteTimeout(writeTimeoutMilliseconds); 423 } 424 425 @Override 426 public int getSoWriteTimeout() throws SocketException { 427 return delegate.getSoWriteTimeout(); 428 } 429 430 @Override 431 public void setHandshakeTimeout(int handshakeTimeoutMilliseconds) throws SocketException { 432 delegate.setHandshakeTimeout(handshakeTimeoutMilliseconds); 433 } 434 435 @Override 436 public byte[] getNpnSelectedProtocol() { 437 return delegate.getNpnSelectedProtocol(); 438 } 439 440 @Override 441 public void setNpnProtocols(byte[] npnProtocols) { 442 delegate.setNpnProtocols(npnProtocols); 443 } 444 445 // These aren't in the Platform's OpenSSLSocketImpl but we have them to support duck typing. 446 447 public byte[] getAlpnSelectedProtocol() { 448 return delegate.getAlpnSelectedProtocol(); 449 } 450 451 public void setAlpnProtocols(byte[] alpnProtocols) { 452 delegate.setAlpnProtocols(alpnProtocols); 453 } 454 } 455