147

几周前我下载了 Privoxy,为了好玩,我很想知道它的简单版本是如何完成的。

我了解我需要配置浏览器(客户端)以向代理发送请求。代理将请求发送到网络(假设它是一个 http 代理)。代理将收到答案......但是代理如何将请求发送回浏览器(客户端)?

我在网上搜索了 C# 和 http 代理,但没有找到让我了解它如何在幕后正确工作的东西。(我相信我不想要反向代理,但我不确定)。

你们有没有一些解释或一些信息可以让我继续这个小项目?

更新

这是我的理解(见下图)。

第 1 步我将客户端(浏览器)配置为将所有请求发送到代理侦听端口的 127.0.0.1。这样,请求不会直接发送到 Internet,而是由代理处理。

Step2代理看到一个新连接,读取 HTTP 标头并查看他必须执行的请求。他执行请求。

Step3代理收到请求的答复。现在他必须将答案从网络发送给客户端,但是如何???

替代文字

有用的链接

Mentalis 代理:我发现这个项目是一个代理(但我想要更多)。我可能会检查来源,但我真的想要一些基本的东西来理解更多的概念。

ASP 代理:我也可以在这里获得一些信息。

请求反射器:这是一个简单的例子。

这是一个带有简单 Http 代理的 Git Hub 存储库

4

10 回答 10

94

我不会使用 HttpListener 或类似的东西,那样你会遇到很多问题。

最重要的是,支持将是一个巨大的痛苦:

  • 代理保活
  • SSL 不起作用(以正确的方式,你会得到弹出窗口)
  • .NET 库严格遵循 RFC,这会导致某些请求失败(即使 IE、FF 和世界上任何其他浏览器都可以使用。)

你需要做的是:

  • 监听 TCP 端口
  • 解析浏览器请求
  • 提取主机以 TCP 级别连接到该主机
  • 除非您想添加自定义标题等,否则来回转发所有内容。

我在 .NET 中编写了 2 个具有不同要求的不同 HTTP 代理,我可以告诉你这是最好的方法。

Mentalis 这样做,但他们的代码是“代表意大利面条”,比 GoTo 更糟糕 :)

于 2009-04-30T11:05:34.560 回答
36

您可以使用该类构建一个HttpListener以侦听传入请求,并使用HttpWebRequest该类来中继请求。

于 2008-10-22T17:34:06.587 回答
35

我最近使用TcpListenerTcpClient在 c# .net 中编写了一个轻量级代理。

https://github.com/titanium007/Titanium-Web-Proxy

它以正确的方式支持安全 HTTP,客户端机器需要信任代理使用的根证书。还支持 WebSockets 中继。除流水线外,支持 HTTP 1.1 的所有功能。无论如何,大多数现代浏览器都不使用流水线。还支持 Windows 身份验证(普通、摘要)。

您可以通过引用项目来连接您的应用程序,然后查看和修改所有流量。(请求和响应)。

就性能而言,我已经在我的机器上对其进行了测试,并且没有任何明显的延迟。

于 2015-01-06T02:10:40.367 回答
20

代理可以通过以下方式工作。

Step1,配置客户端使用proxyHost:proxyPort。

代理是侦听 proxyHost:proxyPort 的 TCP 服务器。浏览器打开与 Proxy 的连接并发送 Http 请求。代理解析此请求并尝试检测“主机”标头。此标头将告诉代理在哪里打开连接。

第 2 步:代理打开到“主机”标头中指定的地址的连接。然后它将 HTTP 请求发送到该远程服务器。读取响应。

第 3 步:从远程 HTTP 服务器读取响应后,代理通过较早打开的与浏览器的 TCP 连接发送响应。

从示意图上看,它将如下所示:

Browser                            Proxy                     HTTP server
  Open TCP connection  
  Send HTTP request  ----------->                       
                                 Read HTTP header
                                 detect Host header
                                 Send request to HTTP ----------->
                                 Server
                                                      <-----------
                                 Read response and send
                   <-----------  it back to the browser
Render content
于 2009-04-30T10:55:59.203 回答
14

如果你只是想拦截流量,你可以使用提琴手核心来创建一个代理......

http://fiddler.wikidot.com/fiddlercore

首先使用 UI 运行 fiddler 以查看它的作用,它是一个代理,允许您调试 http/https 流量。它是用 c# 编写的,并且有一个核心,您可以将其构建到您自己的应用程序中。

请记住,FiddlerCore 对商业应用程序不是免费的。

于 2012-06-20T15:44:26.550 回答
6

同意 dr evil 如果你使用 HTTPListener 你会遇到很多问题,你必须解析请求并且会参与到标题和......

  1. 使用 tcp listener 监听浏览器请求
  2. 仅解析请求的第一行并获取要连接的主机域和端口
  3. 在浏览器请求的第一行向找到的主机发送确切的原始请求
  4. 从目标站点接收数据(我在这部分有问题)
  5. 将从主机接收到的确切数据发送到浏览器

您会看到您甚至不需要知道浏览器请求中的内容并对其进行解析,只需从第一行获取目标站点地址,第一行通常喜欢这个 GET http://google.com HTTP1.1 或 CONNECT facebook.com: 443(这是用于 ssl 请求)

于 2010-09-08T17:32:24.967 回答
6

使用 OWIN 和 WebAPI,事情变得非常简单。在我搜索 C# 代理服务器时,我还看到了这篇文章http://blog.kloud.com.au/2013/11/24/do-it-yourself-web-api-proxy/。这将是我要走的路。

于 2015-01-19T12:34:00.107 回答
5

Socks4 是一个实现起来非常简单的协议。您侦听初始连接,连接到客户端请求的主机/端口,将成功代码发送到客户端,然后通过套接字转发传出和传入流。

如果您使用 HTTP,则必须阅读并可能设置/删除一些 HTTP 标头,这样就需要做更多的工作。

如果我没记错的话,SSL 可以跨 HTTP 和 Socks 代理工作。对于 HTTP 代理,您实现 CONNECT 动词,其工作方式与上述 socks4 非常相似,然后客户端通过代理的 tcp 流打开 SSL 连接。

于 2012-06-15T15:20:38.453 回答
4

对于它的价值,这是一个基于HttpListenerHttpClient的 C# 示例异步实现(我使用它能够将 Android 设备中的 Chrome 连接到 IIS Express,这是我找到的唯一方法......)。

如果你需要 HTTPS 支持,它不应该需要更多的代码,只需要证书配置:Httplistener with HTTPS support

// define http://localhost:5000 and http://127.0.0.1:5000/ to be proxies for http://localhost:53068
using (var server = new ProxyServer("http://localhost:53068", "http://localhost:5000/", "http://127.0.0.1:5000/"))
{
    server.Start();
    Console.WriteLine("Press ESC to stop server.");
    while (true)
    {
        var key = Console.ReadKey(true);
        if (key.Key == ConsoleKey.Escape)
            break;
    }
    server.Stop();
}

....

public class ProxyServer : IDisposable
{
    private readonly HttpListener _listener;
    private readonly int _targetPort;
    private readonly string _targetHost;
    private static readonly HttpClient _client = new HttpClient();

    public ProxyServer(string targetUrl, params string[] prefixes)
        : this(new Uri(targetUrl), prefixes)
    {
    }

    public ProxyServer(Uri targetUrl, params string[] prefixes)
    {
        if (targetUrl == null)
            throw new ArgumentNullException(nameof(targetUrl));

        if (prefixes == null)
            throw new ArgumentNullException(nameof(prefixes));

        if (prefixes.Length == 0)
            throw new ArgumentException(null, nameof(prefixes));

        RewriteTargetInText = true;
        RewriteHost = true;
        RewriteReferer = true;
        TargetUrl = targetUrl;
        _targetHost = targetUrl.Host;
        _targetPort = targetUrl.Port;
        Prefixes = prefixes;

        _listener = new HttpListener();
        foreach (var prefix in prefixes)
        {
            _listener.Prefixes.Add(prefix);
        }
    }

    public Uri TargetUrl { get; }
    public string[] Prefixes { get; }
    public bool RewriteTargetInText { get; set; }
    public bool RewriteHost { get; set; }
    public bool RewriteReferer { get; set; } // this can have performance impact...

    public void Start()
    {
        _listener.Start();
        _listener.BeginGetContext(ProcessRequest, null);
    }

    private async void ProcessRequest(IAsyncResult result)
    {
        if (!_listener.IsListening)
            return;

        var ctx = _listener.EndGetContext(result);
        _listener.BeginGetContext(ProcessRequest, null);
        await ProcessRequest(ctx).ConfigureAwait(false);
    }

    protected virtual async Task ProcessRequest(HttpListenerContext context)
    {
        if (context == null)
            throw new ArgumentNullException(nameof(context));

        var url = TargetUrl.GetComponents(UriComponents.SchemeAndServer, UriFormat.Unescaped);
        using (var msg = new HttpRequestMessage(new HttpMethod(context.Request.HttpMethod), url + context.Request.RawUrl))
        {
            msg.Version = context.Request.ProtocolVersion;

            if (context.Request.HasEntityBody)
            {
                msg.Content = new StreamContent(context.Request.InputStream); // disposed with msg
            }

            string host = null;
            foreach (string headerName in context.Request.Headers)
            {
                var headerValue = context.Request.Headers[headerName];
                if (headerName == "Content-Length" && headerValue == "0") // useless plus don't send if we have no entity body
                    continue;

                bool contentHeader = false;
                switch (headerName)
                {
                    // some headers go to content...
                    case "Allow":
                    case "Content-Disposition":
                    case "Content-Encoding":
                    case "Content-Language":
                    case "Content-Length":
                    case "Content-Location":
                    case "Content-MD5":
                    case "Content-Range":
                    case "Content-Type":
                    case "Expires":
                    case "Last-Modified":
                        contentHeader = true;
                        break;

                    case "Referer":
                        if (RewriteReferer && Uri.TryCreate(headerValue, UriKind.Absolute, out var referer)) // if relative, don't handle
                        {
                            var builder = new UriBuilder(referer);
                            builder.Host = TargetUrl.Host;
                            builder.Port = TargetUrl.Port;
                            headerValue = builder.ToString();
                        }
                        break;

                    case "Host":
                        host = headerValue;
                        if (RewriteHost)
                        {
                            headerValue = TargetUrl.Host + ":" + TargetUrl.Port;
                        }
                        break;
                }

                if (contentHeader)
                {
                    msg.Content.Headers.Add(headerName, headerValue);
                }
                else
                {
                    msg.Headers.Add(headerName, headerValue);
                }
            }

            using (var response = await _client.SendAsync(msg).ConfigureAwait(false))
            {
                using (var os = context.Response.OutputStream)
                {
                    context.Response.ProtocolVersion = response.Version;
                    context.Response.StatusCode = (int)response.StatusCode;
                    context.Response.StatusDescription = response.ReasonPhrase;

                    foreach (var header in response.Headers)
                    {
                        context.Response.Headers.Add(header.Key, string.Join(", ", header.Value));
                    }

                    foreach (var header in response.Content.Headers)
                    {
                        if (header.Key == "Content-Length") // this will be set automatically at dispose time
                            continue;

                        context.Response.Headers.Add(header.Key, string.Join(", ", header.Value));
                    }

                    var ct = context.Response.ContentType;
                    if (RewriteTargetInText && host != null && ct != null &&
                        (ct.IndexOf("text/html", StringComparison.OrdinalIgnoreCase) >= 0 ||
                        ct.IndexOf("application/json", StringComparison.OrdinalIgnoreCase) >= 0))
                    {
                        using (var ms = new MemoryStream())
                        {
                            using (var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))
                            {
                                await stream.CopyToAsync(ms).ConfigureAwait(false);
                                var enc = context.Response.ContentEncoding ?? Encoding.UTF8;
                                var html = enc.GetString(ms.ToArray());
                                if (TryReplace(html, "//" + _targetHost + ":" + _targetPort + "/", "//" + host + "/", out var replaced))
                                {
                                    var bytes = enc.GetBytes(replaced);
                                    using (var ms2 = new MemoryStream(bytes))
                                    {
                                        ms2.Position = 0;
                                        await ms2.CopyToAsync(context.Response.OutputStream).ConfigureAwait(false);
                                    }
                                }
                                else
                                {
                                    ms.Position = 0;
                                    await ms.CopyToAsync(context.Response.OutputStream).ConfigureAwait(false);
                                }
                            }
                        }
                    }
                    else
                    {
                        using (var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))
                        {
                            await stream.CopyToAsync(context.Response.OutputStream).ConfigureAwait(false);
                        }
                    }
                }
            }
        }
    }

    public void Stop() => _listener.Stop();
    public override string ToString() => string.Join(", ", Prefixes) + " => " + TargetUrl;
    public void Dispose() => ((IDisposable)_listener)?.Dispose();

    // out-of-the-box replace doesn't tell if something *was* replaced or not
    private static bool TryReplace(string input, string oldValue, string newValue, out string result)
    {
        if (string.IsNullOrEmpty(input) || string.IsNullOrEmpty(oldValue))
        {
            result = input;
            return false;
        }

        var oldLen = oldValue.Length;
        var sb = new StringBuilder(input.Length);
        bool changed = false;
        var offset = 0;
        for (int i = 0; i < input.Length; i++)
        {
            var c = input[i];

            if (offset > 0)
            {
                if (c == oldValue[offset])
                {
                    offset++;
                    if (oldLen == offset)
                    {
                        changed = true;
                        sb.Append(newValue);
                        offset = 0;
                    }
                    continue;
                }

                for (int j = 0; j < offset; j++)
                {
                    sb.Append(input[i - offset + j]);
                }

                sb.Append(c);
                offset = 0;
            }
            else
            {
                if (c == oldValue[0])
                {
                    if (oldLen == 1)
                    {
                        changed = true;
                        sb.Append(newValue);
                    }
                    else
                    {
                        offset = 1;
                    }
                    continue;
                }

                sb.Append(c);
            }
        }

        if (changed)
        {
            result = sb.ToString();
            return true;
        }

        result = input;
        return false;
    }
}
于 2019-09-21T09:52:11.233 回答
2

浏览器连接到代理,因此代理从 Web 服务器获取的数据只是通过浏览器向代理发起的相同连接发送。

于 2008-11-03T16:15:52.110 回答