Alawn/shadowsocks-windows
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

First working built-in http proxy

Browse Source
This commit is contained in:
noisyfox
2016-12-09 02:17:46 +11:00
parent 0d4d01af3b
commit 5ba0dffa5d
6 changed files with 603 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files
shadowsocks-csharp/Controller/Service/Http2Socks5.cs
+472 -3
View File
@@ -1,15 +1,26 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;
using Shadowsocks.ForwardProxy;
using Shadowsocks.Util.Sockets;
namespace Shadowsocks.Controller.Service
{
class Http2Socks5 : Listener.Service
{
private readonly ByteSearch.SearchTarget _connectSearch =
new ByteSearch.SearchTarget(Encoding.UTF8.GetBytes("HTTP"));
private readonly int _socks5Port;
public Http2Socks5(int socks5Port)
{
_socks5Port = socks5Port;
}
public override bool Handle(byte[] firstPacket, int length, Socket socket, object state)
{
if (socket.ProtocolType != ProtocolType.Tcp)
@@ -17,7 +28,465 @@ namespace Shadowsocks.Controller.Service
return false;
}
return true;
if (_connectSearch.SearchIn(firstPacket, 0, length) != -1)
{
new HttpHandler(_socks5Port, firstPacket, length, socket);
return true;
}
return false;
}
private class HttpHandler
{
private const string HTTP_CRLF = "\r\n";
private const string HTTP_CONNECT_200 =
"HTTP/1.1 200 Connection established" + HTTP_CRLF +
"Proxy-Connection: close" + HTTP_CRLF +
"Proxy-Agent: Shadowsocks" + HTTP_CRLF +
"" + HTTP_CRLF; // End with an empty line
private readonly WrappedSocket _localSocket;
private readonly int _socks5Port;
private Socks5Proxy _socks5;
private bool _closed = false;
private bool _localShutdown = false;
private bool _remoteShutdown = false;
private readonly object _Lock = new object();
private const int RecvSize = 16384;
// remote receive buffer
private readonly byte[] _remoteRecvBuffer = new byte[RecvSize];
// connection receive buffer
private readonly byte[] _connetionRecvBuffer = new byte[RecvSize];
public HttpHandler(int socks5Port, byte[] firstPacket, int length, Socket socket)
{
_socks5Port = socks5Port;
_localSocket = new WrappedSocket(socket);
_localSocket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true);
new LineReader(_localSocket, firstPacket, 0, length, OnLineRead, OnException, OnFinish,
Encoding.UTF8, HTTP_CRLF, 1024, null);
}
private void CheckClose()
{
if (_localShutdown && _remoteShutdown)
{
Close();
}
}
private void Close()
{
lock (_Lock)
{
if (_closed)
{
return;
}
_closed = true;
}
_localSocket.Dispose();
_socks5?.Close();
}
private byte[] _lastBytes;
private int _lastBytesIndex;
private int _lastBytesLength;
#region Socks5 Process
private void ProxyConnectCallback(IAsyncResult ar)
{
if (_closed)
{
return;
}
try
{
_socks5.EndConnectProxy(ar);
_socks5.BeginConnectDest(SocketUtil.GetEndPoint(_targetHost, _targetPort), ConnectCallback, null);
}
catch (ArgumentException)
{
}
catch (Exception e)
{
Logging.LogUsefulException(e);
Close();
}
}
private void ConnectCallback(IAsyncResult ar)
{
if (_closed)
{
return;
}
try
{
_socks5.EndConnectDest(ar);
if (_isConnect)
{
// http connect response
SendConnectResponse();
}
else
{
// send header
SendHeader();
}
}
catch (ArgumentException)
{
}
catch (Exception e)
{
Logging.LogUsefulException(e);
Close();
}
}
#endregion
#region CONNECT
private void SendConnectResponse()
{
var b = Encoding.UTF8.GetBytes(HTTP_CONNECT_200);
_localSocket.BeginSend(b, 0, b.Length, SocketFlags.None, Http200SendCallback, null);
}
private void Http200SendCallback(IAsyncResult ar)
{
if (_closed)
{
return;
}
try
{
_localSocket.EndSend(ar);
StartPipe();
}
catch (ArgumentException)
{
}
catch (Exception e)
{
Logging.LogUsefulException(e);
Close();
}
}
#endregion
#region Other http method except CONNECT
private void SendHeader()
{
var h = _headers.Dequeue() + HTTP_CRLF;
var len = Encoding.UTF8.GetBytes(h, 0, h.Length, _connetionRecvBuffer, 0);
_socks5.BeginSend(_connetionRecvBuffer, 0, len, SocketFlags.None, HeaderSendCallback, null);
}
private void HeaderSendCallback(IAsyncResult ar)
{
if (_closed)
{
return;
}
try
{
_socks5.EndSend(ar);
if (_headers.Count > 0)
{
SendHeader();
}
else
{
StartPipe();
}
}
catch (Exception e)
{
Logging.LogUsefulException(e);
Close();
}
}
#endregion
#region Pipe
private void StartPipe()
{
if (_closed)
{
return;
}
try
{
_socks5.BeginReceive(_remoteRecvBuffer, 0, RecvSize, 0,
PipeRemoteReceiveCallback, null);
if (_lastBytesLength > 0)
{
_socks5.BeginSend(_lastBytes, _lastBytesIndex, _lastBytesLength, SocketFlags.None,
PipeRemoteSendCallback, null);
}
else
{
_localSocket.BeginReceive(_connetionRecvBuffer, 0, RecvSize, 0,
PipeConnectionReceiveCallback, null);
}
}
catch (Exception e)
{
Logging.LogUsefulException(e);
Close();
}
}
private void PipeRemoteReceiveCallback(IAsyncResult ar)
{
if (_closed)
{
return;
}
try
{
int bytesRead = _socks5.EndReceive(ar);
Logging.Debug("Read from remote: " + bytesRead);
if (bytesRead > 0)
{
_localSocket.BeginSend(_remoteRecvBuffer, 0, bytesRead, 0, PipeConnectionSendCallback, null);
}
else
{
_localSocket.Shutdown(SocketShutdown.Send);
_localShutdown = true;
CheckClose();
}
}
catch (Exception e)
{
Logging.LogUsefulException(e);
Close();
}
}
private void PipeConnectionReceiveCallback(IAsyncResult ar)
{
if (_closed)
{
return;
}
try
{
int bytesRead = _localSocket.EndReceive(ar);
Logging.Debug("Read from local: " + bytesRead);
if (bytesRead > 0)
{
_socks5.BeginSend(_connetionRecvBuffer, 0, bytesRead, 0, PipeRemoteSendCallback, null);
}
else
{
_socks5.Shutdown(SocketShutdown.Send);
_remoteShutdown = true;
CheckClose();
}
}
catch (Exception e)
{
Logging.LogUsefulException(e);
Close();
}
}
private void PipeRemoteSendCallback(IAsyncResult ar)
{
if (_closed)
{
return;
}
try
{
_socks5.EndSend(ar);
_localSocket.BeginReceive(_connetionRecvBuffer, 0, RecvSize, 0,
PipeConnectionReceiveCallback, null);
}
catch (Exception e)
{
Logging.LogUsefulException(e);
Close();
}
}
private void PipeConnectionSendCallback(IAsyncResult ar)
{
if (_closed)
{
return;
}
try
{
_localSocket.EndSend(ar);
_socks5.BeginReceive(_remoteRecvBuffer, 0, RecvSize, 0,
PipeRemoteReceiveCallback, null);
}
catch (Exception e)
{
Logging.LogUsefulException(e);
Close();
}
}
#endregion
#region Header Parse
private void OnException(Exception ex, object state)
{
throw ex;
}
private static readonly Regex HttpRequestHeaderRegex = new Regex(@"^([A-Z]+?) ([^\s]+) HTTP/1\.\d$");
private int _requestLineCount = 0;
private volatile bool _isConnect = false;
private string _targetHost;
private int _targetPort;
private readonly Queue<string> _headers = new Queue<string>();
private bool OnLineRead(string line, object state)
{
if (_closed)
{
return true;
}
Logging.Debug(line);
if (_requestLineCount == 0)
{
var m = HttpRequestHeaderRegex.Match(line);
if (m.Success)
{
var method = m.Groups[1].Value;
if (method == "CONNECT")
{
_isConnect = true;
var location = m.Groups[2].Value;
var locs = location.Split(':');
_targetHost = locs[0];
if (locs.Length > 1)
{
if (!int.TryParse(locs[1], out _targetPort))
{
throw new Exception("Bad http header: " + line);
}
}
else
{
_targetPort = 80;
}
}
_headers.Enqueue(line);
}
}
else
{
if (line.IsNullOrEmpty())
{
_headers.Enqueue("");
return true;
}
if (!line.StartsWith("Proxy-"))
{
_headers.Enqueue(line);
}
if (!_isConnect)
{
if (line.StartsWith("Host: "))
{
var location = line.Substring(6).Trim();
var locs = location.Split(':');
_targetHost = locs[0];
if (locs.Length > 1)
{
if (!int.TryParse(locs[1], out _targetPort))
{
throw new Exception("Bad http header: " + line);
}
}
else
{
_targetPort = 80;
}
}
}
}
_requestLineCount++;
return false;
}
private void OnFinish(byte[] lastBytes, int index, int length, object state)
{
if (_closed)
{
return;
}
if (_targetHost == null)
{
Logging.Error("Unkonwn host");
Close();
}
else
{
if (length > 0)
{
_lastBytes = lastBytes;
_lastBytesIndex = index;
_lastBytesLength = length;
}
// Start socks5 conn
_socks5 = new Socks5Proxy();
_socks5.BeginConnectProxy(SocketUtil.GetEndPoint("127.0.0.1", _socks5Port), ProxyConnectCallback,
null);
}
}
#endregion
}
}
}
shadowsocks-csharp/Controller/ShadowsocksController.cs
+2 -1
View File
@@ -7,7 +7,7 @@ using System.Text;
using System.Threading;
using System.Web;
using Newtonsoft.Json;
using Shadowsocks.Controller.Service;
using Shadowsocks.Controller.Strategy;
using Shadowsocks.Model;
using Shadowsocks.Properties;
@@ -462,6 +462,7 @@ namespace Shadowsocks.Controller
services.Add(tcpRelay);
services.Add(udpRelay);
services.Add(_pacServer);
services.Add(new Http2Socks5(_config.localPort));
_listener = new Listener(services);
_listener.Start(_config);
}
shadowsocks-csharp/Util/Sockets/ByteSearch.cs
+117
View File
@@ -0,0 +1,117 @@
using System;
namespace Shadowsocks.Util.Sockets
{
// Boyer-Moore string search
public static class ByteSearch
{
public class SearchTarget
{
private readonly byte[] _needle;
private readonly int[] _needleCharTable;
private readonly int[] _needleOffsetTable;
public SearchTarget(byte[] needle)
{
_needle = needle;
_needleCharTable = MakeCharTable(needle);
_needleOffsetTable = MakeOffsetTable(needle);
}
// Thread-safe
public int SearchIn(byte[] haystack, int index, int length)
{
return IndexOf(haystack, index, length, _needle, _needleOffsetTable, _needleCharTable);
}
}
private static int IndexOf(byte[] haystack, int index, int length, byte[] needle, int[] offsetTable, int[] charTable)
{
var end = index + length;
for (int i = needle.Length - 1 + index, j; i < end;)
{
for (j = needle.Length - 1; needle[j] == haystack[i]; --i, --j)
{
if (j == 0)
{
return i;
}
}
// i += needle.length - j; // For naive method
i += Math.Max(offsetTable[needle.Length - 1 - j], charTable[haystack[i]]);
}
return -1;
}
/**
* Makes the jump table based on the mismatched character information.
*/
private static int[] MakeCharTable(byte[] needle)
{
const int ALPHABET_SIZE = 256;
int[] table = new int[ALPHABET_SIZE];
for (int i = 0; i < table.Length; ++i)
{
table[i] = needle.Length;
}
for (int i = 0; i < needle.Length - 1; ++i)
{
table[needle[i]] = needle.Length - 1 - i;
}
return table;
}
/**
* Makes the jump table based on the scan offset which mismatch occurs.
*/
private static int[] MakeOffsetTable(byte[] needle)
{
int[] table = new int[needle.Length];
int lastPrefixPosition = needle.Length;
for (int i = needle.Length - 1; i >= 0; --i)
{
if (IsPrefix(needle, i + 1))
{
lastPrefixPosition = i + 1;
}
table[needle.Length - 1 - i] = lastPrefixPosition - i + needle.Length - 1;
}
for (int i = 0; i < needle.Length - 1; ++i)
{
int slen = SuffixLength(needle, i);
table[slen] = needle.Length - 1 - i + slen;
}
return table;
}
/**
* Is needle[p:end] a prefix of needle?
*/
private static bool IsPrefix(byte[] needle, int p)
{
for (int i = p, j = 0; i < needle.Length; ++i, ++j)
{
if (needle[i] != needle[j])
{
return false;
}
}
return true;
}
/**
* Returns the maximum length of the substring ends at p and is a suffix.
*/
private static int SuffixLength(byte[] needle, int p)
{
int len = 0;
for (int i = p, j = needle.Length - 1;
i >= 0 && needle[i] == needle[j]; --i, --j)
{
len += 1;
}
return len;
}
}
}
shadowsocks-csharp/Util/Sockets/LineReader.cs
+3 -98
View File
@@ -12,8 +12,7 @@ namespace Shadowsocks.Util.Sockets
private readonly Encoding _encoding;
// private readonly string _delimiter;
private readonly byte[] _delimiterBytes;
private readonly int[] _delimiterSearchCharTable;
private readonly int[] _delimiterSearchOffsetTable;
private readonly ByteSearch.SearchTarget _delimiterSearch;
private readonly object _state;
private readonly byte[] _lineBuffer;
@@ -78,8 +77,7 @@ namespace Shadowsocks.Util.Sockets
throw new ArgumentException("Too small!", nameof(maxLineBytes));
}
_delimiterSearchCharTable = MakeCharTable(_delimiterBytes);
_delimiterSearchOffsetTable = MakeOffsetTable(_delimiterBytes);
_delimiterSearch = new ByteSearch.SearchTarget(_delimiterBytes);
_lineBuffer = new byte[maxLineBytes];
@@ -140,8 +138,7 @@ namespace Shadowsocks.Util.Sockets
private void NewPackageRecv()
{
int i;
while ((i = IndexOf(_lineBuffer, _bufferDataIndex, _bufferDataLength, _delimiterBytes, _delimiterSearchOffsetTable,
_delimiterSearchCharTable)) != -1)
while ((i = _delimiterSearch.SearchIn(_lineBuffer, _bufferDataIndex, _bufferDataLength)) != -1)
{
var decodeLen = i - _bufferDataIndex;
string line = _encoding.GetString(_lineBuffer, _bufferDataIndex, decodeLen);
@@ -183,97 +180,5 @@ namespace Shadowsocks.Util.Sockets
{
_onFinish?.Invoke(_lineBuffer, _bufferDataIndex, _bufferDataLength, _state);
}
#region Boyer-Moore string search
private static int IndexOf(byte[] haystack, int index, int length, byte[] needle, int[] offsetTable, int[] charTable)
{
var end = index + length;
for (int i = needle.Length - 1 + index, j; i < end;)
{
for (j = needle.Length - 1; needle[j] == haystack[i]; --i, --j)
{
if (j == 0)
{
return i;
}
}
// i += needle.length - j; // For naive method
i += Math.Max(offsetTable[needle.Length - 1 - j], charTable[haystack[i]]);
}
return -1;
}
/**
* Makes the jump table based on the mismatched character information.
*/
private static int[] MakeCharTable(byte[] needle)
{
const int ALPHABET_SIZE = 256;
int[] table = new int[ALPHABET_SIZE];
for (int i = 0; i < table.Length; ++i)
{
table[i] = needle.Length;
}
for (int i = 0; i < needle.Length - 1; ++i)
{
table[needle[i]] = needle.Length - 1 - i;
}
return table;
}
/**
* Makes the jump table based on the scan offset which mismatch occurs.
*/
private static int[] MakeOffsetTable(byte[] needle)
{
int[] table = new int[needle.Length];
int lastPrefixPosition = needle.Length;
for (int i = needle.Length - 1; i >= 0; --i)
{
if (IsPrefix(needle, i + 1))
{
lastPrefixPosition = i + 1;
}
table[needle.Length - 1 - i] = lastPrefixPosition - i + needle.Length - 1;
}
for (int i = 0; i < needle.Length - 1; ++i)
{
int slen = SuffixLength(needle, i);
table[slen] = needle.Length - 1 - i + slen;
}
return table;
}
/**
* Is needle[p:end] a prefix of needle?
*/
private static bool IsPrefix(byte[] needle, int p)
{
for (int i = p, j = 0; i < needle.Length; ++i, ++j)
{
if (needle[i] != needle[j])
{
return false;
}
}
return true;
}
/**
* Returns the maximum length of the substring ends at p and is a suffix.
*/
private static int SuffixLength(byte[] needle, int p)
{
int len = 0;
for (int i = p, j = needle.Length - 1;
i >= 0 && needle[i] == needle[j]; --i, --j)
{
len += 1;
}
return len;
}
#endregion
}
}
shadowsocks-csharp/Util/Sockets/WrappedSocket.cs
+8
View File
@@ -26,6 +26,14 @@ namespace Shadowsocks.Util.Sockets
private Socket _activeSocket;
public WrappedSocket() { }
public WrappedSocket(Socket socket)
{
_activeSocket = socket;
}
public void BeginConnect(EndPoint remoteEP, AsyncCallback callback, object state)
{
if (_disposed)
shadowsocks-csharp/shadowsocks-csharp.csproj
+1
View File
@@ -190,6 +190,7 @@
<Compile Include="StringEx.cs" />
<Compile Include="Controller\System\Hotkeys\Hotkeys.cs" />
<Compile Include="Encryption\RNG.cs" />
<Compile Include="Util\Sockets\ByteSearch.cs" />
<Compile Include="Util\Sockets\LineReader.cs" />
<Compile Include="Util\Sockets\SocketUtil.cs" />
<Compile Include="Util\Sockets\WrappedSocket.cs" />