开发一个http代理服务器

最新推荐文章于 2024-02-07 09:46:42 发布
最新推荐文章于 2024-02-07 09:46:42 发布
阅读量1k 收藏 4
点赞数
文章标签： 运维 网络

参考链接：

http://www.cnblogs.com/jivi/archive/2013/03/10/2952860.html

https://www.2cto.com/kf/201405/297926.html

http://www.jb51.net/article/116591.htm

http://www.jb51.net/article/79893.htm

http://blog.csdn.net/u012734441/article/details/44801523

http://blog.csdn.net/turkeyzhou/article/details/5512348

http://blog.csdn.net/u013087513/article/details/53560827

一、产品原型

1、配置使用代理服务器

参照上图设置，HTTPS和FTP等不要设置（本代理服务器未对这两种协议进行处理）, IP是 127.0.0.1 表示代理服务器是在本机，监听端口设成8888。   

在IE里设置完后，我们会发现其它浏览器也自动开始使用代理服务器了，这是因为设置代理服务器是系统的功能，每个浏览器打开的都是同一个设置代理服务器的程序。

其实，我们可以实现一个自动设置代理服务器的功能，这样，当我们的代理服务器启动的时候，就自动将本机的代理服务器设置成自己，退出的时候，再恢复成原样，这样就不再需要向上面一样手动设置了。

2、使用代理服务器

配置完毕后，在浏览器里输入网址： http://www.baidu.com 

我们可以清楚看到，所有的请求和响应信息都已经被监听到了。

二、理论储备

1、http请求处理过程

客户端先建立一个和服务端的TCP连接，然后利用这个TCP连接将一份象上面一样的HTTP请求报文发到服务端，

服务端监听到这个请求，然后利用Accept建立一条和这个客户端的专门连接，然后利用这个专门连接读取这一段请求报文，然后再分析这段报文，当他看到有connection:keep-alive的首部时，服务端就知道，客户端要求建立持久连接，服务端根据实际情况对这个请求进行处理。      

a.  如果服务端不同意建立持久连接，那么会在响应报文里加上一个首部 connection:close 。然后再利用这个专门连接将这个响应报文发回给客户端，接着服务端就会关闭这条连接，

     客户端会收到服务器刚才的应答信息，看到了connection:close,这时候客户端就知道服务端拒绝了他的持久连接，那么，客户端在完成这次响应报文的解析后会关闭这条连接，当下次再有请求发送到这个服务器的时候，会重新建一个连接。

b.  如果服务端同意建立持久连接，那么会在响应报文里加上一个首部connection:keep-alive。然后利用这个专门连接，将这个响应报文发回给客户端, 但不关闭这条连接，而是阻塞在那里，直到监视到有新的请求从这个连接传来，再接着处理。

     客户端收到刚才的响应报名，看到了connection:keep-alive，于是客户端知道服务端同意了他的持久连接请求，那么客户端也不会关闭这个连接，当有新的向此服务器发送的请求时，客户端就会通过这个已经打开的连接进行传输，这样就可以节省很多时间（连接建立的时间是很耗时的）。

2、http请求报文

 

http请求报文包含如下三部分：

http请求报文例子分析：

关于请求头host补充一下：请求头host冒号后面的部分除了采用 域名:端口 的方法，还可以采用 IP:端口的方法。

例如 host:192.168.1.12:8080 。这种情况下，第二个冒号前面的就是IP了。

如果是域名，host:www.domain.com 的情况。这种情况，就需要从域名得到IP了。那么从域名--IP，需要什么技术呢，自然就是DNS(Domain Name System)了。

在本地的DNS缓存里找域名对应的IP，然后封装成IPAddress类型的数组进行返回。为什么返回的是数组? 

因为有IPV4和IPV6两种类型的地址，但在一些不支持IPV6的机器上，IPV6项会被筛选掉，所以这种情况下，这个数组的大小就是1。

3、http响应报文

 

4、如果设置了代理

当没有设置代理的时候，正常的HTTP请求报文格式应该是这样的

但是如果设置了代理，那么浏览器的请求报文都会被发送到代理服务器，在这种情况下，浏览器会对请求报文做些简单的变化，主要在两个方面。

4.1、区别一：post / http/1.1 ----》post http://www.domain.com/ http/1.1

我们看到在直接发送到目标服务器的情况下，一般都是相对的地址（前面的例子默认都是这种情况下的）：

post / http/1.1

而在发送到代理服务器的情况下，就会变成：

post http://www.domain.com/ http/1.1

<request-url> 部分被替换成了完整的URL地址。为什么要这样做呢，是因为早期的HTTP协议，是没有HOST首部的，这样当直接连接到服务器时，是没有问题的，因为服务器IP在发送报文前肯定是已知的，所以这种情况只要传个相对路径给服务器,服务器就可以通过这个相对路径找到资源并返回了。

但是如果是发送到代理的话，这个请求报文就出问题了，因为代理无法从这个请求报文里分析出来目标服务器的地址，地址都不知道代理又如何将这个请求转发呢。

所以，在HTTP协议里将发送到代理服务器情况下的请求报文里的<request-url>设计成了完整地址，这样代理服务器就可以通过分析这个完整的址址的主机部分获取目标服务器的地址，如此就可能顺利的建立到目标服务器的连接并实现转发了。

但是后来随着虚拟主机的出现，同一个服务器可以映射多个站点，没有HOST首部的HTTP协议，已经没办法处理这种情况了，所以后来HTTP协议里引入了HOST这个首部，

理论上在引入了HOST首部后，不仅虚拟主机的情况可以解决，就连代理服务器也可以一并解决了，就不用再在<request-url>里写完整地址了，但是为了保持协议的兼容性，当发送到代理服务器时<request-url>为完整地址的规则还是被继承了下来。 

4.2、区别二： connection:keep-alive/close  ----》proxy-conection:keep-alive/close

那就是当直接发送到目标服务器时，有个首部是
connection:keep-alive/close
当发送到代理服务器时，这个首部会被替换成
proxy-conection:keep-alive/close

这段代码在 ServerChatter 类里的 ResendRequest方法体里。这里又出现了this._bWasForwarded.  意思是 如果继续转发请求给代理服务器或网关，而且不是HTTPS的情况下，就把proxy-connection 替换成 connection .

然而程序本身是没有办法判断出要转发到的目标服务器究竟是不是代理服务器或者网关的，所以这个变量，不在人工干预的情况下，百分之百是FALSE的 。在我们的代码里，目前并没有实现人工干预的功能，所以这个变量永远都是FALSE。保留他下来只是为了以后的扩展。

事实上代理服务器确实不一定会把请求直接转发到最终的目标服务器，而是有可能先转发到另外一个代理服务器或者网关上，然后再由他们转发到最终的目标服务器或者他也是再转发至下一个代理服务器或者网关。

因为我们很有可能会遇到下面的这种情况， 在自己的内网建了一个过滤代理，这个过滤代理的功能就是把除了公司想让我们访问的网址以外的所有网址全部屏蔽，但是现在出问题了，公司想让我们访问的网站，全部都是被天朝封锁的国外网站，这可怎么办呢?

其实不难办，这时候只要过滤代理再把这个请求转发给另外一个代理服务器（这个服务器要求在国内能访问，另外它也能访问国外的网站就可以了），然后由它来获取网页后响应给我们的过滤代理,再由我们的过滤代理发回给客户端 。 

三、关键点设计

代理服务器程序启动时，new 一个代理(Proxy)类的实例,然后调用这个实例的Start方法，在Start方法里不停的异步监听代理服务器8888端口, 

如果监听到了，就从线程池里取出来一个线程，并在这个线程里构造一个Session对象。一个Session对象代表客户端与服务器的一次会话，在有代理服务器情况下的一次会话(Session) 过程如下：

  • 1.从客户端读请求
  • 2.重新包装客户端的请求，转发至目标服务器. 
  • 3.从目标服务器读取响应信息 
  • 4.包装接收到的响应信息并返回给客户端。

故而在Session类里，封装一个ClientChatter类型的名为Request的对象，用来实现和客户端的通讯, 另外又封装了一个ServiceChatter类型的名为Response的对象，用来实现和目标服务器的通讯。 

