private void processHandshakeFailure(Socket raw) throws Exception { SSLContext context = SSLContext.getInstance("TLS"); context.init(null, new TrustManager[] {UNTRUSTED_TRUST_MANAGER}, new SecureRandom()); SSLSocketFactory sslSocketFactory = context.getSocketFactory(); SSLSocket socket = (SSLSocket) sslSocketFactory.createSocket( raw, raw.getInetAddress().getHostAddress(), raw.getPort(), true); try { socket.startHandshake(); // we're testing a handshake failure throw new AssertionError(); } catch (IOException expected) { } socket.close(); }
public SSLSocket createSSLSocket(Socket socket, byte[] pushbackBytes) throws IOException { SSLSocket sslSocket; if (pushbackBytes != null && pushbackBytes.length > 0) { sslSocket = (SSLSocket) sslContext.getSocketFactory().createSocket( socket, new ByteArrayInputStream(pushbackBytes), true); } else { sslSocket = (SSLSocket) sslContext.getSocketFactory().createSocket( socket, null, socket.getPort(), true); } return configureSSLSocket(sslSocket, false); }
@Override public SSLSocket createSocket(Socket socket) throws SocketException { SSLContext sc; try { sc = SSLContext.getInstance(this.protocol); initSSLContext(sc); } catch (GeneralSecurityException e) { throw new SocketException(e.getMessage()); } try { return (SSLSocket) sc.getSocketFactory() .createSocket(socket, socket.getInetAddress().getHostName(), socket.getPort(), true); } catch (IOException e) { throw new SocketException(e.getMessage()); } }
socket = socketFactory.createSocket(host, port); sslSocket = (SSLSocket) ((SSLSocketFactory)socketFactory).createSocket(socket, host, port, true); sslSocket = (SSLSocket) (getDefaultSSLSocketFactory(trustAll)).createSocket(socket, host, port, true);
@Override public void upgradeToSsl() { if (sslSocket != null) // Already upgraded return; if (verbose) System.out.println("[" + this + "] INFO: Upgrading socket to SSL."); try { // Use most secure implementation of SSL available now. // JVM will try to negotiate TLS1.2, then will fallback to TLS1.0, if // TLS1.2 is not supported. SSLContext sslContext = SSLUtils.getSSLContext(); // Trust all certificates (FIXME: insecure) sslContext.init(null, new TrustManager[] {new TrustAllX509TrustManager(sslState)}, null); SSLSocketFactory sslSocketFactory = new SecureSSLSocketFactory(sslContext); sslSocket = (SSLSocket)sslSocketFactory.createSocket(socket, address.getHostName(), address.getPort(), true); sslSocket.setEnabledProtocols(SSLUtils.getSupportedProtocols(sslSocket.getEnabledProtocols())); sslSocket.startHandshake(); InputStream sis = sslSocket.getInputStream(); source.setInputStream(sis); OutputStream sos = sslSocket.getOutputStream(); sink.setOutputStream(sos); } catch (Exception e) { throw new RuntimeException("Cannot upgrade socket to SSL: " + e.getMessage(), e); } }
_proxy = _sslContext.getSocketFactory().createSocket(_proxy, host, port, true); else _proxy = ((SSLSocketFactory) SSLSocketFactory.getDefault()).createSocket(_proxy, host, port, true); if (_log.shouldLog(Log.DEBUG)) _log.debug(_proxyType + " proxy headers read completely"); _proxy = _sslContext.getSocketFactory().createSocket(host, port); else _proxy = SSLSocketFactory.getDefault().createSocket(host, port); if (_fetchHeaderTimeout > 0) { _proxy.setSoTimeout(_fetchHeaderTimeout);
public Socket createSocket(String host, int port) throws IOException { try { SSLContext ctx = SSLContext.getInstance("TLS"); ctx.init(null, new TrustManager[] {new TrustAllSSL()}, null); SSLSocketFactory factory = ctx.getSocketFactory(); return factory.createSocket(host, port); } catch(Exception e) { throw new IOException(e); } } }
public Socket createSSLSocket(String host, int port) throws IOException { InetAddress address = InetAddress.getByName(host); javax.net.ssl.SSLSocketFactory socketFactory = this.clientSSLContext.getSocketFactory(); return socketFactory.createSocket(address, port); }
return makeSocketSafe(delegate.createSocket(s, host, port, autoClose)); return makeSocketSafe(delegate.createSocket(host, port)); return makeSocketSafe(delegate.createSocket(host, port, localHost, localPort)); return makeSocketSafe(delegate.createSocket(host, port));
SSLContext sslContext = SSLContext.getInstance("TLS"); sslContext.init(null, new TrustManager[] { tm }, null); return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose); return sslContext.getSocketFactory().createSocket();
/** * Creates a new SSL Socket. * * @param host the host to connect to * @param port the port to connect to * @return the SSL Socket * @throws IOException thrown if the creation fails */ @Override public Socket createSocket(InetAddress host, int port) throws IOException { final SSLSocketFactory factory = sslCtxt.getSocketFactory(); final SSLSocket ss = (SSLSocket) factory.createSocket(host, port); ss.setEnabledProtocols(protocols); return ss; }
return makeSocketSafe(delegate.createSocket(s, host, port, autoClose)); return makeSocketSafe(delegate.createSocket(host, port)); return makeSocketSafe(delegate.createSocket(host, port, localHost, localPort)); return makeSocketSafe(delegate.createSocket(host, port));
@Override public Socket createSocket(Socket socket, String host, int port, String clientCertificateAlias) throws NoSuchAlgorithmException, KeyManagementException, MessagingException, IOException { TrustManager[] trustManagers = new TrustManager[] { new VeryTrustingTrustManager(serverCertificate) }; SSLContext sslContext = SSLContext.getInstance("TLS"); sslContext.init(null, trustManagers, null); SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory(); return sslSocketFactory.createSocket( socket, socket.getInetAddress().getHostAddress(), socket.getPort(), true); } }
/** * Creates a new SSL Socket. * * @param host the host to connect to * @param port the port to connect to * @return the SSL Socket * @throws IOException thrown if the creation fails */ @Override public Socket createSocket(String host, int port) throws IOException { final SSLSocketFactory factory = sslCtxt.getSocketFactory(); final SSLSocket ss = (SSLSocket) factory.createSocket(host, port); ss.setEnabledProtocols(protocols); return ss; }
return makeSocketSafe(delegate.createSocket(s, host, port, autoClose)); return makeSocketSafe(delegate.createSocket(host, port)); return makeSocketSafe(delegate.createSocket(host, port, localHost, localPort)); return makeSocketSafe(delegate.createSocket(host, port));
protected SSLContext sslContext = SSLContext.getInstance("TLS"); sslContext.init(null, new TrustManager[]{new AdditionalKeyStoresTrustManager(keyStore)}, null); return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose); return sslContext.getSocketFactory().createSocket();
public SSLSocket createSSLSocket() throws IOException { return configureSSLSocket((SSLSocket) sslContext.getSocketFactory().createSocket(), true); }
socket = ((SSLSocketFactory)factory).createSocket(tempsocket, host, port, true); } else { socket = factory.createSocket(); socket.connect(sockaddr, conTimeout*1000);
SSLContext sslContext = SSLContext.getInstance("TLS"); sslContext.init(null, new TrustManager[] { tm }, null); return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose); return sslContext.getSocketFactory().createSocket();
/** * Creates an SSL Socket. * * @param s the base socket * @param host the host * @param port the port * @param autoClose if the socket should auto-close * @return the SSL Socket * @throws IOException thrown if the creation fails */ @Override public Socket createSocket(Socket s, String host, int port, boolean autoClose) throws IOException { final SSLSocketFactory factory = sslCtxt.getSocketFactory(); final SSLSocket ss = (SSLSocket) factory.createSocket(s, host, port, autoClose); ss.setEnabledProtocols(protocols); return ss; }