undefect. CWE-407 — 63 sites patched across 27 ecosystems
Authors: russell@unturf.com · brackishbert@gmail.com · foxhop.net · TimeHexOn.com Patches, unit tests, benchmarks, whitepaper, and outreach briefs. Public domain — no copyright claimed. Use freely.
This commit is contained in:
commit
0a580b313d
70422 changed files with 17213626 additions and 0 deletions
341
test/jdk/java/net/Socket/HttpProxy.java
Normal file
341
test/jdk/java/net/Socket/HttpProxy.java
Normal file
|
|
@ -0,0 +1,341 @@
|
|||
/*
|
||||
* Copyright (c) 2010, 2022, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 6370908 8220663
|
||||
* @library /test/lib
|
||||
* @summary Add support for HTTP_CONNECT proxy in Socket class.
|
||||
* This test uses the wildcard address and is susceptible to fail intermittently.
|
||||
* @key intermittent
|
||||
* @run main HttpProxy
|
||||
* @run main/othervm -Djava.net.preferIPv4Stack=true HttpProxy
|
||||
* @run main/othervm -Djava.net.preferIPv6Addresses=true HttpProxy
|
||||
*/
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.OutputStream;
|
||||
import java.io.PrintWriter;
|
||||
import java.net.InetAddress;
|
||||
import java.net.InetSocketAddress;
|
||||
import java.net.Proxy;
|
||||
import java.net.ServerSocket;
|
||||
import java.net.Socket;
|
||||
import java.net.SocketAddress;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import static java.lang.System.out;
|
||||
import jdk.test.lib.net.HttpHeaderParser;
|
||||
import jdk.test.lib.net.IPSupport;
|
||||
|
||||
public class HttpProxy {
|
||||
final String proxyHost;
|
||||
final int proxyPort;
|
||||
static final int SO_TIMEOUT = 15000;
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
IPSupport.throwSkippedExceptionIfNonOperational();
|
||||
|
||||
String host;
|
||||
int port;
|
||||
ConnectProxyTunnelServer proxy = null;
|
||||
if (args.length == 0) {
|
||||
// Start internal proxy
|
||||
proxy = new ConnectProxyTunnelServer();
|
||||
proxy.start();
|
||||
host = InetAddress.getLoopbackAddress().getHostAddress();
|
||||
port = proxy.getLocalPort();
|
||||
out.println("Running with internal proxy: " + host + ":" + port);
|
||||
} else if (args.length == 2) {
|
||||
host = args[0];
|
||||
port = Integer.valueOf(args[1]);
|
||||
out.println("Running against specified proxy server: " + host + ":" + port);
|
||||
} else {
|
||||
System.err.println("Usage: java HttpProxy [<proxy host> <proxy port>]");
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
HttpProxy p = new HttpProxy(host, port);
|
||||
p.test();
|
||||
} finally {
|
||||
if (proxy != null)
|
||||
proxy.close();
|
||||
}
|
||||
}
|
||||
|
||||
public HttpProxy(String proxyHost, int proxyPort) {
|
||||
this.proxyHost = proxyHost;
|
||||
this.proxyPort = proxyPort;
|
||||
}
|
||||
|
||||
static boolean canUseIPv6() {
|
||||
return IPSupport.hasIPv6() && !IPSupport.preferIPv4Stack();
|
||||
}
|
||||
|
||||
void test() throws Exception {
|
||||
InetSocketAddress proxyAddress = new InetSocketAddress(proxyHost, proxyPort);
|
||||
Proxy httpProxy = new Proxy(Proxy.Type.HTTP, proxyAddress);
|
||||
|
||||
// Wildcard address is needed here
|
||||
try (ServerSocket ss = new ServerSocket(0)) {
|
||||
List<InetSocketAddress> externalAddresses = new ArrayList<>();
|
||||
externalAddresses.add(
|
||||
new InetSocketAddress(InetAddress.getLocalHost(), ss.getLocalPort()));
|
||||
|
||||
if (canUseIPv6()) {
|
||||
byte[] bytes = new byte[] {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
|
||||
var address = InetAddress.getByAddress(bytes);
|
||||
externalAddresses.add(
|
||||
new InetSocketAddress(address, ss.getLocalPort()));
|
||||
}
|
||||
|
||||
for (SocketAddress externalAddress : externalAddresses) {
|
||||
try (Socket sock = new Socket(httpProxy)) {
|
||||
sock.setSoTimeout(SO_TIMEOUT);
|
||||
sock.setTcpNoDelay(false);
|
||||
|
||||
out.println("Trying to connect to server socket on " + externalAddress);
|
||||
sock.connect(externalAddress);
|
||||
try (Socket externalSock = ss.accept()) {
|
||||
// perform some simple checks
|
||||
check(sock.isBound(), "Socket is not bound");
|
||||
check(sock.isConnected(), "Socket is not connected");
|
||||
check(!sock.isClosed(), "Socket should not be closed");
|
||||
check(sock.getSoTimeout() == SO_TIMEOUT,
|
||||
"Socket should have a previously set timeout");
|
||||
check(sock.getTcpNoDelay() == false, "NODELAY should be false");
|
||||
|
||||
simpleDataExchange(sock, externalSock);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void check(boolean condition, String message) {
|
||||
if (!condition) out.println(message);
|
||||
}
|
||||
|
||||
static Exception unexpected(Exception e) {
|
||||
out.println("Unexpected Exception: " + e);
|
||||
e.printStackTrace();
|
||||
return e;
|
||||
}
|
||||
|
||||
// performs a simple exchange of data between the two sockets
|
||||
// and throws an exception if there is any problem.
|
||||
void simpleDataExchange(Socket s1, Socket s2) throws Exception {
|
||||
try (final InputStream i1 = s1.getInputStream();
|
||||
final InputStream i2 = s2.getInputStream();
|
||||
final OutputStream o1 = s1.getOutputStream();
|
||||
final OutputStream o2 = s2.getOutputStream()) {
|
||||
startSimpleWriter("simpleWriter1", o1, 100);
|
||||
startSimpleWriter("simpleWriter2", o2, 200);
|
||||
simpleRead(i2, 100);
|
||||
simpleRead(i1, 200);
|
||||
}
|
||||
}
|
||||
|
||||
void startSimpleWriter(String threadName, final OutputStream os, final int start) {
|
||||
(new Thread(new Runnable() {
|
||||
public void run() {
|
||||
try { simpleWrite(os, start); }
|
||||
catch (Exception e) {unexpected(e); }
|
||||
finally { out.println(threadName + ": done"); }
|
||||
}}, threadName)).start();
|
||||
}
|
||||
|
||||
void simpleWrite(OutputStream os, int start) throws Exception {
|
||||
byte b[] = new byte[2];
|
||||
for (int i=start; i<start+100; i++) {
|
||||
b[0] = (byte) (i / 256);
|
||||
b[1] = (byte) (i % 256);
|
||||
os.write(b);
|
||||
}
|
||||
out.println("Wrote " + start + " -> " + (start + 100));
|
||||
}
|
||||
|
||||
void simpleRead(InputStream is, int start) throws Exception {
|
||||
byte b[] = new byte [2];
|
||||
for (int i=start; i<start+100; i++) {
|
||||
int x = is.read(b);
|
||||
if (x == 1)
|
||||
x += is.read(b,1,1);
|
||||
if (x!=2)
|
||||
throw new Exception("read error");
|
||||
int r = bytes(b[0], b[1]);
|
||||
if (r != i)
|
||||
throw new Exception("read " + r + " expected " +i);
|
||||
}
|
||||
out.println("Read " + start + " -> " + (start + 100));
|
||||
}
|
||||
|
||||
int bytes(byte b1, byte b2) {
|
||||
int i1 = (int)b1 & 0xFF;
|
||||
int i2 = (int)b2 & 0xFF;
|
||||
return i1 * 256 + i2;
|
||||
}
|
||||
|
||||
static class ConnectProxyTunnelServer extends Thread implements AutoCloseable {
|
||||
|
||||
private final ServerSocket ss;
|
||||
private volatile boolean closed;
|
||||
|
||||
public ConnectProxyTunnelServer() throws IOException {
|
||||
ss = new ServerSocket(0, 0, InetAddress.getLoopbackAddress());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
try {
|
||||
while (!closed) {
|
||||
try (Socket clientSocket = ss.accept()) {
|
||||
processRequest(clientSocket);
|
||||
}
|
||||
}
|
||||
} catch (Exception e) {
|
||||
if (!closed) {
|
||||
out.println("Proxy Failed: " + e);
|
||||
e.printStackTrace();
|
||||
}
|
||||
} finally {
|
||||
if (!closed)
|
||||
try { ss.close(); } catch (IOException x) { unexpected(x); }
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the port on which the proxy is accepting connections.
|
||||
*/
|
||||
public int getLocalPort() {
|
||||
return ss.getLocalPort();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void close() throws Exception {
|
||||
closed = true;
|
||||
ss.close();
|
||||
}
|
||||
|
||||
/*
|
||||
* Processes the CONNECT request
|
||||
*/
|
||||
private void processRequest(Socket clientSocket) throws Exception {
|
||||
HttpHeaderParser mheader = new HttpHeaderParser(clientSocket.getInputStream());
|
||||
String statusLine = mheader.getRequestDetails();
|
||||
|
||||
if (!statusLine.startsWith("CONNECT")) {
|
||||
out.println("proxy server: processes only "
|
||||
+ "CONNECT method requests, received: "
|
||||
+ statusLine);
|
||||
return;
|
||||
}
|
||||
|
||||
// retrieve the host and port info from the status-line
|
||||
InetSocketAddress serverAddr = getConnectInfo(statusLine);
|
||||
out.println("Proxy serving CONNECT request to " + serverAddr);
|
||||
|
||||
//open socket to the server
|
||||
try (Socket serverSocket = new Socket(serverAddr.getAddress(),
|
||||
serverAddr.getPort())) {
|
||||
Forwarder clientFW = new Forwarder(clientSocket.getInputStream(),
|
||||
serverSocket.getOutputStream());
|
||||
Thread clientForwarderThread = new Thread(clientFW, "ClientForwarder");
|
||||
clientForwarderThread.start();
|
||||
send200(clientSocket);
|
||||
Forwarder serverFW = new Forwarder(serverSocket.getInputStream(),
|
||||
clientSocket.getOutputStream());
|
||||
serverFW.run();
|
||||
clientForwarderThread.join();
|
||||
}
|
||||
}
|
||||
|
||||
private void send200(Socket clientSocket) throws IOException {
|
||||
OutputStream out = clientSocket.getOutputStream();
|
||||
PrintWriter pout = new PrintWriter(out);
|
||||
|
||||
pout.println("HTTP/1.1 200 OK");
|
||||
pout.println();
|
||||
pout.flush();
|
||||
}
|
||||
|
||||
/*
|
||||
* This method retrieves the hostname and port of the tunnel destination
|
||||
* from the request line.
|
||||
* @param connectStr
|
||||
* of the form: <i>CONNECT server-name:server-port HTTP/1.x</i>
|
||||
*/
|
||||
static InetSocketAddress getConnectInfo(String connectStr)
|
||||
throws Exception
|
||||
{
|
||||
try {
|
||||
int starti = connectStr.indexOf(' ');
|
||||
int endi = connectStr.lastIndexOf(' ');
|
||||
String connectInfo = connectStr.substring(starti+1, endi).trim();
|
||||
// retrieve server name and port
|
||||
endi = connectInfo.lastIndexOf(':');
|
||||
String name = connectInfo.substring(0, endi);
|
||||
|
||||
if (name.contains(":")) {
|
||||
if (!(name.startsWith("[") && name.endsWith("]"))) {
|
||||
throw new IOException("Invalid host:" + name);
|
||||
}
|
||||
name = name.substring(1, name.length() - 1);
|
||||
}
|
||||
int port = Integer.parseInt(connectInfo.substring(endi+1));
|
||||
return new InetSocketAddress(name, port);
|
||||
} catch (Exception e) {
|
||||
out.println("Proxy received a request: " + connectStr);
|
||||
throw unexpected(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Reads from the given InputStream and writes to the given OutputStream */
|
||||
static class Forwarder implements Runnable
|
||||
{
|
||||
private final InputStream in;
|
||||
private final OutputStream os;
|
||||
|
||||
Forwarder(InputStream in, OutputStream os) {
|
||||
this.in = in;
|
||||
this.os = os;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
try {
|
||||
byte[] ba = new byte[1024];
|
||||
int count;
|
||||
while ((count = in.read(ba)) != -1) {
|
||||
os.write(ba, 0, count);
|
||||
}
|
||||
} catch (IOException e) {
|
||||
unexpected(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue