public static ProxyCache add_ProxyCacheLogViewer(this ProxyCache proxyCache, Control control)
        {
            var cacheLog = control.add_TreeView()
                           .hideSelection()
                           .onDoubleClick <RequestResponseData>((requestResponseData) => requestResponseData.details());

            proxyCache.ProxyCacheLogEntry =
                (logLine, requestResponseData)
                => {
                //cacheLog.insert_TreeNode(logLine, requestResponseData, 0).nodes()[0]
                if (proxyCache.ShowItemInLog(logLine, requestResponseData))
                {
                    if (requestResponseData.notNull())
                    {
                        logLine = "{0}  size: {1}".format(logLine, requestResponseData.Response_Bytes.notNull()
                                                                                                                                                                        ? requestResponseData.Response_Bytes.Length
                                                                                                                                                                        : -1);
                    }
                    cacheLog.add_Node(logLine, requestResponseData)
                    .color(requestResponseData.isNull()
                                                                                        ? Color.Gray
                                                                                        : Color.DarkGreen)
                    .selected();
                }
            };
            return(proxyCache);
        }
        /*public static byte[] response_Bytes(this ProxyCache proxyCache, string key)
         * {
         *      if (proxyCache.hasMapping(key))
         *              return proxyCache.requestMappings().value(key).Response_Bytes;
         *      return null;
         * }
         *
         * public static string response_String(this ProxyCache proxyCache, string key)
         * {
         *      if (proxyCache.hasMapping(key))
         *              return proxyCache.requestMappings().value(key).Response_String;
         *      return null;
         * }*/

        public static ProxyCache add_ToCache(this ProxyCache proxyCache, RequestResponseData requestResponseData)
        {
            var requestPostBytes = requestResponseData.Request_PostBytes;
            var cacheKey         = proxyCache.cacheKey(requestResponseData);

            ProxyCache.Requests.Add(requestResponseData);
            ProxyCache.RequestCache.add(cacheKey, requestResponseData);
            return(proxyCache);
        }
        public void setDefaultValues()
        {
            proxyCache      = new ProxyCache();
            CaptureRequests = true;
            this.clearPastRequests();
            IPAddress ipAddress = IPAddress.Loopback;

            IPAddress.TryParse("127.0.0.1", out ipAddress);
            ListeningIPInterface = ipAddress;
            ListeningPort        = 8081;
        }
 public static Control add_ProxyCacheActionsPanel(this ProxyCache proxyCache, Control actionsPanel)
 {
     actionsPanel.add_Label("Settings")
     .append_CheckBox("cache Enabled", (value) => proxyCache.enabled(value)).@checked(proxyCache.enabled())
     .append_Below_Link("show Cache entries", () => ProxyCache.RequestCache.details())
     .append_Link("clear Cache", () => ProxyCache.RequestCache.Clear())
     .append_Link("open a WebBrowser", () => "ProxyChache - test WebBrowser".popupWindow()
                  .add_WebBrowser_Control()
                  .add_NavigationBar()
                  .open("http://www.google.com"));
     return(actionsPanel);
 }
        public static RequestResponseData getMapping(this ProxyCache proxyCache, HttpWebRequest webRequest, byte[] requestPostBytes)
        {
            var cacheKey    = proxyCache.ProxyCache_Brain.cacheKey(webRequest, requestPostBytes);
            var cacheObject = proxyCache.ProxyCache_Brain.getMapping(cacheKey);

            proxyCache.ProxyCacheLogEntry(cacheObject.isNull()
                                                                                                ? "{0}	         (not in cache)".format(cacheKey)
                                                                                                : "{0}           (from cache)".format(cacheKey),
                                          cacheObject);
            if (cacheObject.notNull())
            {
                cacheObject.CacheHits++;
            }
            return(cacheObject);
        }
        public static RequestResponseData add(this  ProxyCache proxyCache,
                                              HttpWebRequest webRequest,
                                              HttpWebResponse webResponse,
                                              byte[] requestPostBytes,
                                              byte[] responseBytes,
                                              string responseString)
        {
            var requestResponseData = new RequestResponseData()
            {
                WebRequest      = webRequest,
                WebResponse     = webResponse,
                Response_Bytes  = responseBytes,
                Response_String = responseString
            };

            if (requestPostBytes.notNull())
            {
                requestResponseData.Request_PostBytes  = requestPostBytes;
                requestResponseData.Request_PostString = requestPostBytes.ascii();
            }
            proxyCache.add_ToCache(requestResponseData);
            return(requestResponseData);
        }
 public static Control insert_Above_ProxyCacheActionsPanel(this Control control, ProxyCache proxyCache)
 {
     return(proxyCache.add_ProxyCacheActionsPanel(control.insert_Above(60, "actions")));
 }
 public static Control insert_Below_ProxyCacheActionsPanel(this Control control, ProxyCache proxyCache)
 {
     return(proxyCache.add_ProxyCacheActionsPanel(control.insert_Below(60, "")));
 }
 public static T add_ProxyCacheLogViewer <T>(this T control, ProxyCache proxyCache)
     where T : Control
 {
     proxyCache.add_ProxyCacheLogViewer(control);
     return(control);
 }
Esempio n. 10
0
 public static string cacheKey(this ProxyCache proxyCache, RequestResponseData requestResponseData)
 {
     return(proxyCache.ProxyCache_Brain.cacheKey(requestResponseData));
 }
Esempio n. 11
0
        public static bool hasMapping(this ProxyCache proxyCache, HttpWebRequest webRequest, byte[] requestPostBytes)
        {
            var cacheKey = proxyCache.ProxyCache_Brain.cacheKey(webRequest, requestPostBytes);

            return(proxyCache.ProxyCache_Brain.hasMapping(cacheKey));
        }
Esempio n. 12
0
 public static Dictionary <string, RequestResponseData> requestMappings(this ProxyCache proxyCache)
 {
     return(ProxyCache.RequestCache);
 }
Esempio n. 13
0
 public static ProxyCache enabled(this ProxyCache proxyCache, bool value)
 {
     proxyCache.CacheEnabled = value;
     return(proxyCache);
 }
Esempio n. 14
0
 public static bool enabled(this ProxyCache proxyCache)
 {
     return(proxyCache.CacheEnabled);
 }
		public void setDefaultValues()
		{
			proxyCache = new ProxyCache();
			CaptureRequests = true;
			this.clearPastRequests();
			IPAddress ipAddress = IPAddress.Loopback;
			IPAddress.TryParse("127.0.0.1", out ipAddress);
			ListeningIPInterface = ipAddress;
			ListeningPort = 8081;
		}		        
Esempio n. 16
0
 public ProxyCache_Brain_DefaultMode(ProxyCache _proxyCache)
 {
     this.proxyCache = _proxyCache;
 }
Esempio n. 17
0
        private static void DoHttpProcessing(TcpClient client)
        {
            Stream       clientStream       = client.GetStream();
            Stream       outStream          = clientStream; //use this stream for writing out - may change if we use ssl
            SslStream    sslStream          = new SslStream(clientStream);
            CacheEntry   cacheEntry         = null;
            MemoryStream cacheStream        = null;
            StreamReader clientStreamReader = null;


            try
            {
                sslStream.AuthenticateAsServer(_certificate,
                                               false, SslProtocols.Tls, true);
                clientStreamReader = new StreamReader(sslStream);
                String httpCmd = clientStreamReader.ReadLine();

                //now we need to decrypt https


                if (String.IsNullOrEmpty(httpCmd))
                {
                    clientStreamReader.Close();
                    clientStream.Close();
                    return;
                }
                //break up the line into three components
                String[] splitBuffer = httpCmd.Split(spaceSplit, 3);

                String method    = splitBuffer[0];
                String remoteUri = splitBuffer[1];
                remoteUri = "https://" + remoteUri.Substring((6));
                Version version = new Version(1, 0);


                HttpWebRequest  webReq;
                HttpWebResponse response = null;
                if (!(splitBuffer[0].ToUpper() == "POST" || splitBuffer[0].ToUpper() == "GET"))
                {
                    //Browser wants to create a secure tunnel
                    //instead = we are going to perform a man in the middle "attack"
                    //the user's browser should warn them of the certification errors however.
                    //Please note: THIS IS ONLY FOR TESTING PURPOSES - you are responsible for the use of this code
                    remoteUri = "https://" + splitBuffer[1];
                    while (!String.IsNullOrEmpty(clientStreamReader.ReadLine()))
                    {
                        ;
                    }
                    StreamWriter connectStreamWriter = new StreamWriter(clientStream);
                    connectStreamWriter.WriteLine("HTTP/1.0 403  Forbidden");
                    connectStreamWriter.WriteLine(String.Format("Timestamp: {0}", DateTime.Now.ToString()));
                    connectStreamWriter.WriteLine("Proxy-agent: matt-dot-net");
                    connectStreamWriter.WriteLine();
                    connectStreamWriter.Flush();

                    /*
                     *
                     * sslStream = new SslStream(clientStream, false);
                     * try
                     * {
                     *  sslStream.AuthenticateAsServer(_certificate, false, SslProtocols.Tls | SslProtocols.Ssl3 | SslProtocols.Ssl2, true);
                     * }
                     * catch (Exception)
                     * {
                     *  sslStream.Close();
                     *  clientStreamReader.Close();
                     *  connectStreamWriter.Close();
                     *  clientStream.Close();
                     *  return;
                     * }
                     *
                     * //HTTPS server created - we can now decrypt the client's traffic
                     * clientStream = sslStream;
                     * clientStreamReader = new StreamReader(sslStream);
                     * outStream = sslStream;
                     * //read the new http command.
                     * httpCmd = clientStreamReader.ReadLine();
                     * if (String.IsNullOrEmpty(httpCmd))
                     * {
                     *  clientStreamReader.Close();
                     *  clientStream.Close();
                     *  sslStream.Close();
                     *  return;
                     * }
                     * splitBuffer = httpCmd.Split(spaceSplit, 3);
                     * method = splitBuffer[0];
                     * remoteUri = remoteUri + splitBuffer[1];
                     */
                }

                //construct the web request that we are going to issue on behalf of the client.

                webReq                 = (HttpWebRequest)HttpWebRequest.Create(remoteUri);
                webReq.Method          = method;
                webReq.ProtocolVersion = version;

                //read the request headers from the client and copy them to our request
                int contentLen = ReadRequestHeaders(clientStreamReader, webReq);

                webReq.Proxy                  = null;
                webReq.KeepAlive              = false;
                webReq.AllowAutoRedirect      = false;
                webReq.AutomaticDecompression = DecompressionMethods.None;


                if (Server.DumpHeaders)
                {
                    Console.WriteLine(String.Format("{0} {1} HTTP/{2}", webReq.Method, webReq.RequestUri.AbsoluteUri, webReq.ProtocolVersion));
                    DumpHeaderCollectionToConsole(webReq.Headers);
                }

                //using the completed request, check our cache
                if (method.ToUpper() == "GET")
                {
                    cacheEntry = ProxyCache.GetData(webReq);
                }
                else if (method.ToUpper() == "POST")
                {
                    char[]       postBuffer = new char[contentLen];
                    int          bytesRead;
                    int          totalBytesRead = 0;
                    StreamWriter sw             = new StreamWriter(webReq.GetRequestStream());
                    while (totalBytesRead < contentLen && (bytesRead = clientStreamReader.ReadBlock(postBuffer, 0, contentLen)) > 0)
                    {
                        totalBytesRead += bytesRead;
                        sw.Write(postBuffer, 0, bytesRead);
                        if (ProxyServer.Server.DumpPostData)
                        {
                            Console.Write(postBuffer, 0, bytesRead);
                        }
                    }
                    if (Server.DumpPostData)
                    {
                        Console.WriteLine();
                        Console.WriteLine();
                    }

                    sw.Close();
                }

                if (cacheEntry == null)
                {
                    //Console.WriteLine(String.Format("ThreadID: {2} Requesting {0} on behalf of client {1}", webReq.RequestUri, client.Client.RemoteEndPoint.ToString(), Thread.CurrentThread.ManagedThreadId));
                    webReq.Timeout = 15000;

                    try
                    {
                        response = (HttpWebResponse)webReq.GetResponse();
                    }
                    catch (WebException webEx)
                    {
                        response = webEx.Response as HttpWebResponse;
                    }
                    if (response != null)
                    {
                        List <Tuple <String, String> > responseHeaders = ProcessResponse(response);
                        StreamWriter myResponseWriter = new StreamWriter(outStream);
                        Stream       responseStream   = response.GetResponseStream();
                        try
                        {
                            //send the response status and response headers
                            WriteResponseStatus(response.StatusCode, response.StatusDescription, myResponseWriter);
                            WriteResponseHeaders(myResponseWriter, responseHeaders);

                            DateTime?  expires  = null;
                            CacheEntry entry    = null;
                            Boolean    canCache = (sslStream == null && ProxyCache.CanCache(response.Headers, ref expires));
                            if (canCache)
                            {
                                entry = ProxyCache.MakeEntry(webReq, response, responseHeaders, expires);
                                if (response.ContentLength > 0)
                                {
                                    cacheStream = new MemoryStream(entry.ResponseBytes);
                                }
                            }

                            Byte[] buffer;
                            if (response.ContentLength > 0)
                            {
                                buffer = new Byte[response.ContentLength];
                            }
                            else
                            {
                                buffer = new Byte[BUFFER_SIZE];
                            }

                            int bytesRead;

                            while ((bytesRead = responseStream.Read(buffer, 0, buffer.Length)) > 0)
                            {
                                if (cacheStream != null)
                                {
                                    cacheStream.Write(buffer, 0, bytesRead);
                                }
                                outStream.Write(buffer, 0, bytesRead);
                                if (Server.DumpResponseData)
                                {
                                    Console.Write(UTF8Encoding.UTF8.GetString(buffer, 0, bytesRead));
                                }
                            }
                            if (Server.DumpResponseData)
                            {
                                Console.WriteLine();
                                Console.WriteLine();
                            }

                            responseStream.Close();
                            if (cacheStream != null)
                            {
                                cacheStream.Flush();
                                cacheStream.Close();
                            }

                            outStream.Flush();
                            if (canCache)
                            {
                                ProxyCache.AddData(entry);
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(ex.Message);
                        }
                        finally
                        {
                            responseStream.Close();
                            response.Close();
                            myResponseWriter.Close();
                        }
                    }
                }
                else
                {
                    //serve from cache
                    StreamWriter myResponseWriter = new StreamWriter(outStream);
                    try
                    {
                        WriteResponseStatus(cacheEntry.StatusCode, cacheEntry.StatusDescription, myResponseWriter);
                        WriteResponseHeaders(myResponseWriter, cacheEntry.Headers);
                        if (cacheEntry.ResponseBytes != null)
                        {
                            outStream.Write(cacheEntry.ResponseBytes, 0, cacheEntry.ResponseBytes.Length);
                            if (ProxyServer.Server.DumpResponseData)
                            {
                                Console.Write(UTF8Encoding.UTF8.GetString(cacheEntry.ResponseBytes));
                            }
                        }
                        myResponseWriter.Close();
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                    }
                    finally
                    {
                        myResponseWriter.Close();
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                if (Server.DumpHeaders || Server.DumpPostData || Server.DumpResponseData)
                {
                    //release the lock
                    Monitor.Exit(_outputLockObj);
                }

                clientStreamReader.Close();
                clientStream.Close();
                if (sslStream != null)
                {
                    sslStream.Close();
                }
                outStream.Close();
                if (cacheStream != null)
                {
                    cacheStream.Close();
                }
            }
        }