1、ObtainRequest()

这里就是不停的读取请求信息，直到读取完成为止。读取的同时将这些请求信息存在this.m_requestData(MemoryStream类型)这个全局变量里。有一点要注意一下,那就是判断接收结束的方法。也就是while里面的那三个条件：

  • 一个是 flag2 = true , 从上面的代码可以看出，就是iMaxByteCount = 0 ，客户端关闭了链接 
  • 另外一个条件是 flag = true,也就是出意外了，出意外了自然结束
  • 还有一个就是 isRequestComplete()， 封装了两种结束方式：content-length结束和transfer-encoding:chunked方式结束 

iMaxByteCount = 0 了，不就代表已经读取完客户端发过来的请求数据了吗，当然不是，iMaxByteCount其实是客户端关闭了链接。

这个iMaxByteCount 其实是Socket.Receive的返回值, Socket.Receive(byte[] buffer)  从绑定的 Socket 套接字接收数据，将数据存入接收缓冲区。  

当读不到数据的时候，Receive方法会阻塞在那里，直到有数据到达，或者超时为止，而不是象我们想象的那样返回0，返回0只有一种情况，就是Socket.Shutdown(),也就是连接的那个Socket关闭了他的连接,在这里也就是客户端关闭了连接。    

所以说一般情况下，我们是不可能通过iMaxByteCount=0（iMaxByteCount= Socket.receive()）来判断是否已经读取完了客户端的请求报文（用户在请求过程上，关闭了浏览器可能会发生这种情况）。 

请求接收结束时机 isRequestComplete（）->content-length方式结束

当客户端将请求报文发送到服务器后，连接是不会关闭的，客户端是否关闭连接，要等到服务器响应后才决定。 

也就是说一般情况下，我们是不可能通过iMaxByteCount=0（iMaxByteCount= Socket.receive()）来判断是否已经读取完了客户端的请求报文（用户在请求过程上，关闭了浏览器可能会发生这种情况）。 那么我们又怎么来判断请求报文已经全部接收完成了呢？ 

 

请求头：content-length:8, 表示实体 <entity-body>（在上面的例子里就是a=b&b=cd）的长度，那么<head>头部解析完后再读取content-length个字符，不就表示此次的请求已经全部读取完成了吗？ 

实际的处理如下： 

请求接收结束时机 isRequestComplete（）->transfer-encoding:chunked方式结束  

当然content-length并不能判断所有的情况，只有确切的知道entity-body长度的情况下,content-length才是有意义的。 

但是事实上entity-body的长度并不总是可以预知的，尤其在传一些大文件的时候，为了节省资源和时间，一般会采用分块传输的方式，采用分块传输的时候，会在报文里增加一个首部transfer-encoding:chunked,另外在entity-body里也要遵循一定的格式， 

这种情况在请求报文里很少见，因为请求报文在不选择文件进行提交的时候，一般报文都很小，这种情况主要出现在响应报文里。这种情况一般会有如下处理方式： 

同时，isRequestComplete（）解析了请求报文头，ParseRequestForHeaders()

if (!this.ParseRequestForHeaders())
这个就是分析报头的代码了，前面提到过，会将原始报头映射到一个HTTPRequestHeaders类型的对象里，那么这个方法就是做那个的了，

此方法执行完成后，会把原始的请求报文流中的报头部分(除entity-body以外的部分)分析到一个HTTPRequestHeaders类型的私有属性(m_headers)里。

然后在ClientChatter里又暴露了一个Public的属性Headers来访问这个属性。当然这个方法里还会记录entity-body的起始位置，这样，在后面的TakeEntity方法就可以通过这个位置读取entity-body的内容了。

而TakeEntity会在 Session类的ObtainRequest里被调用this.RequestBodyBytes = this.Request.TakeEntity();

Session类的ObtainRequest方法终于分析完成! 

调用完Session的ObtainRequest方法后,程序会变成什么样呢,经过刚才的分析其实已经很清楚了。

这时在Session类里，只要使用this.Request.Headers就可以获得所有的报头信息了。报体部分entity-body 则是通过this.RequestBodyBytes 进行调用 。 

2、response.ResendRequest

 

核心逻辑分析如下：

其中，

a、this.ConnectToHost();  

// 构造一个ServerPipe，并在里面封装一个和服务端通讯的Socket

// 获取ip（可以通过dns解析域名，从在本地的DNS缓存里找域名对应的IP得到）

// 获取端口

// 创建链接

this.ConnectToHost() 展开如下：

 

b、this.ServerPipe.Send( this.m_session.Request.Headers.ToByteArray( true, true, this._bWasForwarded && !this.m_session.IsHTTPS ) );

// 通过这个ServerPipe的Send方法将使用this.m_session.Request.Headers.ToByteArray方法重新包装的请求报头发送给服务器 。

 

c、this.ServerPipe.Send(this.m_session.RequestBodyBytes);

 

// 发送原始请求报文的报体到服务器

 

3、response.ReadRequest

 响应报文：

ReadResponse（ServerChatter.cs里）方法和读取请求报文时（ClientChatter的ReadRequest方法）基本上是一样的，都是不停的使用Receive方法接收数据,直到已经接收完成为止（也要判断三种情况）。
然后再将接收到的响应信息映射到一个HTTPResponseHeaders 类型的对象里，这个对象名叫_inHeaders。同样的也有一个public的Headers属性来访问它。
和读取请求报文时一样，这个方法里，也会记录<entity-body>的偏移位置，以备 TakeEntity方法调用时，用来读取entito-body 部分。

  • version : HTTP的版本号,例如 HTTP/1.1 or HTTP/1.0
  • status ： 状态码 常见的 200 成功 404 没有找到文件 500 服务器错误等
  • reason-phrase : 对于状态码的简短解释，这个解析不同的服务器内容可能不尽相同。例如 当 status为200时，这里可以是 OK
  • head : 首部,可以有0个或者多个，每个首部都是key:value的形式，然后以CRLF(回车换行)结束 例如： content-type:text/html
  • entity-body 主体内容，返回的HTML，或者二进制的图片，视频等数据都在这一部分

 

 

4、returnResponse

 

weixin_33747129
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
c语言代理服务器.zip_C语言_HTTP代理服务器_c代理IP开发_代理服务器
07-13
用C语言实现的http代理服务器，可自己更改进行网站引导，网站屏蔽，用户屏蔽
HTTP代理服务器的设计与实现
tu_gou的博客
10-10 3204
哈工大计算机网络实验一—HTTP代理服务器的设计与实现
HTTP 代理服务器的设计与实现
qq_42754642的博客
11-24 1593
HTTP 代理服务器的设计与实现 首先当然是最重要的代码：github地址 1) 实验目的 熟悉并掌握 Socket 网络编程的过程与技术；深入理解 HTTP 协议，掌握 HTTP 代理服 务器的基本工作原理；掌握 HTTP 代理服务器设计与编程实现的基本技能。 2) 实验内容 基于 java 实现了基本功能与全部附加功能，并增加了 https 的支持 (1) 设计并实现一个基本 HTTP 代理服...
基于Linux的HTTP代理服务器搭建与配置实战
最新发布
weixin_73725158的博客
02-07 1350
在数字化世界中，HTTP代理服务器扮演着至关重要的角色，它们能够帮助我们管理网络请求、提高访问速度，甚至在某些情况下还能保护我们的隐私。而Linux系统，凭借其强大的功能和灵活性，成为了搭建HTTP代理服务器的理想选择。这些软件各有特点，比如Squid功能全面、易于配置，Varnish则更侧重于缓存和性能优化，而Nginx则可以作为反向代理和负载均衡器使用。现在，你可以根据自己的需求进行进一步的配置和优化，享受代理服务器带来的便利和高效。定期清理Squid的缓存文件，以避免占用过多的磁盘空间。
搭建简单的http代理服务器
weixin_43145985的博客
05-20 8334
1.安装squid yum install squid 2.修改配置文件 vi /etc/squid/squid.conf 将http_access deny all 中deny 改为allow,http_port后面的是端口号，默认为3128。可改可不改。 3.重启服务 service squid restart 到这里，就配置完成了。 ...
http(s)代理服务器与搭建
as you know, nlp is fantasitc!
05-02 2823
写在前面：为了复现*ctf的oh-my-lotto那道题，补了一下关于代理方面的知识，顺便做一下总结 文章目录1、代理透明度2、正向代理和反向代理3、hosts文件4、设置http_proxy、https_proxy5、tinyproxy的配置6、测试代理是否配置成功 1、代理透明度 全匿名代理 普通代理 全透明代理 2、正向代理和反向代理 正向代理，代理服务器代表客户端向服务端发送请求，这样可以隐藏真实的客户端 反向代理表示，代理服务器代表服务端向客户端返回请求，这样可以隐藏真实的服务端 3、ho
http/https代理服务器搭建
kennyz的专栏
12-05 1541
从服务端机器直接通过代理端口3128是可以直接访问国外，所以使用隧道方式映射服务器端的3128端口与客户端的端口，实现代理访问。期间尝试过使用搭建vpn方式，但连接一直有问题，还在尝试解决，后续如果解决，再追加补充连接方式。设置好隧道后，客户端先通过xshell登录至服务器，打通隧道的端口映射。安装完成后，我们可以使用以下命令来检查Squid是否已经成功安装。需求：搭建代理服务器，通过浏览器设置代理后访问国外网站。将地址设置为127.0.0.1，端口设置为3128.再测试代理，发现已经成功代理。
C#实现HTTP代理服务器技术
03-13
采用c#实现的代理服务器技术，绝对的通俗易懂，而且可以作为很好的学习案例进行分析。特别是和http协议打交道比较多的c#.net程序员可千万别错过哦！只要能够学到东西，积分都是浮云
Java的HTTP代理服务器 Smart Cache
06-02
Java的HTTP代理服务器 Smart Cache
springboot集成netty实现代理服务器
12-21
springboot集成netty实现代理服务器，实现http和https请求的代理功能
超简单--搭建http、https代理服务器
yayun616的博客
03-09 1845
搭建http、https代理服务器
编写简单的代理服务器(java源码)
01-14
基本原理： 代理服务器打开一个端口接收浏览器发来的访问某个站点的请求，从请求的字符串中解析出用户想访问哪个网页，让后通过URL对象建立输入流读取相应的网页内容，最后按照web服务器的工作方式将网页内容发送给用户浏览器 源程序： import java.net.*; import java.io.*; public class MyProxyServer { public static void main(String args[]) { try { ServerSocket ss=new ServerSocket(8080); System.out.println("proxy server OK"); while (true) { Socket s=ss.accept(); process p=new process(s); Thread t=new Thread(p); t.start(); } } catch (Exception e) { System.out.println(e); } } }; class process implements Runnable { Socket s; public process(Socket s1) { s=s1; } public void run() { String content=" "; try { PrintStream out=new PrintStream(s.getOutputStream()); BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream())); String info=in.readLine(); System.out.println("now got "+info); int sp1=info.indexOf(' '); int sp2=info.indexOf(' ',sp1+1); String gotourl=info.substring(sp1,sp2); System.out.println("now connecting "+gotourl); URL con=new URL(gotourl); InputStream gotoin=con.openStream(); int n=gotoin.available(); byte buf[]=new byte[1024]; out.println("HTTP/1.0 200 OK"); out.println("MIME_version:1.0"); out.println("Content_Type:text/html"); out.println("Content_Length:"+n); out.println(" "); while ((n=gotoin.read(buf))>=0) { out.write(buf,0,n); } out.close(); s.close(); } catch (IOException e) { System.out.println("Exception:"+e); } } };
java开发的代理服务器
04-30
转载的别人写的用java语言开发的代理服务器，文档中介绍了http，scoket 等几种方式的代理
基于C++实现的HTTP代理服务器设计
毕业作品网站
06-12 1527
对应的操作是申请一个socket，这时的socket称为“欢迎套接字”，然后绑定（bind）本地地址信息和欢迎套接字，然后开放监听（listen）。代理服务器，俗称“翻墙软件”，允许一个网络终端（一般为客户端），通过这个服务与另一个网络终端（一般为服务器）进行非直接的连接。（1）打开一通信通道，即建立起要与服务器传输数据的套接字socket，通过connect连接到服务器所在主机的特定端口；（1）客户与服务器进程的作用是非对称的，因此代码不同。（1）客户与服务器进程的作用是非对称的，因此代码不同。
CentOS 6.5搭建http代理服务器(TinyProxy)
shuishen49的专栏
01-21 4483
CentOS 6.5搭建http代理服务器(TinyProxy) 应用场景：比如公司网络限制了一些网站的访问，而你需要访问，那么不得不借助一些代理服务器进行访问。 Linux代理软件可以选择强大的Squid，不过Squid略显复杂，为了最快速度完成一个http代理，那么我们使用另外一款小巧的TinyProxy代理软件。 CentOS 6.5如何搭建一个http代理服务器呢？ 1、安装T...
用Java开发HTTP代理服务器
weixin_44617651的博客
05-31 1796
HTTP代理服务器是一种网络应用，它充当位于客户端和目标服务器之间的中间节点，将客户端发出的HTTP请求转发给目标服务器，并将目标服务器返回的HTTP响应内容回传给客户端。通过使用代理服务器，客户端可以避免直接访问目标服务器，从而更加安全地访问互联网资源。
Java代理服务开发
yhj198927的博客
07-08 1820
目前许多公司在部署项目时，会采用内外网隔离的方式进行部署，当需要访问外网接口或者资源时，采用代理转发实现。此时代理转发有两种方式一种是透明转发，另一种是非透明转发。1.非透明转发非透明转发只需要将转发地址在配置文件里配置，然后在ProxyController里将配置的地址进行转发就可以了2.透明转发使用透明转发有两种方式第一种：使用命令行参数 （1）如果只需要考虑代理 HTTP 协议请求，只需添加如下命令行参数： (2) 如果只需要考虑代理 H
用Java开发代理服务器
myali88的专栏
12-06 5449
源文作者俞良松        代理服务器的应用非常广泛。比如，在企业网内部，它可以用来控制员工在工作时浏览的Internet内容，阻止员工访问某些类型的内容或某些指定的网站。代理服务器实际上扮演着浏览器和Web服务器之间的中间人的角色，能够对浏览器请求进行各种各样的处理，能够过滤广告和Cookie，能够预先提取Web页面，使得浏览器访问页面的速度更快，等等。 一、基础知识 不管以哪种方式应用代理服
java netty开发一个http/https代理
06-07
下面是一个简单的 Java Netty 实现的 HTTP/HTTPS 代理服务代码示例： ```java import io.netty.bootstrap.Bootstrap; import io.netty.bootstrap.ServerBootstrap; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.Channel; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioSocketChannel; import io.netty.handler.codec.http.DefaultFullHttpResponse; import io.netty.handler.codec.http.DefaultHttpRequest; import io.netty.handler.codec.http.HttpClientCodec; import io.netty.handler.codec.http.HttpContent; import io.netty.handler.codec.http.HttpHeaders; import io.netty.handler.codec.http.HttpMethod; import io.netty.handler.codec.http.HttpObject; import io.netty.handler.codec.http.HttpResponse; import io.netty.handler.codec.http.HttpServerCodec; import io.netty.handler.codec.http.HttpVersion; import io.netty.handler.ssl.SslContext; import io.netty.handler.ssl.SslContextBuilder; import io.netty.handler.ssl.SslHandler; import io.netty.handler.ssl.util.InsecureTrustManagerFactory; import io.netty.util.CharsetUtil; import javax.net.ssl.SSLEngine; import java.net.InetSocketAddress; import java.util.HashMap; import java.util.Map; public class HttpsProxyServer { private final int port; public HttpsProxyServer(int port) { this.port = port; } public void start() throws Exception { EventLoopGroup bossGroup = new NioEventLoopGroup(1); EventLoopGroup workerGroup = new NioEventLoopGroup(); try { ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .localAddress(new InetSocketAddress(port)) .childHandler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ch.pipeline().addLast(new HttpServerCodec()); ch.pipeline().addLast(new HttpsProxyServerHandler()); } }) .childOption(ChannelOption.AUTO_READ, false) .bind().sync().channel().closeFuture().sync(); } finally { bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); } } public static void main(String[] args) throws Exception { if (args.length != 1) { System.err.println("Usage: " + HttpsProxyServer.class.getSimpleName() + " <port>"); return; } int port = Integer.parseInt(args[0]); new HttpsProxyServer(port).start(); } private static final class HttpsProxyServerHandler extends SimpleChannelInboundHandler<HttpObject> { private Channel clientChannel; private Channel serverChannel; private SSLEngine sslEngine; private boolean isHttps; private final Map<String, String> headers = new HashMap<>(); @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { clientChannel = ctx.channel(); } @Override public void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception { if (msg instanceof DefaultHttpRequest) { DefaultHttpRequest request = (DefaultHttpRequest) msg; String requestUri = request.getUri(); isHttps = requestUri.startsWith("https://"); String[] hostParts = HttpHeaders.getHost(request).split(":"); String host = hostParts[0]; int port = isHttps ? 443 : (hostParts.length > 1 ? Integer.parseInt(hostParts[1]) : 80); Bootstrap b = new Bootstrap(); b.group(clientChannel.eventLoop()) .channel(NioSocketChannel.class) .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000) .handler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { if (isHttps) { sslEngine = SslContextBuilder.forClient() .trustManager(InsecureTrustManagerFactory.INSTANCE) .build().newEngine(ch.alloc(), host, port); ch.pipeline().addLast(new SslHandler(sslEngine)); } ch.pipeline().addLast(new HttpClientCodec()); ch.pipeline().addLast(new HttpsProxyServerHandler()); } }) .connect(host, port) .addListener((ChannelFuture future) -> { if (future.isSuccess()) { serverChannel = future.channel(); } else { clientChannel.close(); } }); headers.clear(); for (Map.Entry<String, String> entry : request.headers()) { headers.put(entry.getKey(), entry.getValue()); } headers.remove(HttpHeaders.Names.HOST); b.channel(NioSocketChannel.class) .connect(host, port) .addListener((ChannelFuture future) -> { if (future.isSuccess()) { serverChannel = future.channel(); serverChannel.writeAndFlush(request.retain()); clientChannel.read(); } else { clientChannel.close(); } }); } else if (msg instanceof HttpResponse) { HttpResponse response = (HttpResponse) msg; response.headers().remove(HttpHeaders.Names.TRANSFER_ENCODING); response.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.CLOSE); clientChannel.writeAndFlush(response.retain()); } else if (msg instanceof HttpContent) { HttpContent content = (HttpContent) msg; clientChannel.writeAndFlush(content.retain()); if (content instanceof LastHttpContent) { if (isHttps) { sslEngine.closeOutbound(); } clientChannel.flush(); clientChannel.close(); serverChannel.close(); } } } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { if (clientChannel.isActive()) { clientChannel.writeAndFlush(new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_GATEWAY, Unpooled.copiedBuffer("Failure: " + cause.getMessage(), CharsetUtil.UTF_8))) .addListener(ChannelFutureListener.CLOSE); } } } } ``` 这是一个简单的 HTTP/HTTPS 代理服务，可以接收来自客户端的请求，并将其转发到目标服务器。如果请求是 HTTPS 请求，它还会与目标服务器建立安全连接。 在这个示例中，我们使用了 Netty 的 HTTP/HTTPS 编解码器和 SSL 处理程序来处理请求和响应，并将它们转发到目标服务器。在建立与目标服务器的连接时，我们还使用了 Netty 的 Bootstrap 类来创建客户端通道。 当客户端发送请求时，我们从请求中提取目标主机和端口，并使用 Bootstrap 类创建一个新的客户端通道，然后将请求发送到目标服务器。在接收到来自目标服务器的响应时，我们将响应转发给客户端。 如果请求是 HTTPS 请求，我们还需要使用 SSL 处理程序来建立与目标服务器的安全连接。我们使用 Netty 的 SslContextBuilder 类创建一个 SSL 引擎，并将其添加到客户端通道的管道中。在建立与目标服务器的连接时，我们还需要使用 SslHandler 将 SSL 引擎添加到客户端通道的管道中，以便进行 SSL 握手。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值