Commit 3b7ca8ec authored by unknown's avatar unknown

Added the proxy server project

parent 26396f49
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
namespace HTTPProxyServer
{
public partial class ProxyServer
{
private void SendNormal(Stream inStream, Stream outStream)
{
Byte[] buffer = new Byte[BUFFER_SIZE];
int bytesRead;
while ((bytesRead = inStream.Read(buffer, 0, buffer.Length)) > 0)
{
outStream.Write(buffer, 0, bytesRead);
}
}
private void SendChunked(Stream inStream, Stream outStream)
{
Byte[] buffer = new Byte[BUFFER_SIZE];
var ChunkTrail = Encoding.ASCII.GetBytes(Environment.NewLine);
int bytesRead;
while ((bytesRead = inStream.Read(buffer, 0, buffer.Length)) > 0)
{
var ChunkHead = Encoding.ASCII.GetBytes(bytesRead.ToString("x2"));
outStream.Write(ChunkHead, 0, ChunkHead.Length);
outStream.Write(ChunkTrail, 0, ChunkTrail.Length);
outStream.Write(buffer, 0, bytesRead);
outStream.Write(ChunkTrail, 0, ChunkTrail.Length);
}
var ChunkEnd = Encoding.ASCII.GetBytes(0.ToString("x2") + Environment.NewLine + Environment.NewLine);
outStream.Write(ChunkEnd, 0, ChunkEnd.Length);
}
private void SendChunked(byte[] data, Stream outStream)
{
Byte[] buffer = new Byte[BUFFER_SIZE];
var ChunkTrail = Encoding.ASCII.GetBytes(Environment.NewLine);
var ChunkHead = Encoding.ASCII.GetBytes(data.Length.ToString("x2"));
outStream.Write(ChunkHead, 0, ChunkHead.Length);
outStream.Write(ChunkTrail, 0, ChunkTrail.Length);
outStream.Write(data, 0, data.Length);
outStream.Write(ChunkTrail, 0, ChunkTrail.Length);
var ChunkEnd = Encoding.ASCII.GetBytes(0.ToString("x2") + Environment.NewLine + Environment.NewLine);
outStream.Write(ChunkEnd, 0, ChunkEnd.Length);
}
private byte[] EncodeData(string ResponseData, Encoding e)
{
return e.GetBytes(ResponseData);
}
private byte[] CompressZlib(string ResponseData, Encoding e)
{
Byte[] bytes = e.GetBytes(ResponseData);
using (MemoryStream ms = new MemoryStream())
{
using (Ionic.Zlib.ZlibStream zip = new Ionic.Zlib.ZlibStream(ms, Ionic.Zlib.CompressionMode.Compress, true))
{
zip.Write(bytes, 0, bytes.Length);
}
return ms.ToArray();
}
}
private byte[] CompressDeflate(string ResponseData, Encoding e)
{
Byte[] bytes = e.GetBytes(ResponseData);
using (MemoryStream ms = new MemoryStream())
{
using (Ionic.Zlib.DeflateStream zip = new Ionic.Zlib.DeflateStream(ms, Ionic.Zlib.CompressionMode.Compress, true))
{
zip.Write(bytes, 0, bytes.Length);
}
return ms.ToArray();
}
}
private byte[] CompressGzip(string ResponseData, Encoding e)
{
Byte[] bytes = e.GetBytes(ResponseData);
using (MemoryStream ms = new MemoryStream())
{
using (Ionic.Zlib.GZipStream zip = new Ionic.Zlib.GZipStream(ms, Ionic.Zlib.CompressionMode.Compress, true))
{
zip.Write(bytes, 0, bytes.Length);
}
return ms.ToArray();
}
}
private void sendData(Stream outStream, byte[] data, bool isChunked)
{
if (!isChunked)
{
outStream.Write(data, 0, data.Length);
}
else
SendChunked(data, outStream);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Security.Principal;
namespace Titanium.HTTPProxyServer
{
public class CredentialManager
{
public static Dictionary<string, WindowsPrincipal> Cache { get; set; }
}
}
using System;
using System.Text;
using System.IO;
using System.Net;
using HTTPProxyServer.Utility;
namespace HTTPProxyServer
{
public class SessionEventArgs : EventArgs
{
public string requestURL { get; set; }
public string hostName { get; set; }
public CustomBinaryReader clientStreamReader { get; set; }
public string responseString { get; set; }
public int requestLength { get; set; }
public Stream clientStream { get; set; }
public Version httpVersion { get; set; }
public bool isAlive { get; set; }
public bool cancel { get; set; }
public bool isSecure { get; set; }
public int port { get; set; }
private int BUFFER_SIZE;
public HttpWebResponse serverResponse { get; set; }
public Stream serverResponseStream { get; set; }
public HttpWebRequest proxyRequest { get; set; }
public Encoding encoding { get; set; }
public bool wasModified { get; set; }
public System.Threading.ManualResetEvent finishedRequestEvent { get; set; }
public string upgradeProtocol { get; set; }
public SessionEventArgs(int BufferSize)
{
BUFFER_SIZE = BufferSize;
}
public string decode()
{
int bytesRead;
int totalBytesRead = 0;
MemoryStream mw = new MemoryStream();
var buffer = clientStreamReader.ReadBytes(requestLength);
while (totalBytesRead < requestLength && (bytesRead = buffer.Length) > 0)
{
totalBytesRead += bytesRead;
mw.Write(buffer, 0, bytesRead);
}
mw.Close();
return Encoding.Default.GetString(mw.ToArray());
}
public void Ok()
{
StreamWriter connectStreamWriter = new StreamWriter(clientStream);
var s = String.Format("HTTP/{0}.{1} {2} {3}", httpVersion.Major, httpVersion.Minor, 200, "Ok");
connectStreamWriter.WriteLine(s);
connectStreamWriter.WriteLine(String.Format("Timestamp: {0}", DateTime.Now.ToString()));
connectStreamWriter.WriteLine("content-length: 0");
connectStreamWriter.WriteLine("Cache-Control: no-cache, no-store, must-revalidate");
connectStreamWriter.WriteLine("Pragma: no-cache");
connectStreamWriter.WriteLine("Expires: 0");
if (isAlive)
{
connectStreamWriter.WriteLine("Connection: Keep-Alive");
}
else
connectStreamWriter.WriteLine("Connection: close");
connectStreamWriter.WriteLine();
connectStreamWriter.Flush();
cancel = true;
}
public void getResponseBody()
{
if (responseString == null)
{
encoding = Encoding.GetEncoding(serverResponse.CharacterSet);
if (encoding == null) encoding = Encoding.Default;
string ResponseData = "";
switch (serverResponse.ContentEncoding)
{
case "gzip":
ResponseData = DecompressGzip(serverResponseStream, encoding);
break;
case "deflate":
ResponseData = DecompressDeflate(serverResponseStream, encoding);
break;
case "zlib":
ResponseData = DecompressZlib(serverResponseStream, encoding);
break;
default:
ResponseData = DecodeData(serverResponseStream, encoding);
break;
}
responseString = ResponseData;
wasModified = true;
}
}
//stream reader not recomended for images
private string DecodeData(Stream responseStream, Encoding e)
{
StreamReader reader = new StreamReader(responseStream, e);
return reader.ReadToEnd();
}
private string DecompressGzip(Stream input, Encoding e)
{
using (System.IO.Compression.GZipStream decompressor = new System.IO.Compression.GZipStream(input,System.IO.Compression.CompressionMode.Decompress))
{
int read = 0;
var buffer = new byte[BUFFER_SIZE];
using (MemoryStream output = new MemoryStream())
{
while ((read = decompressor.Read(buffer, 0, buffer.Length)) > 0)
{
output.Write(buffer, 0, read);
}
return e.GetString(output.ToArray());
}
}
}
private string DecompressDeflate(Stream input, Encoding e)
{
using (Ionic.Zlib.DeflateStream decompressor = new Ionic.Zlib.DeflateStream(input, Ionic.Zlib.CompressionMode.Decompress))
{
int read = 0;
var buffer = new byte[BUFFER_SIZE];
using (MemoryStream output = new MemoryStream())
{
while ((read = decompressor.Read(buffer, 0, buffer.Length)) > 0)
{
output.Write(buffer, 0, read);
}
return e.GetString(output.ToArray());
}
}
}
private string DecompressZlib(Stream input, Encoding e)
{
using (Ionic.Zlib.ZlibStream decompressor = new Ionic.Zlib.ZlibStream(input, Ionic.Zlib.CompressionMode.Decompress))
{
int read = 0;
var buffer = new byte[BUFFER_SIZE];
using (MemoryStream output = new MemoryStream())
{
while ((read = decompressor.Read(buffer, 0, buffer.Length)) > 0)
{
output.Write(buffer, 0, read);
}
return e.GetString(output.ToArray());
}
}
}
public IPAddress ipAddress { get; set; }
}
}
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Threading;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Net.Security;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using System.Diagnostics;
using Titanium.HTTPProxyServer;
namespace HTTPProxyServer
{
public partial class ProxyServer
{
private static readonly int BUFFER_SIZE = 8192;
private static readonly char[] semiSplit = new char[] { ';' };
private static readonly char[] equalSplit = new char[] { '=' };
private static readonly String[] colonSpaceSplit = new string[] { ": " };
private static readonly char[] spaceSplit = new char[] { ' ' };
private static readonly char[] commaSplit = new char[] { ',' };
private static readonly Regex cookieSplitRegEx = new Regex(@",(?! )");
private static object _outputLockObj = new object();
private static List<string> _pinnedCertificateClients = new List<string>();
private static Dictionary<string, X509Certificate2> certificateCache = new Dictionary<string, X509Certificate2>();
private static X509Store _store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
private TcpListener _listener;
private Thread _listenerThread;
public event EventHandler<SessionEventArgs> BeforeRequest;
public event EventHandler<SessionEventArgs> BeforeResponse;
public IPAddress ListeningIPInterface { get; set; }
public Int32 ListeningPort
{
get
{
return ((IPEndPoint)_listener.LocalEndpoint).Port;
}
}
public ProxyServer()
{
System.Net.ServicePointManager.Expect100Continue = false;
System.Net.WebRequest.DefaultWebProxy = null;
System.Net.ServicePointManager.DefaultConnectionLimit = 10;
ServicePointManager.DnsRefreshTimeout = 3 * 60 * 1000;//3 minutes
ServicePointManager.MaxServicePointIdleTime = 3 * 60 * 1000;
ServicePointManager.ServerCertificateValidationCallback = delegate(object s, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
if (sslPolicyErrors == SslPolicyErrors.None) return true;
else
return false;
};
URLPeriodFix();
}
public bool Start()
{
_listener = new TcpListener(IPAddress.Any, 0);
_listener.Start();
_listenerThread = new Thread(new ParameterizedThreadStart(Listen));
_listenerThread.Start(_listener);
_listenerThread.IsBackground = true;
return true;
}
public void Stop()
{
_listener.Stop();
_listenerThread.Abort();
_listenerThread.Join();
}
private void Listen(Object obj)
{
TcpListener listener = (TcpListener)obj;
CredentialManager.Cache = new Dictionary<string, System.Security.Principal.WindowsPrincipal>();
try
{
while (true)
{
TcpClient client = listener.AcceptTcpClient();
while (!ThreadPool.UnsafeQueueUserWorkItem(new WaitCallback(ProcessClient), client)) ;
}
}
catch (ThreadAbortException ex) { Debug.WriteLine(ex.Message); }
catch (SocketException ex)
{
Debug.WriteLine(ex.Message);
}
}
private void ProcessClient(Object obj)
{
try
{
TcpClient client = (TcpClient)obj;
DoHttpProcessing(client);
client.Close();
}
catch { }
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Diagnostics;
using System.Net;
namespace HTTPProxyServer
{
public partial class ProxyServer
{
private void GetRequestStreamCallback(IAsyncResult asynchronousResult)
{
var Args = (SessionEventArgs)asynchronousResult.AsyncState;
// End the operation
Stream postStream = Args.proxyRequest.EndGetRequestStream(asynchronousResult);
if (Args.proxyRequest.ContentLength > 0)
{
Args.proxyRequest.AllowWriteStreamBuffering = true;
try
{
int totalbytesRead = 0;
int bytesToRead;
if (Args.proxyRequest.ContentLength < BUFFER_SIZE)
{
bytesToRead = (int)Args.proxyRequest.ContentLength;
}
else
bytesToRead = BUFFER_SIZE;
while (totalbytesRead < (int)Args.proxyRequest.ContentLength)
{
var buffer = Args.clientStreamReader.ReadBytes(bytesToRead);
totalbytesRead += buffer.Length;
int RemainingBytes = (int)Args.proxyRequest.ContentLength - totalbytesRead;
if (RemainingBytes < bytesToRead)
{
bytesToRead = RemainingBytes;
}
postStream.Write(buffer, 0, buffer.Length);
}
postStream.Close();
}
catch (IOException ex)
{
Args.proxyRequest.KeepAlive = false;
Args.finishedRequestEvent.Set();
Debug.WriteLine(ex.Message);
return;
}
catch (WebException ex)
{
Args.proxyRequest.KeepAlive = false;
Args.finishedRequestEvent.Set();
Debug.WriteLine(ex.Message);
return;
}
}
else if (Args.proxyRequest.SendChunked)
{
Args.proxyRequest.AllowWriteStreamBuffering = true;
try
{
StringBuilder sb = new StringBuilder();
byte[] byteRead = new byte[1];
while (true)
{
Args.clientStream.Read(byteRead, 0, 1);
sb.Append(Encoding.ASCII.GetString(byteRead));
if (sb.ToString().EndsWith(Environment.NewLine))
{
var chunkSizeInHex = sb.ToString().Replace(Environment.NewLine, String.Empty);
var chunckSize = int.Parse(chunkSizeInHex, System.Globalization.NumberStyles.HexNumber);
if (chunckSize == 0)
{
for (int i = 0; i < Encoding.ASCII.GetByteCount(Environment.NewLine); i++)
{
Args.clientStream.ReadByte();
}
break;
}
var totalbytesRead = 0;
int bytesToRead;
if (chunckSize < BUFFER_SIZE)
{
bytesToRead = chunckSize;
}
else
bytesToRead = BUFFER_SIZE;
while (totalbytesRead < chunckSize)
{
var buffer = Args.clientStreamReader.ReadBytes(bytesToRead);
totalbytesRead += buffer.Length;
int RemainingBytes = chunckSize - totalbytesRead;
if (RemainingBytes < bytesToRead)
{
bytesToRead = RemainingBytes;
}
postStream.Write(buffer, 0, buffer.Length);
}
for (int i = 0; i < Encoding.ASCII.GetByteCount(Environment.NewLine); i++)
{
Args.clientStream.ReadByte();
}
sb.Clear();
}
}
postStream.Close();
}
catch (IOException ex)
{
if (postStream != null)
postStream.Close();
Args.proxyRequest.KeepAlive = false;
Args.finishedRequestEvent.Set();
Debug.WriteLine(ex.Message);
return;
}
catch (WebException ex)
{
if (postStream != null)
postStream.Close();
Args.proxyRequest.KeepAlive = false;
Args.finishedRequestEvent.Set();
Debug.WriteLine(ex.Message);
return;
}
}
Args.proxyRequest.BeginGetResponse(new AsyncCallback(GetResponseCallback), Args);
}
}
}
This diff is collapsed.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.IO;
using System.Net;
using System.Net.Security;
using System.Threading;
using System.Security.Authentication;
using System.Diagnostics;
namespace HTTPProxyServer
{
partial class ProxyServer
{
private void GetResponseCallback(IAsyncResult asynchronousResult)
{
SessionEventArgs Args = (SessionEventArgs)asynchronousResult.AsyncState;
try
{
Args.serverResponse = (HttpWebResponse)Args.proxyRequest.EndGetResponse(asynchronousResult);
}
catch (WebException webEx)
{
Args.proxyRequest.KeepAlive = false;
Args.serverResponse = webEx.Response as HttpWebResponse;
}
Stream serverResponseStream = null;
Stream clientWriteStream = Args.clientStream;
StreamWriter myResponseWriter = null;
try
{
myResponseWriter = new StreamWriter(clientWriteStream);
if (Args.serverResponse != null)
{
List<Tuple<String, String>> responseHeaders = ProcessResponse(Args.serverResponse);
serverResponseStream = Args.serverResponse.GetResponseStream();
Args.serverResponseStream = serverResponseStream;
if (Args.serverResponse.Headers.Count == 0 && Args.serverResponse.ContentLength == -1)
Args.proxyRequest.KeepAlive = false;
bool isChunked = Args.serverResponse.GetResponseHeader("transfer-encoding") == null ? false : Args.serverResponse.GetResponseHeader("transfer-encoding").ToLower() == "chunked" ? true : false;
Args.proxyRequest.KeepAlive = Args.serverResponse.GetResponseHeader("connection") == null ? Args.proxyRequest.KeepAlive : (Args.serverResponse.GetResponseHeader("connection") == "close" ? false : Args.proxyRequest.KeepAlive);
Args.upgradeProtocol = Args.serverResponse.GetResponseHeader("upgrade") == null ? null : Args.serverResponse.GetResponseHeader("upgrade");
if (BeforeResponse != null)
BeforeResponse(null, Args);
if (Args.wasModified)
{
byte[] data;
switch (Args.serverResponse.ContentEncoding)
{
case "gzip":
data = CompressGzip(Args.responseString, Args.encoding);
WriteResponseStatus(Args.serverResponse.ProtocolVersion, Args.serverResponse.StatusCode, Args.serverResponse.StatusDescription, myResponseWriter);
WriteResponseHeaders(myResponseWriter, responseHeaders, data.Length);
sendData(clientWriteStream, data, isChunked);
break;
case "deflate":
data = CompressDeflate(Args.responseString, Args.encoding);
WriteResponseStatus(Args.serverResponse.ProtocolVersion, Args.serverResponse.StatusCode, Args.serverResponse.StatusDescription, myResponseWriter);
WriteResponseHeaders(myResponseWriter, responseHeaders, data.Length);
sendData(clientWriteStream, data, isChunked);
break;
case "zlib":
data = CompressZlib(Args.responseString, Args.encoding);
WriteResponseStatus(Args.serverResponse.ProtocolVersion, Args.serverResponse.StatusCode, Args.serverResponse.StatusDescription, myResponseWriter);
WriteResponseHeaders(myResponseWriter, responseHeaders, data.Length);
sendData(clientWriteStream, data, isChunked);
break;
default:
data = EncodeData(Args.responseString, Args.encoding);
WriteResponseStatus(Args.serverResponse.ProtocolVersion, Args.serverResponse.StatusCode, Args.serverResponse.StatusDescription, myResponseWriter);
WriteResponseHeaders(myResponseWriter, responseHeaders, data.Length);
sendData(clientWriteStream, data, isChunked);
break;
}
}
else
{
WriteResponseStatus(Args.serverResponse.ProtocolVersion, Args.serverResponse.StatusCode, Args.serverResponse.StatusDescription, myResponseWriter);
WriteResponseHeaders(myResponseWriter, responseHeaders);
if (isChunked)
SendChunked(serverResponseStream, clientWriteStream);
else
SendNormal(serverResponseStream, clientWriteStream);
}
clientWriteStream.Flush();
}
else
Args.proxyRequest.KeepAlive = false;
}
catch (IOException ex)
{
Args.proxyRequest.KeepAlive = false;
Debug.WriteLine(ex.Message);
}
catch (SocketException ex)
{
Args.proxyRequest.KeepAlive = false;
Debug.WriteLine(ex.Message);
}
catch (ArgumentException ex)
{
Args.proxyRequest.KeepAlive = false;
Debug.WriteLine(ex.Message);
}
catch (WebException ex)
{
Args.proxyRequest.KeepAlive = false;
Debug.WriteLine(ex.Message);
}
finally
{
if (Args.proxyRequest.KeepAlive == false)
{
if (myResponseWriter != null)
myResponseWriter.Close();
if (clientWriteStream != null)
clientWriteStream.Close();
}
//if (serverResponseStream != null)
// serverResponseStream.Close();
if (Args.serverResponse != null)
Args.serverResponse.Close();
Args.finishedRequestEvent.Set();
}
}
}
}
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">x86</Platform>
<ProductVersion>8.0.30703</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>Titanium.HTTPProxyServer</RootNamespace>
<AssemblyName>Titanium.HTTPProxyServer</AssemblyName>
<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
<TargetFrameworkProfile>Client</TargetFrameworkProfile>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
<PlatformTarget>AnyCPU</PlatformTarget>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
<PlatformTarget>x86</PlatformTarget>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup>
<StartupObject />
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'">
<PlatformTarget>AnyCPU</PlatformTarget>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG</DefineConstants>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|AnyCPU'">
<PlatformTarget>AnyCPU</PlatformTarget>
<OutputPath>bin\Release\</OutputPath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
<OutputPath>bin\x64\Debug\</OutputPath>
<PlatformTarget>x64</PlatformTarget>
<CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
<CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
<CodeAnalysisFailOnMissingRules>true</CodeAnalysisFailOnMissingRules>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
<OutputPath>bin\x64\Release\</OutputPath>
<PlatformTarget>x64</PlatformTarget>
<CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
<CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
<CodeAnalysisFailOnMissingRules>true</CodeAnalysisFailOnMissingRules>
</PropertyGroup>
<ItemGroup>
<Reference Include="Ionic.Zip">
<HintPath>..\packages\DotNetZip.1.9.3\lib\net20\Ionic.Zip.dll</HintPath>
</Reference>
<Reference Include="System" />
<Reference Include="System.configuration" />
<Reference Include="System.Core" />
<Reference Include="System.Xml.Linq" />
<Reference Include="System.Data.DataSetExtensions" />
<Reference Include="Microsoft.CSharp" />
<Reference Include="System.Data" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="CredentialManager.cs" />
<Compile Include="RequestHandler.cs" />
<Compile Include="RequestManager.cs" />
<Compile Include="ResponseManager.cs" />
<Compile Include="Utility\CertificateUtils.cs" />
<Compile Include="Utility\CustomBinaryReader.cs" />
<Compile Include="Utility\OtherUtils.cs" />
<Compile Include="Compression\EncodeCompressionUtils.cs" />
<Compile Include="ProxyServer.cs" />
<Compile Include="EventArgs\SessionEventArgs.cs" />
<Compile Include="Utility\RawTCPRelay.cs" />
<Compile Include="Utility\StreamExtensions.cs" />
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
<ItemGroup>
<None Include="packages.config" />
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>
\ No newline at end of file
using System;
using System.Security.Cryptography.X509Certificates;
using System.Diagnostics;
using System.Threading;
namespace HTTPProxyServer
{
public partial class ProxyServer
{
static X509Store store;
private static X509Certificate2 getCertificate(string hostname)
{
if (store == null)
{
store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadOnly);
}
var CachedCertificate = getCertifiateFromStore(hostname);
if(CachedCertificate==null)
CreateClientCertificate(hostname);
return getCertifiateFromStore(hostname);
}
public static X509Certificate2 getCertifiateFromStore(string hostname)
{
X509Certificate2Collection certificateCollection = store.Certificates.Find(X509FindType.FindBySubjectName, hostname, true);
foreach(var certificate in certificateCollection)
{
if (certificate.SubjectName.Name.StartsWith("CN=" + hostname) && certificate.IssuerName.Name.StartsWith("CN=Titanium_Proxy_Test_Root"))
return certificate;
}
return null;
}
public static void CreateClientCertificate(string hostname)
{
Process process = new Process();
// Stop the process from opening a new window
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.UseShellExecute = false;
process.StartInfo.CreateNoWindow = true;
// Setup executable and parameters
process.StartInfo.FileName = @"makecert.exe";
process.StartInfo.Arguments = @"-pe -ss my -n ""CN=" + hostname + @""" -sky exchange -in Titanium_Proxy_Test_Root -is my -eku 1.3.6.1.5.5.7.3.1 -cy end -a sha1 -m 132 -b 10/07/2012";
// Go
process.Start();
process.WaitForExit();
}
#region old
//public System.Security.Cryptography.X509Certificates.X509Certificate2 CreateClientCertificate(string hostname, System.Security.Cryptography.X509Certificates.X509Certificate2 rootCertificate)
//{
// // get the server certificate
// Org.BouncyCastle.X509.X509Certificate CA = DotNetUtilities.FromX509Certificate(rootCertificate);
// AsymmetricKeyParameter bouncyCastlePrivateKey = TransformRSAPrivateKey(rootCertificate.PrivateKey);
// var kpgen = new RsaKeyPairGenerator();
// kpgen.Init(new KeyGenerationParameters(new SecureRandom(new CryptoApiRandomGenerator()), 1024));
// var kp = kpgen.GenerateKeyPair();
// // generate the client certificate
// X509V3CertificateGenerator generator = new X509V3CertificateGenerator();
// generator.SetSerialNumber(BigInteger.ProbablePrime(120, new Random()));
// generator.SetIssuerDN(CA.SubjectDN);
// generator.SetNotBefore(DateTime.Now);
// generator.SetNotAfter(DateTime.Now.AddYears(5));
// generator.SetSubjectDN(new X509Name("CN=" + hostname));
// generator.SetPublicKey(kp.Public);
// generator.SetSignatureAlgorithm("SHA1withRSA");
// generator.AddExtension(X509Extensions.AuthorityKeyIdentifier, false, new AuthorityKeyIdentifierStructure(CA));
// generator.AddExtension(X509Extensions.SubjectKeyIdentifier, false, new SubjectKeyIdentifierStructure(kp.Public));
// var newClientCert = generator.Generate(bouncyCastlePrivateKey);
// // newClientCert.Verify(CA.GetPublicKey());
// var cert = new X509Certificate2(Org.BouncyCastle.Security.DotNetUtilities.ToX509Certificate(newClientCert));
// cert.PrivateKey = getDotNetPrivateKey(kp.Private);
// return cert;
//}
//private AsymmetricKeyParameter TransformRSAPrivateKey(AsymmetricAlgorithm privateKey)
//{
// RSACryptoServiceProvider prov = privateKey as RSACryptoServiceProvider;
// RSAParameters parameters = prov.ExportParameters(true);
// return new RsaPrivateCrtKeyParameters(
// new BigInteger(1, parameters.Modulus),
// new BigInteger(1, parameters.Exponent),
// new BigInteger(1, parameters.D),
// new BigInteger(1, parameters.P),
// new BigInteger(1, parameters.Q),
// new BigInteger(1, parameters.DP),
// new BigInteger(1, parameters.DQ),
// new BigInteger(1, parameters.InverseQ));
//}
//private RSACryptoServiceProvider getDotNetPrivateKey(AsymmetricKeyParameter kp)
//{
// // Apparently, using DotNetUtilities to convert the private key is a little iffy. Have to do some init up front.
// RSACryptoServiceProvider tempRcsp = (RSACryptoServiceProvider)DotNetUtilities.ToRSA((RsaPrivateCrtKeyParameters)kp);
// RSACryptoServiceProvider rcsp = new RSACryptoServiceProvider(new CspParameters(1, "Microsoft Strong Cryptographic Provider",
// new Guid().ToString(),
// new CryptoKeySecurity(), null));
// rcsp.ImportCspBlob(tempRcsp.ExportCspBlob(true));
// return rcsp;
//}
#endregion
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Diagnostics;
namespace HTTPProxyServer.Utility
{
public class CustomBinaryReader : BinaryReader
{
public CustomBinaryReader(Stream stream, Encoding encoding)
: base(stream, encoding)
{
}
public string ReadLine()
{
try
{
char[] buf = new char[1];
StringBuilder _readBuffer = new StringBuilder();
var charsRead = 0;
char lastChar = new char();
while ((charsRead = base.Read(buf, 0, 1)) > 0)
{
if (lastChar == '\r' && buf[0] == '\n')
{
return _readBuffer.Remove(_readBuffer.Length - 1, 1).ToString();
}
else
if (buf[0] == '\0')
{
return _readBuffer.ToString();
}
else
_readBuffer.Append(buf[0]);
lastChar = buf[0];
}
return _readBuffer.ToString();
}
catch { throw new EndOfStreamException(); }
}
}
}
using System;
using System.Collections.Generic;
using System.Net;
using System.IO;
using System.Reflection;
using HTTPProxyServer.Utility;
using System.Linq;
namespace HTTPProxyServer
{
public partial class ProxyServer
{
private static void URLPeriodFix()
{
MethodInfo getSyntax = typeof(UriParser).GetMethod("GetSyntax", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
FieldInfo flagsField = typeof(UriParser).GetField("m_Flags", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
if (getSyntax != null && flagsField != null)
{
foreach (string scheme in new[] { "http", "https" })
{
UriParser parser = (UriParser)getSyntax.Invoke(null, new object[] { scheme });
if (parser != null)
{
int flagsValue = (int)flagsField.GetValue(parser);
if ((flagsValue & 0x1000000) != 0)
flagsField.SetValue(parser, flagsValue & ~0x1000000);
}
}
}
}
private static List<Tuple<String, String>> ProcessResponse(HttpWebResponse response)
{
String value = null;
String header = null;
List<Tuple<String, String>> returnHeaders = new List<Tuple<String, String>>();
foreach (String s in response.Headers.Keys)
{
if (s.ToLower() == "set-cookie")
{
header = s;
value = response.Headers[s];
}
else
returnHeaders.Add(new Tuple<String, String>(s, response.Headers[s]));
}
if (!String.IsNullOrWhiteSpace(value))
{
response.Headers.Remove(header);
String[] cookies = cookieSplitRegEx.Split(value);
foreach (String cookie in cookies)
returnHeaders.Add(new Tuple<String, String>("Set-Cookie", cookie));
}
return returnHeaders;
}
private static void WriteResponseStatus(Version version, HttpStatusCode code, String description, StreamWriter myResponseWriter)
{
String s = String.Format("HTTP/{0}.{1} {2} {3}", version.Major, version.Minor, (Int32)code, description);
myResponseWriter.WriteLine(s);
}
private static void WriteResponseHeaders(StreamWriter myResponseWriter, List<Tuple<String, String>> headers)
{
if (headers != null)
{
foreach (Tuple<String, String> header in headers)
{
myResponseWriter.WriteLine(String.Format("{0}: {1}", header.Item1, header.Item2));
}
}
myResponseWriter.WriteLine();
myResponseWriter.Flush();
}
private static void WriteResponseHeaders(StreamWriter myResponseWriter, List<Tuple<String, String>> headers, int length)
{
if (headers != null)
{
foreach (Tuple<String, String> header in headers)
{
if (header.Item1.ToLower() != "content-length")
myResponseWriter.WriteLine(String.Format("{0}: {1}", header.Item1, header.Item2));
else
myResponseWriter.WriteLine(String.Format("{0}: {1}", "content-length", length.ToString()));
}
}
myResponseWriter.WriteLine();
myResponseWriter.Flush();
}
//NEED to optimize this call later
private static string getHostName(ref Queue<string> requestLines)
{
String httpCmd = requestLines.Dequeue();
while (!String.IsNullOrWhiteSpace(httpCmd))
{
String[] header = httpCmd.Split(colonSpaceSplit, 2, StringSplitOptions.None);
switch (header[0].ToLower())
{
case "host":
var hostdetail = header[1];
if (hostdetail.Contains(":"))
return hostdetail.Split(':')[0].Trim();
else
return hostdetail.Trim();
default:
break;
}
httpCmd = requestLines.Dequeue();
}
return null;
}
private static void ReadRequestHeaders(ref List<string> requestLines, HttpWebRequest webReq)
{
for(int i=1; i<requestLines.Count; i++)
{
String httpCmd = requestLines[i];
String[] header = httpCmd.Split(colonSpaceSplit, 2, StringSplitOptions.None);
if(!String.IsNullOrEmpty(header[0].Trim()))
switch (header[0].ToLower())
{
case "accept":
webReq.Accept = header[1];
break;
case "accept-encoding":
webReq.Headers.Add(header[0], "gzip,deflate,zlib");
break;
case "cookie":
webReq.Headers["Cookie"] = header[1];
break;
case "connection":
if (header[1].ToLower() == "keep-alive")
webReq.KeepAlive = true;
break;
case "content-length":
int contentLen;
int.TryParse(header[1], out contentLen);
if (contentLen != 0)
webReq.ContentLength = contentLen;
break;
case "content-type":
webReq.ContentType = header[1];
break;
case "expect":
if (header[1].ToLower() == "100-continue")
webReq.ServicePoint.Expect100Continue = true;
else
webReq.Expect = header[1];
break;
case "host":
webReq.Host = header[1];
break;
case "if-modified-since":
String[] sb = header[1].Trim().Split(semiSplit);
DateTime d;
if (DateTime.TryParse(sb[0], out d))
webReq.IfModifiedSince = d;
break;
case "proxy-connection":
break;
case "range":
var startEnd = header[1].Replace(Environment.NewLine, "").Remove(0, 6).Split('-');
if (startEnd.Length > 1) { if (!String.IsNullOrEmpty(startEnd[1])) webReq.AddRange(int.Parse(startEnd[0]), int.Parse(startEnd[1])); else webReq.AddRange(int.Parse(startEnd[0])); }
else
webReq.AddRange(int.Parse(startEnd[0]));
break;
case "referer":
webReq.Referer = header[1];
break;
case "user-agent":
webReq.UserAgent = header[1];
break;
case "transfer-encoding":
if (header[1].ToLower() == "chunked")
webReq.SendChunked = true;
else
webReq.SendChunked = false;
break;
case "upgrade":
if (header[1].ToLower() == "http/1.1")
webReq.Headers.Add(header[0], header[1]);
break;
default:
if(header.Length>0)
webReq.Headers.Add(header[0], header[1]);
else
webReq.Headers.Add(header[0], "");
break;
}
}
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using HTTPProxyServer.Utility;
using System.Net.Security;
using System.IO;
using System.Net;
namespace HTTPProxyServer
{
public partial class ProxyServer
{
public static void sendRaw(string hostname, int tunnelPort, System.IO.Stream clientStream)
{
System.Net.Sockets.TcpClient tunnelClient = new System.Net.Sockets.TcpClient(hostname, tunnelPort);
var tunnelStream = tunnelClient.GetStream();
var tunnelReadBuffer = new byte[BUFFER_SIZE];
Thread sendRelay = new Thread(() => StreamUtilities.CopyTo(clientStream, tunnelStream, BUFFER_SIZE));
Thread receiveRelay = new Thread(() => StreamUtilities.CopyTo(tunnelStream, clientStream, BUFFER_SIZE));
sendRelay.Start();
receiveRelay.Start();
sendRelay.Join();
receiveRelay.Join();
if (tunnelStream != null)
tunnelStream.Close();
if (tunnelClient != null)
tunnelClient.Close();
}
private static void sendRaw(string httpCmd, string secureHostName, ref List<string> requestLines, bool isSecure, Stream clientStream)
{
StringBuilder sb = new StringBuilder();
sb.Append(httpCmd);
sb.Append(Environment.NewLine);
string hostname= secureHostName;
for(int i = 1; i < requestLines.Count;i++)
{
var header = requestLines[i];
if (secureHostName == null)
{
String[] headerParsed = httpCmd.Split(colonSpaceSplit, 2, StringSplitOptions.None);
switch (headerParsed[0].ToLower())
{
case "host":
var hostdetail = headerParsed[1];
if (hostdetail.Contains(":"))
hostname = hostdetail.Split(':')[0].Trim();
else
hostname = hostdetail.Trim();
break;
default:
break;
}
}
sb.Append(header);
sb.Append(Environment.NewLine);
}
sb.Append(Environment.NewLine);
if (hostname == null)
{
// Dns.geth
}
int tunnelPort = 80;
if (isSecure)
{
tunnelPort = 443;
}
System.Net.Sockets.TcpClient tunnelClient = new System.Net.Sockets.TcpClient(hostname, tunnelPort);
var tunnelStream = (System.IO.Stream)tunnelClient.GetStream();
if (isSecure)
{
var sslStream = new SslStream(tunnelStream);
sslStream.AuthenticateAsClient(hostname);
tunnelStream = sslStream;
}
Thread sendRelay = new Thread(() => StreamUtilities.CopyTo(sb.ToString(), clientStream, tunnelStream, BUFFER_SIZE));
Thread receiveRelay = new Thread(() => StreamUtilities.CopyTo(tunnelStream, clientStream, BUFFER_SIZE));
sendRelay.Start();
receiveRelay.Start();
sendRelay.Join();
receiveRelay.Join();
if (tunnelStream != null)
tunnelStream.Close();
if (tunnelClient != null)
tunnelClient.Close();
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
namespace HTTPProxyServer.Utility
{
public static class StreamUtilities
{
private const int DEFAULT_BUFFER_SIZE = 8192; // +32767
public static void CopyTo(this Stream input, Stream output)
{
input.CopyTo(output, DEFAULT_BUFFER_SIZE);
return;
}
public static void CopyTo(string initialData, Stream input, Stream output, int bufferSize)
{
var bytes = Encoding.ASCII.GetBytes(initialData);
output.Write(bytes,0, bytes.Length);
CopyTo(input, output, bufferSize);
}
public static void CopyTo(this Stream input, Stream output, int bufferSize)
{
try
{
if (!input.CanRead) throw new InvalidOperationException("input must be open for reading");
if (!output.CanWrite) throw new InvalidOperationException("output must be open for writing");
byte[][] buf = { new byte[bufferSize], new byte[bufferSize] };
int[] bufl = { 0, 0 };
int bufno = 0;
IAsyncResult read = input.BeginRead(buf[bufno], 0, buf[bufno].Length, null, null);
IAsyncResult write = null;
while (true)
{
// wait for the read operation to complete
read.AsyncWaitHandle.WaitOne();
bufl[bufno] = input.EndRead(read);
// if zero bytes read, the copy is complete
if (bufl[bufno] == 0)
{
break;
}
// wait for the in-flight write operation, if one exists, to complete
// the only time one won't exist is after the very first read operation completes
if (write != null)
{
write.AsyncWaitHandle.WaitOne();
output.EndWrite(write);
}
// start the new write operation
write = output.BeginWrite(buf[bufno], 0, bufl[bufno], null, null);
// toggle the current, in-use buffer
// and start the read operation on the new buffer.
//
// Changed to use XOR to toggle between 0 and 1.
// A little speedier than using a ternary expression.
bufno ^= 1; // bufno = ( bufno == 0 ? 1 : 0 ) ;
read = input.BeginRead(buf[bufno], 0, buf[bufno].Length, null, null);
}
// wait for the final in-flight write operation, if one exists, to complete
// the only time one won't exist is if the input stream is empty.
if (write != null)
{
write.AsyncWaitHandle.WaitOne();
output.EndWrite(write);
}
output.Flush();
}
catch { }
// return to the caller ;
return;
}
}
}
<?xml version="1.0" encoding="utf-8"?>
<packages>
<package id="DotNetZip" version="1.9.3" targetFramework="net40-Client" />
</packages>
\ No newline at end of file

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.30501.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Library", "Library", "{B6DBABDC-C985-4872-9C38-B4E5079CBC4B}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Titanium.HTTPProxyServer", "Titanium.HTTPProxyServer\Titanium.HTTPProxyServer.csproj", "{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Titanium.ProxyTest", "Titanium.ProxyTest\Titanium.ProxyTest.csproj", "{F3B7E553-1904-4E80-BDC7-212342B5C952}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|Any CPU = Release|Any CPU
Release|x64 = Release|x64
Release|x86 = Release|x86
Release-Plus|Any CPU = Release-Plus|Any CPU
Release-Plus|x64 = Release-Plus|x64
Release-Plus|x86 = Release-Plus|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Debug|Any CPU.Build.0 = Debug|Any CPU
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Debug|x64.ActiveCfg = Debug|x64
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Debug|x64.Build.0 = Debug|x64
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Debug|x86.ActiveCfg = Debug|x86
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Debug|x86.Build.0 = Debug|x86
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Release|Any CPU.ActiveCfg = Release|Any CPU
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Release|Any CPU.Build.0 = Release|Any CPU
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Release|x64.ActiveCfg = Release|x64
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Release|x64.Build.0 = Release|x64
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Release|x86.ActiveCfg = Release|x86
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Release|x86.Build.0 = Release|x86
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Release-Plus|Any CPU.ActiveCfg = Release|Any CPU
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Release-Plus|Any CPU.Build.0 = Release|Any CPU
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Release-Plus|x64.ActiveCfg = Release|x64
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Release-Plus|x64.Build.0 = Release|x64
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Release-Plus|x86.ActiveCfg = Release|x86
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906}.Release-Plus|x86.Build.0 = Release|x86
{F3B7E553-1904-4E80-BDC7-212342B5C952}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{F3B7E553-1904-4E80-BDC7-212342B5C952}.Debug|Any CPU.Build.0 = Debug|Any CPU
{F3B7E553-1904-4E80-BDC7-212342B5C952}.Debug|x64.ActiveCfg = Debug|Any CPU
{F3B7E553-1904-4E80-BDC7-212342B5C952}.Debug|x86.ActiveCfg = Debug|Any CPU
{F3B7E553-1904-4E80-BDC7-212342B5C952}.Release|Any CPU.ActiveCfg = Release|Any CPU
{F3B7E553-1904-4E80-BDC7-212342B5C952}.Release|Any CPU.Build.0 = Release|Any CPU
{F3B7E553-1904-4E80-BDC7-212342B5C952}.Release|x64.ActiveCfg = Release|Any CPU
{F3B7E553-1904-4E80-BDC7-212342B5C952}.Release|x86.ActiveCfg = Release|Any CPU
{F3B7E553-1904-4E80-BDC7-212342B5C952}.Release-Plus|Any CPU.ActiveCfg = Release|Any CPU
{F3B7E553-1904-4E80-BDC7-212342B5C952}.Release-Plus|Any CPU.Build.0 = Release|Any CPU
{F3B7E553-1904-4E80-BDC7-212342B5C952}.Release-Plus|x64.ActiveCfg = Release|Any CPU
{F3B7E553-1904-4E80-BDC7-212342B5C952}.Release-Plus|x86.ActiveCfg = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(NestedProjects) = preSolution
{8D73A1BE-868C-42D2-9ECE-F32CC1A02906} = {B6DBABDC-C985-4872-9C38-B4E5079CBC4B}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
EnterpriseLibraryConfigurationToolBinariesPath = .1.505.2\lib\NET35
EndGlobalSection
EndGlobal
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<configSections>
<section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration" />
<section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />
</configSections>
<connectionStrings>
<add name="SqlCELogConnectionString" providerName="System.Data.SqlServerCe.4.0" connectionString="Data Source=Log.sdf" />
<add name="SqlCEEventsConnectionString" providerName="System.Data.SqlServerCe.4.0" connectionString="Data Source=Events.sdf" />
<add name="SqlCEFilesConnectionString" providerName="System.Data.SqlServerCe.4.0" connectionString="Data Source=Files.sdf" />
<add name="SqlServerLogConnectionString" connectionString="Data Source=.\SQLEXPRESS;Initial Catalog=ASXLog;Integrated Security=True;Enlist=False;" providerName="System.Data.SqlClient" />
<add name="SqlServerEventsConnectionString" connectionString="Data Source=.\SQLEXPRESS;Initial Catalog=ASXEvents;Integrated Security=True;Enlist=False;" providerName="System.Data.SqlClient" />
<add name="SqlServerFilesConnectionString" connectionString="Data Source=.\SQLEXPRESS;Initial Catalog=ASXFiles;Integrated Security=True;Enlist=False;" providerName="System.Data.SqlClient" />
<add name="SqlServerSettingsConnectionString" connectionString="Data Source=.\SQLEXPRESS;Initial Catalog=ASXSettings;Integrated Security=True;Enlist=False;" providerName="System.Data.SqlClient" />
</connectionStrings>
<entityFramework>
<defaultConnectionFactory type="System.Data.Entity.Infrastructure.SqlCeConnectionFactory, EntityFramework">
<parameters>
<parameter value="System.Data.SqlServerCe.4.0" />
</parameters>
</defaultConnectionFactory>
<providers>
<provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" />
<provider invariantName="System.Data.SqlServerCe.4.0" type="System.Data.Entity.SqlServerCompact.SqlCeProviderServices, EntityFramework.SqlServerCompact" />
</providers>
</entityFramework>
<unity configSource="unity.debug.xml" />
<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0,Profile=Client" /></startup></configuration>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using Titanium.ProxyManager.Utitlity;
using System.Text.RegularExpressions;
using Titanium.ProxyManager;
using System.DirectoryServices.AccountManagement;
using System.DirectoryServices.ActiveDirectory;
using HTTPProxyServer;
namespace Titanium.Proxy
{
public partial class Controller
{
private List<string> _URLList = new List<string>();
private string _lastURL = string.Empty;
private ProxyServer _server;
public static void Main(string[] args)
{
var controller = new Controller();
controller.StartProxy();
Console.WriteLine("To make Http(s) work install the test root certificate included in this project to both Personal and Trusted Root Certificate Authorities of client machine");
Console.WriteLine("Hit any key to exit");
Console.Read();
controller.Stop();
}
public void StartProxy()
{
_server = new ProxyServer();
_server.BeforeRequest += OnRequest;
_server.BeforeResponse += OnResponse;
_server.Start();
Console.WriteLine(String.Format("Proxy listening on local machine port: {0} ", _server.ListeningPort));
}
public void Stop()
{
_server.BeforeRequest -= OnRequest;
_server.BeforeResponse -= OnResponse;
_server.Stop();
}
public delegate void SiteVisitedEventHandler(VisitedEventArgs e);
public event SiteVisitedEventHandler Visited;
// Invoke the Changed event; called whenever list changes
protected virtual void OnChanged(VisitedEventArgs e)
{
if (Visited != null)
Visited(e);
}
//Test On Request, intecept requests
//Read browser URL send back to proxy by the injection script in OnResponse event
public void OnRequest(object sender, SessionEventArgs e)
{
string Random = e.requestURL.Substring(e.requestURL.LastIndexOf(@"/") + 1);
int index = _URLList.IndexOf(Random);
if (index >= 0)
{
string URL = e.decode();
if (_lastURL != URL)
{
OnChanged(new VisitedEventArgs() { hostname = e.hostName, URL = URL, remoteIP = e.ipAddress, remotePort = e.port });
}
e.Ok();
_lastURL = URL;
}
}
//Test script injection
//Insert script to read the Browser URL and send it back to proxy
public void OnResponse(object sender, SessionEventArgs e)
{
try
{
if (e.proxyRequest.Method == "GET" || e.proxyRequest.Method == "POST")
{
if (e.serverResponse.StatusCode == HttpStatusCode.OK)
{
if (e.serverResponse.ContentType.Trim().ToLower().Contains("text/html"))
{
string c = e.serverResponse.GetResponseHeader("X-Requested-With");
if (e.serverResponse.GetResponseHeader("X-Requested-With") == "")
{
e.getResponseBody();
string functioname = "fr" + RandomString(10);
string VisitedURL = RandomString(5);
string RequestVariable = "c" + RandomString(5);
string RandomURLEnding = RandomString(25);
string RandomLastRequest = RandomString(10);
string LocalRequest;
if (e.isSecure)
LocalRequest = "https://" + e.hostName + "/" + RandomURLEnding;
else
LocalRequest = "http://" + e.hostName + "/" + RandomURLEnding;
string script = "var " + RandomLastRequest + " = null;" +
"if(window.top==self) { " + "\n" +
" " + functioname + "();" +
"setInterval(" + functioname + ",500); " + "\n" + "}" +
"function " + functioname + "(){ " + "\n" +
"var " + RequestVariable + " = new XMLHttpRequest(); " + "\n" +
"var " + VisitedURL + " = null;" + "\n" +
"if(window.top.location.href!=null) " + "\n" +
"" + VisitedURL + " = window.top.location.href; else " + "\n" +
"" + VisitedURL + " = document.referrer; " +
"if(" + RandomLastRequest + "!= " + VisitedURL + ") {" +
RequestVariable + ".open(\"POST\",\"" + LocalRequest + "\", true); " + "\n" +
RequestVariable + ".send(" + VisitedURL + ");} " + RandomLastRequest + " = " + VisitedURL + "}";
string response = e.responseString;
Regex RE = new Regex("</body>", RegexOptions.RightToLeft | RegexOptions.IgnoreCase | RegexOptions.Multiline);
string replaced = RE.Replace(response, "<script type =\"text/javascript\">" + script + "</script></body>", 1);
if (replaced.Length != response.Length)
{
e.responseString = replaced;
_URLList.Add(RandomURLEnding);
}
}
}
}
}
}
catch { }
}
private Random random = new Random((int)DateTime.Now.Ticks);
private string RandomString(int size)
{
StringBuilder builder = new StringBuilder();
char ch;
for (int i = 0; i < size; i++)
{
ch = Convert.ToChar(Convert.ToInt32(Math.Floor(26 * random.NextDouble() + 65)));
builder.Append(ch);
}
return builder.ToString();
}
}
public class VisitedEventArgs : EventArgs
{
public string URL;
public string hostname;
public IPAddress remoteIP { get; set; }
public int remotePort { get; set; }
}
}
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("Demo")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Demo")]
[assembly: AssemblyCopyright("Copyright ©2013 Telerik")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("33a2109d-0312-4c94-aa51-fbb2a83e63ab")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>8.0.30703</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{F3B7E553-1904-4E80-BDC7-212342B5C952}</ProjectGuid>
<OutputType>Exe</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>Titanium.ProxyManager</RootNamespace>
<AssemblyName>Titanium.ProxyManager</AssemblyName>
<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<TargetFrameworkProfile>Client</TargetFrameworkProfile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup>
<StartupObject />
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<Reference Include="System.ComponentModel.DataAnnotations" />
<Reference Include="System.configuration" />
<Reference Include="System.Core" />
<Reference Include="System.DirectoryServices" />
<Reference Include="System.DirectoryServices.AccountManagement" />
<Reference Include="System.DirectoryServices.Protocols" />
<Reference Include="System.ServiceModel" />
<Reference Include="System.ServiceModel.Discovery" />
<Reference Include="System.Xml.Linq" />
<Reference Include="System.Data.DataSetExtensions" />
<Reference Include="Microsoft.CSharp" />
<Reference Include="System.Data" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Controller.cs" />
<Compile Include="Utility\ProcessDetails.cs" />
</ItemGroup>
<ItemGroup>
<Content Include="makecert.exe">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</Content>
<Content Include="unity.debug.xml">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</Content>
</ItemGroup>
<ItemGroup>
<None Include="App.config" />
<None Include="Titanium Proxy Test Root Certificate.cer" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Titanium.HTTPProxyServer\Titanium.HTTPProxyServer.csproj">
<Project>{8d73a1be-868c-42d2-9ece-f32cc1a02906}</Project>
<Name>Titanium.HTTPProxyServer</Name>
</ProjectReference>
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<PropertyGroup>
</PropertyGroup>
<Import Project="..\..\..\lib\packages\AutoMapper.3.3.0\tools\AutoMapper.targets" Condition="Exists('..\..\..\lib\packages\AutoMapper.3.3.0\tools\AutoMapper.targets')" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>
\ No newline at end of file
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<ProjectView>ShowAllFiles</ProjectView>
</PropertyGroup>
</Project>
\ No newline at end of file
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Management;
using System.Diagnostics;
namespace Titanium.ProxyManager.Utitlity
{
public class TcpHelperUtil
{
private const short MINIMUM_TOKEN_IN_A_LINE = 5;
private const string COMMAND_EXE = @"cmd.exe";
public static int GetProcessId(int port)
{
try
{
// execute netstat command for the given port
string commandArgument = string.Format("/c netstat -an -o -p tcp|findstr \":{0}.*ESTABLISHED", port);
string commandOut = ExecuteCommandAndCaptureOutput(COMMAND_EXE, commandArgument);
if (string.IsNullOrEmpty(commandOut))
{
// port is not in use
return 0;
}
string[] stringTokens = commandOut.Split(default(Char[]), StringSplitOptions.RemoveEmptyEntries);
if (stringTokens.Length < MINIMUM_TOKEN_IN_A_LINE)
{
return 0;
}
if (stringTokens.Length == 10)
return int.Parse(stringTokens[9].Trim());
else
return 0;
}
catch { return 0; }
}
/// <summary>
/// Execute the given command and captures the output
/// </summary>
/// <param name="commandName"></param>
/// <param name="arguments"></param>
/// <returns></returns>
private static string ExecuteCommandAndCaptureOutput(string commandName, string arguments)
{
string commandOut = string.Empty;
Process process = new Process();
process.StartInfo.FileName = commandName;
process.StartInfo.Arguments = arguments;
process.StartInfo.UseShellExecute = false;
process.StartInfo.CreateNoWindow = true;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.Start();
commandOut = process.StandardOutput.ReadToEnd();
string errors = process.StandardError.ReadToEnd();
try
{
process.WaitForExit(TimeSpan.FromSeconds(2).Milliseconds);
}
catch
{
}
return commandOut;
}
}
}
<?xml version="1.0" encoding="utf-8" ?>
<unity>
<assembly name="Titanium.Interfaces"/>
<assembly name="Titanium.Data.Repository"/>
<containers>
<container>
<types>
<type type ="Titanium.Interfaces.Repository.ILogRepository,Titanium.Interfaces" mapTo="Titanium.Data.Repository.SqlServer.SqlServerLogRepository,Titanium.Data.Repository" />
<type type ="Titanium.Interfaces.Repository.IEventsRepository,Titanium.Interfaces" mapTo="Titanium.Data.Repository.SqlServer.SqlServerEventsRepository,Titanium.Data.Repository" />
<type type ="Titanium.Interfaces.Repository.ISettingsRepository,Titanium.Interfaces" mapTo="Titanium.Data.Repository.SqlServer.SqlServerSettingsRepository,Titanium.Data.Repository" />
</types>
</container>
</containers>
</unity>
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment