commit 096eae705baeaa05e703efbdfc0cd52b965699cb
Author: Nathan Freitas <[email protected]>
Date: Sat Feb 14 01:54:56 2015 -0500
implementing http server for meek-client VPN bypass
---
src/org/torproject/android/service/TorService.java | 16 +-
src/org/torproject/android/vpn/HttpProxy.java | 606 ++++++++++++++++++++
.../torproject/android/vpn/OrbotVpnService.java | 25 +-
3 files changed, 633 insertions(+), 14 deletions(-)
diff --git a/src/org/torproject/android/service/TorService.java
b/src/org/torproject/android/service/TorService.java
index 81fdf90..01fa339 100644
--- a/src/org/torproject/android/service/TorService.java
+++ b/src/org/torproject/android/service/TorService.java
@@ -2120,9 +2120,9 @@ public class TorService extends Service implements
TorServiceConstants, TorConst
{
if (mUseVPN) //set the proxy here if we aren't using a bridge
{
- String proxyType = "socks5";
- String proxyHost = "127.0.0.1";
- int proxyPort = 9999;
+ String proxyType = "http";//"socks5";
+ String proxyHost = "10.0.0.1";
+ int proxyPort = 8888;//9999;
updateConfiguration(proxyType + "Proxy", proxyHost + ':' +
proxyPort, false);
}
@@ -2244,11 +2244,11 @@ public class TorService extends Service implements
TorServiceConstants, TorConst
if (mUseVPN)
{
- proxyType = "socks5";
- String proxyHost = "127.0.0.1";
- int proxyPort = 9999;
-
- proxyBridge = " proxyurl=" + proxyType + "://" +
proxyHost + ':' + proxyPort;
+ proxyType = "http"; //"socks5";
+ String proxyHost = "10.0.0.1";
+ int proxyPort = 8888; //9999;
+
+ proxyBridge = " proxy=" + proxyType + "://" + proxyHost
+ ':' + proxyPort;
}
else if (proxyType != null && proxyType.length() > 0)
diff --git a/src/org/torproject/android/vpn/HttpProxy.java
b/src/org/torproject/android/vpn/HttpProxy.java
new file mode 100644
index 0000000..617788b
--- /dev/null
+++ b/src/org/torproject/android/vpn/HttpProxy.java
@@ -0,0 +1,606 @@
+package org.torproject.android.vpn;
+/* <!-- in case someone opens this in a browser... --> <pre> */
+/*
+ * This is a simple multi-threaded Java proxy server
+ * for HTTP requests (HTTPS doesn't seem to work, because
+ * the CONNECT requests aren't always handled properly).
+ * I implemented the class as a thread so you can call it
+ * from other programs and kill it, if necessary (by using
+ * the closeSocket() method).
+ *
+ * We'll call this the 1.1 version of this class. All I
+ * changed was to separate the HTTP header elements with
+ * \r\n instead of just \n, to comply with the official
+ * HTTP specification.
+ *
+ * This can be used either as a direct proxy to other
+ * servers, or as a forwarding proxy to another proxy
+ * server. This makes it useful if you want to monitor
+ * traffic going to and from a proxy server (for example,
+ * you can run this on your local machine and set the
+ * fwdServer and fwdPort to a real proxy server, and then
+ * tell your browser to use "localhost" as the proxy, and
+ * you can watch the browser traffic going in and out).
+ *
+ * One limitation of this implementation is that it doesn't
+ * close the ProxyThread socket if the client disconnects
+ * or the server never responds, so you could end up with
+ * a bunch of loose threads running amuck and waiting for
+ * connections. As a band-aid, you can set the server socket
+ * to timeout after a certain amount of time (use the
+ * setTimeout() method in the ProxyThread class), although
+ * this can cause false timeouts if a remote server is simply
+ * slow to respond.
+ *
+ * Another thing is that it doesn't limit the number of
+ * socket threads it will create, so if you use this on a
+ * really busy machine that processed a bunch of requests,
+ * you may have problems. You should use thread pools if
+ * you're going to try something like this in a "real"
+ * application.
+ *
+ * Note that if you're using the "main" method to run this
+ * by itself and you don't need the debug output, it will
+ * run a bit faster if you pipe the std output to 'nul'.
+ *
+ * You may use this code as you wish, just don't pretend
+ * that you wrote it yourself, and don't hold me liable for
+ * anything that it does or doesn't do. If you're feeling
+ * especially honest, please include a link to nsftools.com
+ * along with the code. Thanks, and good luck.
+ *
+ * Julian Robichaux -- http://www.nsftools.com
+ */
+import java.io.*;
+import java.net.*;
+import java.nio.channels.SocketChannel;
+import java.lang.reflect.Array;
+
+import android.net.VpnService;
+
+public class HttpProxy extends Thread
+{
+ public static final int DEFAULT_PORT = 8080;
+
+ private ServerSocket server = null;
+ private int thisPort = DEFAULT_PORT;
+ private String fwdServer = "";
+ private int fwdPort = 0;
+ private int ptTimeout = ProxyThread.DEFAULT_TIMEOUT;
+ private int debugLevel = 0;
+ private PrintStream debugOut = System.out;
+
+ public static VpnService vpnService;
+
+ /* here's a main method, in case you want to run this by itself */
+ public static void main (String args[])
+ {
+ int port = 0;
+ String fwdProxyServer = "";
+ int fwdProxyPort = 0;
+
+ if (args.length == 0)
+ {
+ System.err.println("USAGE: java HttpProxy <port number>
[<fwd proxy> <fwd port>]");
+ System.err.println(" <port number> the port this
service listens on");
+ System.err.println(" <fwd proxy> optional proxy
server to forward requests to");
+ System.err.println(" <fwd port> the port that the
optional proxy server is on");
+ System.err.println("\nHINT: if you don't want to see
all the debug information flying by,");
+ System.err.println("you can pipe the output to a file
or to 'nul' using \">\". For example:");
+ System.err.println(" to send output to the file
prox.txt: java HttpProxy 8080 > prox.txt");
+ System.err.println(" to make the output go away: java
HttpProxy 8080 > nul");
+ return;
+ }
+
+ // get the command-line parameters
+ port = Integer.parseInt(args[0]);
+ if (args.length > 2)
+ {
+ fwdProxyServer = args[1];
+ fwdProxyPort = Integer.parseInt(args[2]);
+ }
+
+ // create and start the HttpProxy thread, using a 20 second
timeout
+ // value to keep the threads from piling up too much
+ System.err.println(" ** Starting HttpProxy on port " + port +
". Press CTRL-C to end. **\n");
+ HttpProxy jp = new HttpProxy(port, fwdProxyServer,
fwdProxyPort, 20);
+ jp.setDebug(1, System.out); // or set the debug
level to 2 for tons of output
+ jp.start();
+
+ // run forever; if you were calling this class from another
+ // program and you wanted to stop the HttpProxy thread at some
+ // point, you could write a loop that waits for a certain
+ // condition and then calls HttpProxy.closeSocket() to kill
+ // the running HttpProxy thread
+ while (true)
+ {
+ try { Thread.sleep(3000); } catch (Exception e) {}
+ }
+
+ // if we ever had a condition that stopped the loop above,
+ // we'd want to do this to kill the running thread
+ //jp.closeSocket();
+ //return;
+ }
+
+
+ /* the proxy server just listens for connections and creates
+ * a new thread for each connection attempt (the ProxyThread
+ * class really does all the work)
+ */
+ public HttpProxy (int port)
+ {
+ thisPort = port;
+ }
+
+ public HttpProxy (int port, String proxyServer, int proxyPort)
+ {
+ thisPort = port;
+ fwdServer = proxyServer;
+ fwdPort = proxyPort;
+ }
+
+ public HttpProxy (int port, String proxyServer, int proxyPort, int
timeout)
+ {
+ thisPort = port;
+ fwdServer = proxyServer;
+ fwdPort = proxyPort;
+ ptTimeout = timeout;
+ }
+
+ public static void setVpnService (final VpnService v)
+ {
+ vpnService = v;
+ }
+
+ /* allow the user to decide whether or not to send debug
+ * output to the console or some other PrintStream
+ */
+ public void setDebug (int level, PrintStream out)
+ {
+ debugLevel = level;
+ debugOut = out;
+ }
+
+
+ /* get the port that we're supposed to be listening on
+ */
+ public int getPort ()
+ {
+ return thisPort;
+ }
+
+
+ /* return whether or not the socket is currently open
+ */
+ public boolean isRunning ()
+ {
+ if (server == null)
+ return false;
+ else
+ return true;
+ }
+
+
+ /* closeSocket will close the open ServerSocket; use this
+ * to halt a running HttpProxy thread
+ */
+ public void closeSocket ()
+ {
+ try {
+ // close the open server socket
+ server.close();
+ // send it a message to make it stop waiting immediately
+ // (not really necessary)
+ /*Socket s = new Socket("localhost", thisPort);
+ OutputStream os = s.getOutputStream();
+ os.write((byte)0);
+ os.close();
+ s.close();*/
+ } catch(Exception e) {
+ if (debugLevel > 0)
+ debugOut.println(e);
+ }
+
+ server = null;
+ }
+
+
+ public void run()
+ {
+ try {
+ // create a server socket, and loop forever listening
for
+ // client connections
+ server = new ServerSocket(thisPort);
+ if (debugLevel > 0)
+ debugOut.println("Started HttpProxy on port " +
thisPort);
+
+ while (true)
+ {
+ Socket client = server.accept();
+ HttpProxy.vpnService.protect(client);
+ ProxyThread t = new ProxyThread(client,
fwdServer, fwdPort);
+ t.setDebug(debugLevel, debugOut);
+ t.setTimeout(ptTimeout);
+ t.start();
+ }
+ } catch (Exception e) {
+ if (debugLevel > 0)
+ debugOut.println("HttpProxy Thread error: " +
e);
+ }
+
+ closeSocket();
+ }
+
+}
+
+
+/*
+ * The ProxyThread will take an HTTP request from the client
+ * socket and send it to either the server that the client is
+ * trying to contact, or another proxy server
+ */
+class ProxyThread extends Thread
+{
+ private Socket pSocket;
+ private String fwdServer = "";
+ private int fwdPort = 0;
+ private int debugLevel = 0;
+ private PrintStream debugOut = System.out;
+
+ // the socketTimeout is used to time out the connection to
+ // the remote server after a certain period of inactivity;
+ // the value is in milliseconds -- use zero if you don't want
+ // a timeout
+ public static final int DEFAULT_TIMEOUT = 20 * 1000;
+ private int socketTimeout = DEFAULT_TIMEOUT;
+
+
+ public ProxyThread(Socket s)
+ {
+ pSocket = s;
+ }
+
+ public ProxyThread(Socket s, String proxy, int port)
+ {
+ pSocket = s;
+ fwdServer = proxy;
+ fwdPort = port;
+ }
+
+
+ public void setTimeout (int timeout)
+ {
+ // assume that the user will pass the timeout value
+ // in seconds (because that's just more intuitive)
+ socketTimeout = timeout * 1000;
+ }
+
+
+ public void setDebug (int level, PrintStream out)
+ {
+ debugLevel = level;
+ debugOut = out;
+ }
+
+
+ public void run()
+ {
+ try
+ {
+ long startTime = System.currentTimeMillis();
+
+ // client streams (make sure you're using streams that
use
+ // byte arrays, so things like GIF and JPEG files and
file
+ // downloads will transfer properly)
+ BufferedInputStream clientIn = new
BufferedInputStream(pSocket.getInputStream());
+ BufferedOutputStream clientOut = new
BufferedOutputStream(pSocket.getOutputStream());
+
+ // the socket to the remote server
+ Socket server = null;
+
+ // other variables
+ byte[] request = null;
+ byte[] response = null;
+ int requestLength = 0;
+ int responseLength = 0;
+ int pos = -1;
+ StringBuffer host = new StringBuffer("");
+ String hostName = "";
+ int hostPort = 80;
+
+ // get the header info (the web browser won't
disconnect after
+ // it's sent a request, so make sure the
waitForDisconnect
+ // parameter is false)
+ request = getHTTPData(clientIn, host, false);
+ requestLength = Array.getLength(request);
+
+ // separate the host name from the host port, if
necessary
+ // (like if it's "servername:8000")
+ hostName = host.toString();
+ pos = hostName.indexOf(":");
+ if (pos > 0)
+ {
+ try { hostPort =
Integer.parseInt(hostName.substring(pos + 1));
+ } catch (Exception e) { }
+ hostName = hostName.substring(0, pos);
+ }
+
+ // either forward this request to another proxy server
or
+ // send it straight to the Host
+ try
+ {
+ server = SocketChannel.open().socket();
+
+ if ((null != server) && (null !=
HttpProxy.vpnService)) {
+ HttpProxy.vpnService.protect(server);
+ }
+
+ if ((fwdServer.length() > 0) && (fwdPort > 0))
+ {
+ //server = new Socket(fwdServer,
fwdPort);
+ server.connect(new
InetSocketAddress(fwdServer, fwdPort));
+
+ } else {
+ //server = new Socket(hostName,
hostPort);
+ server.connect(new
InetSocketAddress(hostName, hostPort));
+
+ }
+
+
+ HttpProxy.vpnService.protect(server);
+
+ } catch (Exception e) {
+ // tell the client there was an error
+ String errMsg = "HTTP/1.0 500\nContent Type:
text/plain\n\n" +
+ "Error
connecting to the server:\n" + e + "\n";
+ clientOut.write(errMsg.getBytes(), 0,
errMsg.length());
+ }
+
+ if (server != null)
+ {
+ server.setSoTimeout(socketTimeout);
+ BufferedInputStream serverIn = new
BufferedInputStream(server.getInputStream());
+ BufferedOutputStream serverOut = new
BufferedOutputStream(server.getOutputStream());
+
+ // send the request out
+ serverOut.write(request, 0, requestLength);
+ serverOut.flush();
+
+ // and get the response; if we're not at a
debug level that
+ // requires us to return the data in the
response, just stream
+ // it back to the client to save ourselves from
having to
+ // create and destroy an unnecessary byte
array. Also, we
+ // should set the waitForDisconnect parameter
to 'true',
+ // because some servers (like Google) don't
always set the
+ // Content-Length header field, so we have to
listen until
+ // they decide to disconnect (or the connection
times out).
+ if (debugLevel > 1)
+ {
+ response = getHTTPData(serverIn, true);
+ responseLength =
Array.getLength(response);
+ } else {
+ responseLength =
streamHTTPData(serverIn, clientOut, true);
+ }
+
+ serverIn.close();
+ serverOut.close();
+ }
+
+ // send the response back to the client, if we haven't
already
+ if (debugLevel > 1)
+ clientOut.write(response, 0, responseLength);
+
+ // if the user wants debug info, send them debug info;
however,
+ // keep in mind that because we're using threads, the
output won't
+ // necessarily be synchronous
+ if (debugLevel > 0)
+ {
+ long endTime = System.currentTimeMillis();
+ debugOut.println("Request from " +
pSocket.getInetAddress().getHostAddress() +
+ " on
Port " + pSocket.getLocalPort() +
+ " to
host " + hostName + ":" + hostPort +
+ "\n ("
+ requestLength + " bytes sent, " +
+
responseLength + " bytes returned, " +
+
Long.toString(endTime - startTime) + " ms elapsed)");
+ debugOut.flush();
+ }
+ if (debugLevel > 1)
+ {
+ debugOut.println("REQUEST:\n" + (new
String(request)));
+ debugOut.println("RESPONSE:\n" + (new
String(response)));
+ debugOut.flush();
+ }
+
+ // close all the client streams so we can listen again
+ clientOut.close();
+ clientIn.close();
+ pSocket.close();
+ } catch (Exception e) {
+ if (debugLevel > 0)
+ debugOut.println("Error in ProxyThread: " + e);
+ //e.printStackTrace();
+ }
+
+ }
+
+
+ private byte[] getHTTPData (InputStream in, boolean waitForDisconnect)
+ {
+ // get the HTTP data from an InputStream, and return it as
+ // a byte array
+ // the waitForDisconnect parameter tells us what to do in case
+ // the HTTP header doesn't specify the Content-Length of the
+ // transmission
+ StringBuffer foo = new StringBuffer("");
+ return getHTTPData(in, foo, waitForDisconnect);
+ }
+
+
+ private byte[] getHTTPData (InputStream in, StringBuffer host, boolean
waitForDisconnect)
+ {
+ // get the HTTP data from an InputStream, and return it as
+ // a byte array, and also return the Host entry in the header,
+ // if it's specified -- note that we have to use a StringBuffer
+ // for the 'host' variable, because a String won't return any
+ // information when it's used as a parameter like that
+ ByteArrayOutputStream bs = new ByteArrayOutputStream();
+ streamHTTPData(in, bs, host, waitForDisconnect);
+ return bs.toByteArray();
+ }
+
+
+ private int streamHTTPData (InputStream in, OutputStream out, boolean
waitForDisconnect)
+ {
+ StringBuffer foo = new StringBuffer("");
+ return streamHTTPData(in, out, foo, waitForDisconnect);
+ }
+
+ private int streamHTTPData (InputStream in, OutputStream out,
+
StringBuffer host, boolean waitForDisconnect)
+ {
+ // get the HTTP data from an InputStream, and send it to
+ // the designated OutputStream
+ StringBuffer header = new StringBuffer("");
+ String data = "";
+ int responseCode = 200;
+ int contentLength = 0;
+ int pos = -1;
+ int byteCount = 0;
+
+ try
+ {
+ // get the first line of the header, so we know the
response code
+ data = readLine(in);
+ if (data != null)
+ {
+ header.append(data + "\r\n");
+ pos = data.indexOf(" ");
+ if ((data.toLowerCase().startsWith("http")) &&
+ (pos >= 0) && (data.indexOf(" ", pos+1)
>= 0))
+ {
+ String rcString = data.substring(pos+1,
data.indexOf(" ", pos+1));
+ try
+ {
+ responseCode =
Integer.parseInt(rcString);
+ } catch (Exception e) {
+ if (debugLevel > 0)
+ debugOut.println("Error
parsing response code " + rcString);
+ }
+ }
+ }
+
+ // get the rest of the header info
+ while ((data = readLine(in)) != null)
+ {
+ // the header ends at the first blank line
+ if (data.length() == 0)
+ break;
+ header.append(data + "\r\n");
+
+ // check for the Host header
+ pos = data.toLowerCase().indexOf("host:");
+ if (pos >= 0)
+ {
+ host.setLength(0);
+ host.append(data.substring(pos +
5).trim());
+ }
+
+ // check for the Content-Length header
+ pos =
data.toLowerCase().indexOf("content-length:");
+ if (pos >= 0)
+ contentLength =
Integer.parseInt(data.substring(pos + 15).trim());
+ }
+
+ // add a blank line to terminate the header info
+ header.append("\r\n");
+
+ // convert the header to a byte array, and write it to
our stream
+ out.write(header.toString().getBytes(), 0,
header.length());
+
+ // if the header indicated that this was not a 200
response,
+ // just return what we've got if there is no
Content-Length,
+ // because we may not be getting anything else
+ if ((responseCode != 200) && (contentLength == 0))
+ {
+ out.flush();
+ return header.length();
+ }
+
+ // get the body, if any; we try to use the
Content-Length header to
+ // determine how much data we're supposed to be
getting, because
+ // sometimes the client/server won't disconnect after
sending us
+ // information...
+ if (contentLength > 0)
+ waitForDisconnect = false;
+
+ if ((contentLength > 0) || (waitForDisconnect))
+ {
+ try {
+ byte[] buf = new byte[4096];
+ int bytesIn = 0;
+ while ( ((byteCount < contentLength) ||
(waitForDisconnect))
+ && ((bytesIn =
in.read(buf)) >= 0) )
+ {
+ out.write(buf, 0, bytesIn);
+ byteCount += bytesIn;
+ }
+ } catch (Exception e) {
+ String errMsg = "Error getting HTTP
body: " + e;
+ if (debugLevel > 0)
+ debugOut.println(errMsg);
+ //bs.write(errMsg.getBytes(), 0,
errMsg.length());
+ }
+ }
+ } catch (Exception e) {
+ if (debugLevel > 0)
+ debugOut.println("Error getting HTTP data: " +
e);
+ }
+
+ //flush the OutputStream and return
+ try { out.flush(); } catch (Exception e) {}
+ return (header.length() + byteCount);
+ }
+
+
+ private String readLine (InputStream in)
+ {
+ // reads a line of text from an InputStream
+ StringBuffer data = new StringBuffer("");
+ int c;
+
+ try
+ {
+ // if we have nothing to read, just return null
+ in.mark(1);
+ if (in.read() == -1)
+ return null;
+ else
+ in.reset();
+
+ while ((c = in.read()) >= 0)
+ {
+ // check for an end-of-line character
+ if ((c == 0) || (c == 10) || (c == 13))
+ break;
+ else
+ data.append((char)c);
+ }
+
+ // deal with the case where the end-of-line terminator
is \r\n
+ if (c == 13)
+ {
+ in.mark(1);
+ if (in.read() != 10)
+ in.reset();
+ }
+ } catch (Exception e) {
+ if (debugLevel > 0)
+ debugOut.println("Error getting header: " + e);
+ }
+
+ // and return what we have
+ return data.toString();
+ }
+
+}
diff --git a/src/org/torproject/android/vpn/OrbotVpnService.java
b/src/org/torproject/android/vpn/OrbotVpnService.java
index 44a2723..42a8b2b 100644
--- a/src/org/torproject/android/vpn/OrbotVpnService.java
+++ b/src/org/torproject/android/vpn/OrbotVpnService.java
@@ -52,9 +52,11 @@ public class OrbotVpnService extends VpnService implements
Handler.Callback {
private ParcelFileDescriptor mInterface;
private int mSocksProxyPort = 9999;
- private ProxyServer mProxyServer;
+ private ProxyServer mSocksProxyServer;
private Thread mThreadProxy;
+ private HttpProxy mHttpProxyServer;
+
private final static int VPN_MTU = 1500;
@Override
@@ -112,9 +114,9 @@ public class OrbotVpnService extends VpnService implements
Handler.Callback {
{
try {
- mProxyServer = new ProxyServer(new
ServerAuthenticatorNone(null, null));
+ mSocksProxyServer = new ProxyServer(new
ServerAuthenticatorNone(null, null));
ProxyServer.setVpnService(OrbotVpnService.this);
- mProxyServer.start(mSocksProxyPort, 5,
InetAddress.getLocalHost());
+ mSocksProxyServer.start(mSocksProxyPort, 5,
InetAddress.getLocalHost());
} catch (Exception e) {
Log.d(TAG,"proxy server error: " +
e.getLocalizedMessage(),e);
}
@@ -122,6 +124,11 @@ public class OrbotVpnService extends VpnService implements
Handler.Callback {
};
mThreadProxy.start();
+
+ mHttpProxyServer = new HttpProxy(8888);
+ HttpProxy.setVpnService(OrbotVpnService.this);
+ mHttpProxyServer.setDebug(5, System.out);
+ mHttpProxyServer.start();
}
@Override
@@ -132,10 +139,16 @@ public class OrbotVpnService extends VpnService
implements Handler.Callback {
private void stopVPN ()
{
- if (mProxyServer != null){
- mProxyServer.stop();
- mProxyServer = null;
+ if (mSocksProxyServer != null){
+ mSocksProxyServer.stop();
+ mSocksProxyServer = null;
+ }
+
+ if (mHttpProxyServer != null)
+ {
+ mHttpProxyServer.closeSocket();
}
+
if (mInterface != null){
onRevoke();
_______________________________________________
tor-commits mailing list
[email protected]
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits
