Ejemplo n.º 1
0
        internal bool Detach(bool bDontCheckIfAttached)
        {
            if (!bDontCheckIfAttached && !this._bIsAttached)
            {
                return(true);
            }
            if (CONFIG.bIsViewOnly)
            {
                return(true);
            }
            bool result;

            try
            {
                this._bDetaching = true;
                Proxy._setDynamicRegistryKey(false);
                if (this.oAllConnectoids.UnhookAllConnections())
                {
                    this._bIsAttached = false;
                    FiddlerApplication.OnFiddlerDetach();
                    this.WriteAutoProxyPACFile(false);
                    return(true);
                }
                result = false;
            }
            finally
            {
                this._bDetaching = false;
            }
            return(result);
        }
Ejemplo n.º 2
0
 internal bool SecureClientPipeDirect(X509Certificate2 certServer)
 {
     try
     {
         FiddlerApplication.DebugSpew(string.Format("SecureClientPipeDirect({0})", certServer.Subject));
         this._httpsStream = new SslStream(new NetworkStream(this._baseSocket, false), false);
         this._httpsStream.AuthenticateAsServer(certServer, ClientPipe._bWantClientCert, CONFIG.oAcceptedClientHTTPSProtocols, false);
         return(true);
     }
     catch (AuthenticationException eX)
     {
         FiddlerApplication.Log.LogFormat("!SecureClientPipeDirect failed: {1} on pipe to ({0}).", new object[]
         {
             certServer.Subject,
             Utilities.DescribeException(eX)
         });
         Trace.WriteLine(string.Format("!SecureClientPipeDirect failed: {1} on pipe to ({0}).", certServer.Subject, Utilities.DescribeException(eX)));
         base.End();
     }
     catch (Exception eX2)
     {
         FiddlerApplication.Log.LogFormat("!SecureClientPipeDirect failed: {1} on pipe to ({0})", new object[]
         {
             certServer.Subject,
             Utilities.DescribeException(eX2)
         });
         base.End();
     }
     return(false);
 }
Ejemplo n.º 3
0
        internal bool SecureExistingConnection(Session oS, string sCertCN, string sClientCertificateFilename, string sPoolingKey, ref int iHandshakeTime)
        {
            RemoteCertificateValidationCallback userCertificateValidationCallback = null;
            LocalCertificateSelectionCallback   userCertificateSelectionCallback  = null;
            Stopwatch stopwatch = Stopwatch.StartNew();

            try
            {
                this.sPoolKey = sPoolingKey;
                X509CertificateCollection certificateCollectionFromFile = this.GetCertificateCollectionFromFile(sClientCertificateFilename);
                if (userCertificateValidationCallback == null)
                {
                    userCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => ConfirmServerCertificate(oS, sCertCN, certificate, chain, sslPolicyErrors);
                }
                if (userCertificateSelectionCallback == null)
                {
                    userCertificateSelectionCallback = (sender, targetHost, localCertificates, remoteCertificate, acceptableIssuers) => this.AttachClientCertificate(oS, sender, targetHost, localCertificates, remoteCertificate, acceptableIssuers);
                }
                base._httpsStream = new SslStream(new NetworkStream(base._baseSocket, false), false, userCertificateValidationCallback, userCertificateSelectionCallback);
                base._httpsStream.AuthenticateAsClient(sCertCN, certificateCollectionFromFile, CONFIG.oAcceptedServerHTTPSProtocols, false);
                iHandshakeTime = (int)stopwatch.ElapsedMilliseconds;
            }
            catch (Exception exception)
            {
                iHandshakeTime = (int)stopwatch.ElapsedMilliseconds;
                FiddlerApplication.DebugSpew(exception.StackTrace + "\n" + exception.Message);
                FiddlerApplication.Log.LogFormat("fiddler.network.https> Failed to secure existing connection for {0}. {1}{2}", new object[] { sCertCN, exception.Message, (exception.InnerException != null) ? (" InnerException: " + exception.InnerException.ToString()) : "." });
                return(false);
            }
            return(true);
        }
Ejemplo n.º 4
0
 internal static void OnFiddlerDetach()
 {
     if (FiddlerApplication.FiddlerDetach != null)
     {
         FiddlerApplication.FiddlerDetach();
     }
 }
Ejemplo n.º 5
0
        public static void Startup(int iListenPort, bool bRegisterAsSystemProxy, bool bDecryptSSL, bool bAllowRemote)
        {
            FiddlerCoreStartupFlags fiddlerCoreStartupFlags = FiddlerCoreStartupFlags.Default;

            if (bRegisterAsSystemProxy)
            {
                fiddlerCoreStartupFlags |= FiddlerCoreStartupFlags.RegisterAsSystemProxy;
            }
            else
            {
                fiddlerCoreStartupFlags &= ~FiddlerCoreStartupFlags.RegisterAsSystemProxy;
            }
            if (bDecryptSSL)
            {
                fiddlerCoreStartupFlags |= FiddlerCoreStartupFlags.DecryptSSL;
            }
            else
            {
                fiddlerCoreStartupFlags &= ~FiddlerCoreStartupFlags.DecryptSSL;
            }
            if (bAllowRemote)
            {
                fiddlerCoreStartupFlags |= FiddlerCoreStartupFlags.AllowRemoteClients;
            }
            else
            {
                fiddlerCoreStartupFlags &= ~FiddlerCoreStartupFlags.AllowRemoteClients;
            }
            FiddlerApplication.Startup(iListenPort, fiddlerCoreStartupFlags);
        }
Ejemplo n.º 6
0
 private X509Certificate AttachClientCertificate(Session oS, object sender, string targetHost, X509CertificateCollection localCertificates, X509Certificate remoteCertificate, string[] acceptableIssuers)
 {
     if (localCertificates.Count > 0)
     {
         this.MarkAsAuthenticated(oS.LocalProcessID);
         oS.oFlags["x-client-cert"] = localCertificates[0].Subject + " Serial#" + localCertificates[0].GetSerialNumberString();
         return(localCertificates[0]);
     }
     if ((remoteCertificate != null) || (acceptableIssuers.Length >= 1))
     {
         X509Certificate certificate = this._GetDefaultCertificate();
         if (certificate != null)
         {
             this.MarkAsAuthenticated(oS.LocalProcessID);
             oS.oFlags["x-client-cert"] = certificate.Subject + " Serial#" + certificate.GetSerialNumberString();
             return(certificate);
         }
         if (CONFIG.bShowDefaultClientCertificateNeededPrompt && FiddlerApplication.Prefs.GetBoolPref("fiddler.network.https.clientcertificate.ephemeral.prompt-for-missing", true))
         {
             FiddlerApplication.DoNotifyUser("The server [" + targetHost + "] requests a client certificate.\nPlease save a client certificate in the following location:\n\n" + CONFIG.GetPath("DefaultClientCertificate"), "Client Certificate Requested");
             FiddlerApplication.Prefs.SetBoolPref("fiddler.network.https.clientcertificate.ephemeral.prompt-for-missing", false);
         }
         FiddlerApplication.Log.LogFormat("The server [{0}] requested a client certificate, but no client certificate was available.", new object[] { targetHost });
     }
     return(null);
 }
Ejemplo n.º 7
0
 private static void HandlePrefChanged(object sender, PrefChangeEventArgs oPref)
 {
     if (oPref.PrefName == "fiddler.ui.toolbar.visible")
     {
         if (oPref.ValueBool)
         {
             FiddlerApplication.UIInvoke(new MethodInvoker(FiddlerToolbar._DoShow));
         }
         else
         {
             FiddlerApplication.UIInvoke(new MethodInvoker(FiddlerToolbar._DoHide));
         }
     }
     else if (oPref.PrefName == "fiddler.ui.rules.removeencoding")
     {
         if (tsbRemoveEncodings != null)
         {
             bool flag2 = oPref.ValueString == bool.TrueString;
             tsbRemoveEncodings.Checked = flag2;
         }
     }
     else if ((oPref.PrefName == "fiddler.ui.rules.bufferresponses") && (tsbStreaming != null))
     {
         bool flag3 = !oPref.ValueBool;
         tsbStreaming.Checked = flag3;
     }
 }
Ejemplo n.º 8
0
 public bool DoMethod(string sMethodName, object[] oParams)
 {
     if (!this.Ready)
     {
         return(false);
     }
     if (this._typeScriptHandlers == null)
     {
         return(false);
     }
     try
     {
         MethodInfo method = this._typeScriptHandlers.GetMethod(sMethodName);
         if (method != null)
         {
             method.Invoke(null, oParams);
         }
         else
         {
             return(false);
         }
     }
     catch (Exception exception)
     {
         FiddlerApplication.DoNotifyUser(string.Concat(new object[] { "There was a problem with your FiddlerScript.\n\n", exception.Message, "\n", exception.StackTrace, "\n\n", exception.InnerException }), "FiddlerScript Error invoking " + sMethodName);
         return(false);
     }
     return(true);
 }
Ejemplo n.º 9
0
 internal bool DoOnQuickExec(string sCommand)
 {
     foreach (IFiddlerExtension extension in this.m_Extensions.Values)
     {
         if (extension is IHandleExecAction)
         {
             try
             {
                 if ((extension as IHandleExecAction).OnExecAction(sCommand))
                 {
                     return(true);
                 }
                 continue;
             }
             catch (Exception exception)
             {
                 FiddlerApplication.LogAddonException(exception, "Extension threw during OnExecAction");
                 continue;
             }
         }
     }
     if (FiddlerApplication.scriptRules == null)
     {
         return(false);
     }
     return(FiddlerApplication.scriptRules.DoExecAction(sCommand));
 }
Ejemplo n.º 10
0
 public void End()
 {
     if (CONFIG.bDebugSpew)
     {
         FiddlerApplication.DebugSpew("Pipe::End() for {0}", new object[]
         {
             this._sPipeName
         });
     }
     try
     {
         if (this._httpsStream != null)
         {
             this._httpsStream.Close();
         }
         if (this._baseSocket != null)
         {
             this._baseSocket.Shutdown(SocketShutdown.Both);
             this._baseSocket.Close();
         }
     }
     catch (Exception)
     {
     }
     this._baseSocket  = null;
     this._httpsStream = null;
 }
Ejemplo n.º 11
0
        public int Compare(object x, object y)
        {
            int          num   = -1;
            ListViewItem item  = (ListViewItem)x;
            ListViewItem item2 = (ListViewItem)y;

            if (item.SubItems.Count <= this.col)
            {
                num = -1;
            }
            else if (item2.SubItems.Count <= this.col)
            {
                num = 1;
            }
            else if (this.bStringCompare)
            {
                num = string.Compare(item.SubItems[this.col].Text, item2.SubItems[this.col].Text, StringComparison.Ordinal);
            }
            else
            {
                try
                {
                    num = int.Parse(item.SubItems[this.col].Text, NumberStyles.AllowThousands | NumberStyles.AllowLeadingSign) - int.Parse(item2.SubItems[this.col].Text, NumberStyles.AllowThousands | NumberStyles.AllowLeadingSign);
                }
                catch (Exception exception)
                {
                    FiddlerApplication.DebugSpew(exception.Message + "\n" + item.SubItems[this.col].Text + "\n" + item2.SubItems[this.col].Text);
                }
            }
            if (!this.ascending)
            {
                num = -num;
            }
            return(num);
        }
Ejemplo n.º 12
0
 private void _ParseAndSendServerMessages()
 {
     WebSocketMessage[] array  = WebSocket._ParseMessagesFromStream(this, ref this.strmServerBytes, false, true);
     WebSocketMessage[] array2 = array;
     for (int i = 0; i < array2.Length; i++)
     {
         WebSocketMessage webSocketMessage = array2[i];
         webSocketMessage.Timers.dtDoneRead = DateTime.Now;
         List <WebSocketMessage> obj;
         Monitor.Enter(obj = this.listMessages);
         try
         {
             this.listMessages.Add(webSocketMessage);
         }
         finally
         {
             Monitor.Exit(obj);
         }
         FiddlerApplication.DoOnWebSocketMessage(this._mySession, webSocketMessage);
         if (!webSocketMessage.WasAborted)
         {
             webSocketMessage.Timers.dtBeginSend = DateTime.Now;
             this.oCP.Send(webSocketMessage.ToByteArray());
             webSocketMessage.Timers.dtDoneSend = DateTime.Now;
         }
     }
 }
Ejemplo n.º 13
0
 private bool isRequestComplete()
 {
     if (this.m_headers == null)
     {
         if (!this.HeadersAvailable())
         {
             return(false);
         }
         if (!this.ParseRequestForHeaders())
         {
             string str;
             if (this.m_requestData != null)
             {
                 str = Utilities.ByteArrayToHexView(this.m_requestData.GetBuffer(), 0x18, (int)Math.Min(this.m_requestData.Length, 0x800L));
             }
             else
             {
                 str = "{Fiddler:no data}";
             }
             if (this.m_headers == null)
             {
                 this.m_headers             = new HTTPRequestHeaders();
                 this.m_headers.HTTPMethod  = "BAD";
                 this.m_headers["Host"]     = "BAD-REQUEST";
                 this.m_headers.RequestPath = "/BAD_REQUEST";
             }
             this.FailSession(400, "Fiddler - Bad Request", "[Fiddler] Request Header parsing failed. Request was:\n" + str);
             return(true);
         }
         this.m_session._AssignID();
         FiddlerApplication.DoRequestHeadersAvailable(this.m_session);
     }
     if (this.m_headers.ExistsAndEquals("Transfer-encoding", "chunked"))
     {
         long num;
         long num2;
         return(Utilities.IsChunkedBodyComplete(this.m_session, this.m_requestData, (long)this.iEntityBodyOffset, out num2, out num));
     }
     if (this.m_headers.Exists("Content-Length"))
     {
         long result = 0L;
         try
         {
             if (!long.TryParse(this.m_headers["Content-Length"], NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out result) || (result < 0L))
             {
                 FiddlerApplication.HandleHTTPError(this.m_session, SessionFlags.ProtocolViolationInRequest, true, true, "Request content length was invalid.\nContent-Length: " + this.m_headers["Content-Length"]);
                 this.FailSession(400, "Fiddler - Bad Request", "[Fiddler] Request Content-Length header parsing failed.\nContent-Length: " + this.m_headers["Content-Length"]);
                 return(true);
             }
             return(this.m_requestData.Length >= (this.iEntityBodyOffset + result));
         }
         catch
         {
             this.FailSession(400, "Fiddler - Bad Request", "[Fiddler] Unknown error: Check content length header?");
             return(false);
         }
     }
     return(true);
 }
Ejemplo n.º 14
0
        internal bool SecureClientPipe(string sHostname, HTTPResponseHeaders oHeaders)
        {
            X509Certificate2 x509Certificate;

            try
            {
                x509Certificate = CertMaker.FindCert(sHostname);
            }
            catch (Exception ex)
            {
                FiddlerApplication.Log.LogFormat("fiddler.https> Failed to obtain certificate for {0} due to {1}", new object[]
                {
                    sHostname,
                    ex.Message
                });
                x509Certificate = null;
            }
            try
            {
                if (x509Certificate == null)
                {
                    FiddlerApplication.DoNotifyUser("Unable to find Certificate for " + sHostname, "HTTPS Interception Failure");
                    oHeaders.SetStatus(502, "Fiddler unable to generate certificate");
                }
                if (CONFIG.bDebugSpew)
                {
                    FiddlerApplication.DebugSpew("SecureClientPipe for: " + this.ToString() + " sending data to client:\n" + Utilities.ByteArrayToHexView(oHeaders.ToByteArray(true, true), 32));
                }
                base.Send(oHeaders.ToByteArray(true, true));
                bool result;
                if (oHeaders.HTTPResponseCode != 200)
                {
                    FiddlerApplication.DebugSpew("SecureClientPipe returning FALSE because HTTPResponseCode != 200");
                    result = false;
                    return(result);
                }
                this._httpsStream = new SslStream(new NetworkStream(this._baseSocket, false), false);
                this._httpsStream.AuthenticateAsServer(x509Certificate, ClientPipe._bWantClientCert, CONFIG.oAcceptedClientHTTPSProtocols, false);
                result = true;
                return(result);
            }
            catch (Exception eX)
            {
                FiddlerApplication.Log.LogFormat("SecureClientPipe ({0} failed: {1}.", new object[]
                {
                    sHostname,
                    Utilities.DescribeException(eX)
                });
                try
                {
                    base.End();
                }
                catch (Exception)
                {
                }
            }
            return(false);
        }
Ejemplo n.º 15
0
 public bool Attach()
 {
     if (!this._bIsAttached)
     {
         this.CollectConnectoidAndGatewayInfo();
         WinINETProxyInfo oNewInfo = new WinINETProxyInfo {
             bUseManualProxies = true,
             bAllowDirect      = true,
             sHttpProxy        = CONFIG.sFiddlerListenHostPort
         };
         if (CONFIG.bCaptureCONNECT)
         {
             oNewInfo.sHttpsProxy = CONFIG.sFiddlerListenHostPort;
         }
         else
         {
             oNewInfo.sHttpsProxy = this.piPrior.sHttpsProxy;
         }
         if (this.piPrior.bUseManualProxies)
         {
             oNewInfo.sFtpProxy   = this.piPrior.sFtpProxy;
             oNewInfo.sSocksProxy = this.piPrior.sSocksProxy;
         }
         if (CONFIG.bCaptureFTP)
         {
             oNewInfo.sFtpProxy = CONFIG.sFiddlerListenHostPort;
         }
         oNewInfo.sHostsThatBypass = CONFIG.sHostsThatBypassFiddler;
         if (CONFIG.bHookWithPAC)
         {
             if (FiddlerApplication.Prefs.GetBoolPref("fiddler.proxy.pacfile.usefileprotocol", true))
             {
                 oNewInfo.sPACScriptLocation = "file://" + CONFIG.GetPath("Pac");
             }
             else
             {
                 oNewInfo.sPACScriptLocation = "http://" + CONFIG.sFiddlerListenHostPort + "/proxy.pac";
             }
         }
         if (!CONFIG.bIsViewOnly)
         {
             if (this.oAllConnectoids.HookConnections(oNewInfo))
             {
                 this._bIsAttached = true;
                 FiddlerApplication.OnFiddlerAttach();
                 this.WriteAutoProxyPACFile(true);
             }
             else
             {
                 FiddlerApplication.DoNotifyUser("Failed to register Fiddler as the system proxy.", "Error");
                 _setDynamicRegistryKey(false);
                 return(false);
             }
             _setDynamicRegistryKey(true);
         }
     }
     return(true);
 }
Ejemplo n.º 16
0
 private void ScanPathForTranscoders(string sPath)
 {
     try
     {
         if (Directory.Exists(sPath))
         {
             Evidence evidence = Assembly.GetExecutingAssembly().Evidence;
             bool     boolPref;
             if (boolPref = FiddlerApplication.Prefs.GetBoolPref("fiddler.debug.extensions.verbose", false))
             {
                 FiddlerApplication.Log.LogFormat("Searching for Transcoders under {0}", new object[]
                 {
                     sPath
                 });
             }
             FileInfo[] files = new DirectoryInfo(sPath).GetFiles("*.dll");
             FileInfo[] array = files;
             for (int i = 0; i < array.Length; i++)
             {
                 FileInfo fileInfo = array[i];
                 if (!Utilities.IsNotExtension(fileInfo.Name))
                 {
                     if (boolPref)
                     {
                         FiddlerApplication.Log.LogFormat("Looking for Transcoders inside {0}", new object[]
                         {
                             fileInfo.FullName.ToString()
                         });
                     }
                     Assembly assemblyInput;
                     try
                     {
                         if (CONFIG.bRunningOnCLRv4)
                         {
                             assemblyInput = Assembly.LoadFrom(fileInfo.FullName);
                         }
                         else
                         {
                             assemblyInput = Assembly.LoadFrom(fileInfo.FullName, evidence);
                         }
                     }
                     catch (Exception eX)
                     {
                         FiddlerApplication.LogAddonException(eX, "Failed to load " + fileInfo.FullName);
                         goto IL_F1;
                     }
                     this.ScanAssemblyForTranscoders(assemblyInput);
                 }
                 IL_F1 :;
             }
         }
     }
     catch (Exception ex)
     {
         FiddlerApplication.DoNotifyUser(string.Format("[Fiddler] Failure loading Transcoders: {0}", ex.Message), "Transcoders Load Error");
     }
 }
Ejemplo n.º 17
0
 public WinINETConnectoids()
 {
     string[] connectionNames = RASInfo.GetConnectionNames();
     string[] array           = connectionNames;
     for (int i = 0; i < array.Length; i++)
     {
         string text = array[i];
         if (CONFIG.bDebugSpew)
         {
             FiddlerApplication.DebugSpew("Collecting information for Connectoid '{0}'", new object[]
             {
                 text
             });
         }
         if (!this._oConnectoids.ContainsKey(text))
         {
             try
             {
                 WinINETProxyInfo winINETProxyInfo = WinINETProxyInfo.CreateFromNamedConnection(text);
                 if (winINETProxyInfo == null)
                 {
                     FiddlerApplication.Log.LogFormat("!WARNING: Failed to get proxy information for Connection '{0}'.", new object[]
                     {
                         text
                     });
                 }
                 else
                 {
                     WinINETConnectoid winINETConnectoid = new WinINETConnectoid();
                     winINETConnectoid.sConnectionName = text;
                     if (!string.IsNullOrEmpty(winINETProxyInfo.sHttpProxy) && winINETProxyInfo.sHttpProxy.Contains(CONFIG.sFiddlerListenHostPort))
                     {
                         FiddlerApplication.Log.LogString("When connecting, upstream proxy settings were already pointed at Fiddler. Clearing upstream proxy.");
                         winINETProxyInfo.sHttpProxy        = (winINETProxyInfo.sHttpsProxy = (winINETProxyInfo.sFtpProxy = null));
                         winINETProxyInfo.bUseManualProxies = false;
                         winINETProxyInfo.bAllowDirect      = true;
                     }
                     if (!string.IsNullOrEmpty(winINETProxyInfo.sPACScriptLocation) && (winINETProxyInfo.sPACScriptLocation == "file://" + CONFIG.GetPath("Pac") || winINETProxyInfo.sPACScriptLocation == "http://" + CONFIG.sFiddlerListenHostPort + "/proxy.pac"))
                     {
                         FiddlerApplication.Log.LogString("When connecting, upstream proxy script was already pointed at Fiddler. Clearing upstream proxy.");
                         winINETProxyInfo.sPACScriptLocation = null;
                     }
                     winINETConnectoid.oOriginalProxyInfo = winINETProxyInfo;
                     this._oConnectoids.Add(text, winINETConnectoid);
                 }
             }
             catch (Exception eX)
             {
                 FiddlerApplication.Log.LogFormat("!WARNING: Failed to get proxy information for Connection '{0}' due to {1}", new object[]
                 {
                     text,
                     Utilities.DescribeException(eX)
                 });
             }
         }
     }
 }
Ejemplo n.º 18
0
        internal bool ResendRequest()
        {
            bool b = this.pipeServer != null;

            if (!this.ConnectToHost())
            {
                FiddlerApplication.DebugSpew("ConnectToHost returned null. Bailing...");
                this.m_session.SetBitFlag(SessionFlags.ServerPipeReused, b);
                return(false);
            }
            try
            {
                this.pipeServer.IncrementUse(this.m_session.id);
                this.m_session.Timers.ServerConnected = this.pipeServer.dtConnected;
                this._bWasForwarded = this.pipeServer.isConnectedToGateway;
                this.m_session.SetBitFlag(SessionFlags.ServerPipeReused, this.pipeServer.iUseCount > 1);
                this.m_session.SetBitFlag(SessionFlags.SentToGateway, this._bWasForwarded);
                if (!this._bWasForwarded && !this.m_session.isHTTPS)
                {
                    this.m_session.oRequest.headers.RenameHeaderItems("Proxy-Connection", "Connection");
                }
                if (!this.pipeServer.isAuthenticated)
                {
                    string str = this.m_session.oRequest.headers["Authorization"];
                    if ((str != null) && str.StartsWith("N"))
                    {
                        this.pipeServer.MarkAsAuthenticated(this.m_session.LocalProcessID);
                    }
                }
                this.m_session.Timers.FiddlerBeginRequest = DateTime.Now;
                if (this.m_session.oFlags.ContainsKey("request-trickle-delay"))
                {
                    int num = int.Parse(this.m_session.oFlags["request-trickle-delay"]);
                    this.pipeServer.TransmitDelay = num;
                }
                this.pipeServer.Send(this.m_session.oRequest.headers.ToByteArray(true, true, this._bWasForwarded && !this.m_session.isHTTPS));
                this.pipeServer.Send(this.m_session.requestBodyBytes);
            }
            catch (Exception exception)
            {
                if (this.bServerSocketReused && (this.m_session.state != SessionStates.Aborted))
                {
                    this.pipeServer = null;
                    return(this.ResendRequest());
                }
                FiddlerApplication.DebugSpew("ResendRequest() failed: " + exception.Message);
                this.m_session.oRequest.FailSession(0x1f8, "Fiddler - Send Failure", "ResendRequest() failed: " + exception.Message);
                return(false);
            }
            this.m_session.oFlags["x-EgressPort"] = this.pipeServer.LocalPort.ToString();
            if (this.m_session.oFlags.ContainsKey("log-drop-request-body"))
            {
                this.m_session.oFlags["x-RequestBodyLength"] = (this.m_session.requestBodyBytes != null) ? this.m_session.requestBodyBytes.Length.ToString() : "0";
                this.m_session.requestBodyBytes = new byte[0];
            }
            return(true);
        }
Ejemplo n.º 19
0
 private void cbAutoRespond_CheckedChanged(object sender, EventArgs e)
 {
     FiddlerApplication._AutoResponder.IsEnabled = this.cbAutoRespond.Checked;
     if (this.cbAutoRespond.Checked && CONFIG.IsMicrosoftMachine)
     {
         FiddlerApplication.logSelfHostOnePerSession(30);
     }
     this.pnlAutoResponders.Enabled = this.cbAutoRespond.Checked;
     FiddlerApplication.UI.pageResponder.ImageIndex = this.cbAutoRespond.Checked ? 0x18 : 0x17;
 }
Ejemplo n.º 20
0
 private bool GetHeaders()
 {
     if (!this.HeadersAvailable())
     {
         return(false);
     }
     if (!this.ParseResponseForHeaders())
     {
         string str;
         this.m_session.SetBitFlag(SessionFlags.ProtocolViolationInResponse, true);
         this._PoisonPipe();
         if (this.m_responseData != null)
         {
             str = "<plaintext>\n" + Utilities.ByteArrayToHexView(this.m_responseData.GetBuffer(), 0x18, (int)Math.Min(this.m_responseData.Length, 0x800L));
         }
         else
         {
             str = "{Fiddler:no data}";
         }
         this.m_session.oRequest.FailSession(500, "Fiddler - Bad Response", string.Format("[Fiddler] Response Header parsing failed.\n{0}Response Data:\n{1}", this.m_session.isFlagSet(SessionFlags.ServerPipeReused) ? "This can be caused by an illegal HTTP response earlier on this reused server socket-- for instance, a HTTP/304 response which illegally contains a body.\n" : string.Empty, str));
         return(true);
     }
     if ((this.m_inHeaders.HTTPResponseCode <= 0x63) || (this.m_inHeaders.HTTPResponseCode >= 200))
     {
         return(true);
     }
     if (this.m_inHeaders.Exists("Content-Length") && ("0" != this.m_inHeaders["Content-Length"].Trim()))
     {
         FiddlerApplication.HandleHTTPError(this.m_session, SessionFlags.ProtocolViolationInResponse, false, true, "HTTP/1xx responses MUST NOT contain a body, but a non-zero content-length was returned.");
     }
     if (FiddlerApplication.Prefs.GetBoolPref("fiddler.network.streaming.leakhttp1xx", true) && (this.m_session.oRequest.pipeClient != null))
     {
         try
         {
             StringDictionary dictionary;
             this.m_session.oRequest.pipeClient.Send(this.m_inHeaders.ToByteArray(true, true));
             (dictionary = this.m_session.oFlags)["x-fiddler-Stream1xx"] = dictionary["x-fiddler-Stream1xx"] + "Returned a HTTP/" + this.m_inHeaders.HTTPResponseCode.ToString() + " message from the server.";
         }
         catch (Exception exception)
         {
             if (FiddlerApplication.Prefs.GetBoolPref("fiddler.network.streaming.abortifclientaborts", false))
             {
                 throw new Exception("Leaking HTTP/1xx response to client failed", exception);
             }
             FiddlerApplication.Log.LogFormat("fiddler.network.streaming> Streaming of HTTP/1xx headers from #{0} to client failed: {1}", new object[] { this.m_session.id, exception.Message });
         }
     }
     else
     {
         StringDictionary dictionary2;
         (dictionary2 = this.m_session.oFlags)["x-fiddler-streaming"] = dictionary2["x-fiddler-streaming"] + "Eating a HTTP/" + this.m_inHeaders.HTTPResponseCode.ToString() + " message from the stream.";
     }
     this._deleteInformationalMessage();
     return(this.GetHeaders());
 }
Ejemplo n.º 21
0
 internal static void DoAfterSessionComplete(Session oSession)
 {
     if (oSession.isFlagSet(SessionFlags.Ignored))
     {
         return;
     }
     if (FiddlerApplication.AfterSessionComplete != null)
     {
         FiddlerApplication.AfterSessionComplete(oSession);
     }
 }
Ejemplo n.º 22
0
 internal static void DoRequestHeadersAvailable(Session oSession)
 {
     if (oSession.isFlagSet(SessionFlags.Ignored))
     {
         return;
     }
     if (FiddlerApplication.RequestHeadersAvailable != null)
     {
         FiddlerApplication.RequestHeadersAvailable(oSession);
     }
 }
Ejemplo n.º 23
0
 internal static void DoBeforeReturningError(Session oSession)
 {
     if (oSession.isFlagSet(SessionFlags.Ignored))
     {
         return;
     }
     if (FiddlerApplication.BeforeReturningError != null)
     {
         FiddlerApplication.BeforeReturningError(oSession);
     }
 }
Ejemplo n.º 24
0
 static FiddlerApplication()
 {
     FiddlerApplication.Counters      = new DataPoints();
     FiddlerApplication._Log          = new Logger(false);
     FiddlerApplication.Janitor       = new PeriodicWorker();
     FiddlerApplication._Prefs        = null;
     FiddlerApplication.oTranscoders  = new FiddlerTranscoders();
     FiddlerApplication.slLeakedFiles = new List <string>();
     FiddlerApplication._SetXceedLicenseKeys();
     FiddlerApplication._Prefs = new PreferenceBag(null);
 }
Ejemplo n.º 25
0
 internal static void LogAddonException(Exception eX, string sTitle)
 {
     if (FiddlerApplication.Prefs.GetBoolPref("fiddler.debug.extensions.showerrors", false) || FiddlerApplication.Prefs.GetBoolPref("fiddler.debug.extensions.verbose", false))
     {
         FiddlerApplication.Log.LogFormat("!Exception from Extension: {0}", new object[]
         {
             Utilities.DescribeException(eX)
         });
         FiddlerApplication.ReportException(eX, sTitle, "Fiddler has encountered an unexpected problem with an extension.");
     }
 }
Ejemplo n.º 26
0
 public SplashScreen()
 {
     try
     {
         this.InitializeComponent();
     }
     catch (ArgumentException exception)
     {
         FiddlerApplication.DoNotifyUser("It appears that one of your computer's fonts is missing, or your\nMicrosoft .NET Framework installation is corrupt. If you see the Font file in\nthe c:\\windows\\fonts folder, then try reinstalling the .NET Framework and\nall updates from WindowsUpdate.\n\n" + exception.Message + "\n" + exception.StackTrace, "Fiddler is unable to start");
     }
     this.lblVersion.Text = string.Format("v{0}{1}", Application.ProductVersion, CONFIG.bIsBeta ? " beta" : string.Empty);
 }
Ejemplo n.º 27
0
 private bool ParseResponseForHeaders()
 {
     if ((this.m_responseData != null) && (this.iEntityBodyOffset >= 4))
     {
         this.m_inHeaders = new HTTPResponseHeaders(CONFIG.oHeaderEncoding);
         byte[] bytes = this.m_responseData.GetBuffer();
         string str   = CONFIG.oHeaderEncoding.GetString(bytes, 0, this.iEntityBodyOffset).Trim();
         if ((str == null) || (str.Length < 1))
         {
             this.m_inHeaders = null;
             return(false);
         }
         string[] sHeaderLines = str.Replace("\r\n", "\n").Split(new char[] { '\n' });
         if (sHeaderLines.Length >= 1)
         {
             int index = sHeaderLines[0].IndexOf(' ');
             if (index > 0)
             {
                 this.m_inHeaders.HTTPVersion = sHeaderLines[0].Substring(0, index).ToUpper();
                 sHeaderLines[0] = sHeaderLines[0].Substring(index + 1).Trim();
                 if (!this.m_inHeaders.HTTPVersion.StartsWith("HTTP/", StringComparison.OrdinalIgnoreCase))
                 {
                     FiddlerApplication.HandleHTTPError(this.m_session, SessionFlags.ProtocolViolationInResponse, false, true, "Response does not start with HTTP. Data:\n\n\t" + sHeaderLines[0]);
                     return(false);
                 }
                 this.m_inHeaders.HTTPResponseStatus = sHeaderLines[0];
                 bool flag = false;
                 index = sHeaderLines[0].IndexOf(' ');
                 if (index > 0)
                 {
                     flag = int.TryParse(sHeaderLines[0].Substring(0, index).Trim(), NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out this.m_inHeaders.HTTPResponseCode);
                 }
                 else
                 {
                     flag = int.TryParse(sHeaderLines[0].Trim(), NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out this.m_inHeaders.HTTPResponseCode);
                 }
                 if (!flag)
                 {
                     FiddlerApplication.HandleHTTPError(this.m_session, SessionFlags.ProtocolViolationInResponse, false, true, "Response headers did not contain a status code. Data:\n\n\t" + sHeaderLines[0]);
                     return(false);
                 }
                 string sErrors = string.Empty;
                 if (!Parser.ParseNVPHeaders(this.m_inHeaders, sHeaderLines, 1, ref sErrors))
                 {
                     FiddlerApplication.HandleHTTPError(this.m_session, SessionFlags.ProtocolViolationInResponse, false, true, "Incorrectly formed response headers.\n" + sErrors);
                 }
                 return(true);
             }
             FiddlerApplication.HandleHTTPError(this.m_session, SessionFlags.ProtocolViolationInResponse, false, true, "Cannot parse HTTP response; Status line contains no spaces. Data:\n\n\t" + sHeaderLines[0]);
         }
     }
     return(false);
 }
Ejemplo n.º 28
0
 internal void CollectConnectoidAndGatewayInfo()
 {
     try
     {
         this.oAllConnectoids = new WinINETConnectoids();
         this.RefreshUpstreamGatewayInformation();
     }
     catch (Exception eX)
     {
         FiddlerApplication.ReportException(eX, "System Error");
     }
 }
Ejemplo n.º 29
0
 internal static void DoNotifyUser(string sMessage, string sTitle, MessageBoxIcon oIcon)
 {
     if (FiddlerApplication.OnNotification != null)
     {
         NotificationEventArgs e = new NotificationEventArgs(string.Format("{0} - {1}", sTitle, sMessage));
         FiddlerApplication.OnNotification(null, e);
     }
     if (!CONFIG.QuietMode)
     {
         MessageBox.Show(sMessage, sTitle, MessageBoxButtons.OK, oIcon);
     }
 }
Ejemplo n.º 30
0
            public X509Certificate2 GetRootCertificate(string string_2, bool bool_0)
            {
                X509Certificate2 certificate = null;
                int      num;
                string   str2;
                string   stringPref = FiddlerApplication.Prefs.GetStringPref("fiddler.certmaker.DateFormatString", "MM/dd/yyyy");
                int      num2       = -FiddlerApplication.Prefs.GetInt32Pref("fiddler.certmaker.GraceDays", 0x16e);
                DateTime time       = DateTime.Now.AddDays((double)num2);

                if (bool_0)
                {
                    str2 = string.Format(CONFIG.sMakeCertParamsRoot, new object[] { string_2, CONFIG.sMakeCertSubjectO, CONFIG.sMakeCertRootCN, FiddlerApplication.Prefs.GetStringPref("fiddler.certmaker.Root.SigAlg", this.string_1), time.ToString(stringPref, CultureInfo.InvariantCulture), FiddlerApplication.Prefs.GetStringPref("fiddler.certmaker.Root.extraparams", string.Empty) });
                }
                else
                {
                    str2 = string.Format(CONFIG.sMakeCertParamsEE, new object[] { string_2, CONFIG.sMakeCertSubjectO, CONFIG.sMakeCertRootCN, FiddlerApplication.Prefs.GetStringPref("fiddler.certmaker.EE.SigAlg", this.string_1), time.ToString(stringPref, CultureInfo.InvariantCulture), FiddlerApplication.Prefs.GetStringPref("fiddler.certmaker.EE.extraparams", string.Empty) });
                }
                if (CONFIG.bDebugCertificateGeneration)
                {
                    FiddlerApplication.Log.LogFormat("/Fiddler.CertMaker> Invoking makecert.exe with arguments: {0}", new object[] { str2 });
                }
                string str = Utilities.GetExecutableOutput(this.string_0, str2, out num);

                if (CONFIG.bDebugCertificateGeneration)
                {
                    FiddlerApplication.Log.LogFormat("/Fiddler.CertMaker>{3}-CreateCert({0}) => ({1}){2}", new object[] { string_2, num, (num == 0) ? "." : ("\r\n" + str), Thread.CurrentThread.ManagedThreadId });
                }
                if (num == 0)
                {
                    int num3 = 6;
                    do
                    {
                        certificate = NewCertificateProvider.LoadCertificateFromWindowsStore(string_2);
                        Thread.Sleep((int)(50 * (6 - num3)));
                        if (CONFIG.bDebugCertificateGeneration && (certificate == null))
                        {
                            FiddlerApplication.Log.LogFormat("!WARNING: Couldn't find certificate for {0} on try #{1}", new object[] { string_2, 6 - num3 });
                        }
                        num3--;
                    }while ((certificate == null) && (num3 >= 0));
                }
                if (certificate == null)
                {
                    string sMessage = string.Format("Creation of the interception certificate failed.\n\nmakecert.exe returned {0}.\n\n{1}", num, str);
                    FiddlerApplication.Log.LogFormat("Fiddler.CertMaker> [{0} {1}] Returned Error: {2} ", new object[] { this.string_0, str2, sMessage });
                    if (CONFIG.bDebugCertificateGeneration)
                    {
                        FiddlerApplication.DoNotifyUser(sMessage, "Unable to Generate Certificate");
                    }
                }
                return(certificate);
            }