"+(new Date().toString())+":"+msg+"
");
46 | }
47 |
48 |
49 | function pproxy_net_local_filter(host,path){
50 | if(!_pproxy_filter(host,$("#net_local_host").val())){
51 | return false;
52 | }
53 | if(!_pproxy_filter(path,$("#net_local_path").val())){
54 | return false;
55 | }
56 | return true;
57 | }
58 |
59 | function _pproxy_filter(kw,kwstr){
60 | if(kwstr==""){
61 | return true;
62 | }
63 | var kws=(kwstr+"").split("|");
64 | kw+="";
65 | var tmp=[]
66 | for(var i in kws){
67 | var _kw=$.trim(kws[i]+"");
68 | if(_kw!=""){
69 | tmp.push(_kw);
70 | }
71 | }
72 | if(tmp.length==0){
73 | return true;
74 | }
75 | for (var i in tmp){
76 | if(kw.indexOf(tmp[i])!=-1){
77 | return true;
78 | }
79 | }
80 | return false;
81 | }
82 |
83 | socket.on('connect', function() {
84 | connectNum++
85 | if(connectNum>1){
86 | pproxy_log("ws error.connectNum="+connectNum);
87 | socket.emit("disconnect");
88 | return;
89 | }
90 | $("#connect_status").html("online")
91 | $("#network_filter_form").change();
92 | });
93 |
94 | socket.on("disconnect", function() {
95 | connectNum--;
96 | $("#connect_status").html("offline");
97 | });
98 |
99 | socket.on("hello",function(data){
100 | console && console.log(new Date().toString(),data);
101 | });
102 |
103 | function pproxy_getColor(addr){
104 | var info=addr.split(":");
105 | if(info.length!=2){
106 | return "#FFFFFF";
107 | }
108 | var ip=info[0];
109 | var color=ip_colors[ip];
110 | if(!color){
111 | var l=0;
112 | for(var _t in ip_colors){
113 | l++;
114 | }
115 | color=pproxy_colors[l% pproxy_colors.length];
116 | ip_colors[ip]=color;
117 | }
118 | return color
119 | }
120 |
121 |
122 | function pproxy_show_req(data) {
123 | console && console.log("pproxy_show_req:",data)
124 | // var dataStr=Base64.decode(dataStr64+"");
125 | // var data={};
126 | // try{
127 | // data=$.parseJSON(dataStr)
128 | // }catch(e){
129 | // console && console.log("parseJSON_error-pproxy_show_req",e,"datastr:",dataStr)
130 | // return
131 | // }
132 |
133 | // console && console.log("req", data)
134 | var html="" + data["host"] + "
" +data["method"]+" "+ h(data["path"])+ "
| url | " + h(req["url"]) + " view |
|---|---|
| origin | " + h(req["url_origin"]) + " |
| msg | " + h(req["msg"])+" |
| proxy_urer | " + 199 | "remote_addr : " +req["client_ip"] + " docid : "+ req["id"] + 200 | " |
| req_dump | " + h(Base64.decode(req["dump"])).replace(/\n/g, " ") 205 | + " |
| msg | " + h(res["msg"])+" |
|---|---|
| res_dump | " + h(Base64.decode(res["dump"])).replace(/\n/g, " ") 224 | + " |
| body_json | " + bd_json + " |
| body_img | |
| body"; 245 | if(res["body"].length>400){ 246 | html+=""; 247 | }else{ 248 | hideBigBody=false; 249 | } 250 | html+= " | " + 251 | "" +
252 | " " + h(body_str).replace(/\n/g, " ") + 253 | " |
" + json_str + ""; 295 | } 296 | } catch (e) { 297 | console.log("pproxy_parseAsjson_error",e); 298 | } 299 | return false; 300 | } 301 | 302 | function pproxy_tr_sub_table(obj, name) { 303 | if (!obj) { 304 | return ""; 305 | } 306 | var html = "
| " + k + " |
|
|---|
2 |
3 |
10 | 11 |
12 | 3 |
about
4 |HTTP protocol analysis tool.
5 |Based on BS architecture,written by golang.
6 |Project : https://github.com/hidu/pproxy
7 |Current Version: {{.version}}
8 | 9 |10 | 11 |
13 |
14 | 15 | 20 | -------------------------------------------------------------------------------- /res/tpl/config.html: -------------------------------------------------------------------------------- 1 | 2 | 5 |
6 |
7 |
8 |
13 |
14 |
15 |
16 |
17 |
20 |
--------------------------------------------------------------------------------
/res/tpl/config/req_demo.html:
--------------------------------------------------------------------------------
1 | | {%my_include "config/req_form.html" %} |
| {%my_include "config/req_demo.html" %} |
| {%my_include "config/hosts_form.html" %} |
| {%my_include "config/hosts_demo.html" %} |
2 | note:
3 |
13 | req demo:show/hide
14 |
42 | -
4 |
- put //ignore at the first line to ignore the js 5 |
- user's js is default,or the global 6 | 7 | {{if not .isLogin}} 8 |
- login to edit your custom profile 9 | {{end}} 10 | 11 |
-------------------------------------------------------------------------------- /res/tpl/config/req_form.html: -------------------------------------------------------------------------------- 1 | req rewrite 2 | {{range $i,$js:=.jss}} 3 | 31 | {{end}} -------------------------------------------------------------------------------- /res/tpl/error.html: -------------------------------------------------------------------------------- 1 |
2 | Error:
3 | {{.error}}
4 |
--------------------------------------------------------------------------------
/res/tpl/file.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
43 |
--------------------------------------------------------------------------------
/res/tpl/file_edit.html:
--------------------------------------------------------------------------------
1 | | no | 13 |14 | {{if .isSubDir}} 15 | ../ 16 | {{end}} 17 | Name 18 | | 19 |Size | 20 |
|---|---|---|
| {{$k}} | 26 |
27 |
28 | {{if $file.IsDir}}  {{else}} {{end}}
29 | {{$file.Name}}
30 |
31 |
32 | {{if $file.IsDir}}
33 | 
34 | {{else}}
35 | 
36 | {{end}}
37 | |
38 | {{$file.Size}} | 39 |
2 |
28 |
29 |
32 |
33 |
--------------------------------------------------------------------------------
/res/tpl/file_new.html:
--------------------------------------------------------------------------------
1 | edit file
3 |
25 |
26 |
27 |
2 |
3 |
22 |
23 |
26 |
27 |
--------------------------------------------------------------------------------
/res/tpl/layout.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 | new file
4 |
19 |
20 |
21 |
46 | {{.body}}
47 |
48 |
49 |
50 |
51 |
--------------------------------------------------------------------------------
/res/tpl/login.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
22 |
--------------------------------------------------------------------------------
/res/tpl/network.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | 3 |
4 |
19 |
20 |
21 | |
8 |
9 |
60 |
61 |
10 |
37 |
38 |
39 |
40 |
47 | #
41 | host
42 |
43 | path
44 |
45 |
46 |
48 |
59 |
|
62 | 63 | 64 | | 65 |
2 |
3 | 97 |
98 |
99 | 100 |
101 |
102 |
138 |
--------------------------------------------------------------------------------
/res/tpl/replay_direct.html:
--------------------------------------------------------------------------------
1 | 3 | 97 |
98 |
99 | 100 |
2 |
3 |
4 | 21 | 22 | 25 | 26 |
--------------------------------------------------------------------------------
/res/tpl/useage.html:
--------------------------------------------------------------------------------
1 | 3 |
4 | 21 | 22 | 25 | 26 |
2 |
3 |
--------------------------------------------------------------------------------
/res/version:
--------------------------------------------------------------------------------
1 | 0.5.2
--------------------------------------------------------------------------------
/script/create_dest_zip.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 |
3 | echo "bye bye"
4 | exit
5 |
6 | cd $(dirname $0)
7 | cd ../
8 |
9 | if [ -z "$1" ];then
10 | gox -arch amd64 -os linux
11 | bash build.sh windows
12 | fi
13 |
14 | version=$(cat res/version)
15 |
16 | cd dest
17 | ################################################
18 |
19 | if [ -d conf ];then
20 | rm -rf conf
21 | fi
22 |
23 | rm -rf data/*
24 | mkdir conf
25 | cp ../res/conf/demo.conf conf/pproxy.conf
26 | echo -e "name:admin psw:psw is_admin:admin">conf/users
27 | cp ../conf/req_rewrite_8080.js conf/
28 | echo -e "news.baidu.com 127.0.0.1\nnews.163.com 127.0.0.1:81">conf/hosts_8080
29 |
30 | t=$(date +"%Y%m%d%H")
31 |
32 | rm pproxy_*.tar.gz pproxy_*.zip
33 |
34 | ################################################
35 | target_linux="pproxy_${version}_linux_$t.tar.gz"
36 |
37 |
38 | mkdir -p linux/data
39 | mkdir -p linux/file/
40 |
41 | cp pproxy ../script/pproxy_control.sh linux/
42 | cp -r conf linux/conf
43 |
44 |
45 | dir_new="pproxy_${version}"
46 | if [ -d $dir_new ];then
47 | rm -rf $dir_new
48 | fi
49 |
50 | mv linux $dir_new
51 | tar -czvf $target_linux $dir_new
52 |
53 | rm -rf $dir_new
54 |
55 |
56 | ################################################
57 | target_windows="pproxy_${version}_windows_$t.zip"
58 |
59 |
60 | mkdir -p windows/data
61 | mkdir -p windows/file/
62 |
63 | cp pproxy.exe windows
64 | cp ../script/windows_run.bat windows/start.bat
65 | cp -r conf windows/conf
66 |
67 |
68 | mv windows $dir_new
69 | zip -r $target_windows $dir_new
70 |
71 | rm -rf $dir_new conf
72 |
73 |
74 |
75 |
--------------------------------------------------------------------------------
/script/pproxy_control.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 |
3 | CUR_DIR=$(dirname $0)
4 |
5 | BIN_NAME="./pproxy"
6 | DEFAULT_CONF="./conf/pproxy.conf"
7 | INTRO="get more info from github.com/hidu/pproxy"
8 |
9 |
10 | CONF_FILE=$2
11 |
12 | if [ -z "$CONF_FILE" ];then
13 | cd $CUR_DIR
14 | CONF_FILE="$DEFAULT_CONF"
15 | fi
16 |
17 | CONF_PATH=$(readlink -f "$CONF_FILE")
18 |
19 | cd $CUR_DIR
20 |
21 | BIN_PATH=$(readlink -f $BIN_NAME)
22 |
23 | if [ ! -f "$CONF_PATH" ];then
24 | echo "conf file[${CONF_PATH}] not exists!"
25 | exit 2
26 | fi
27 |
28 |
29 | RUN_CMD="$BIN_PATH -conf $CONF_PATH"
30 |
31 | function start(){
32 | nohup $RUN_CMD>/dev/null 2>&1 &
33 | status=$?
34 | if [ "$status" == "0" ];then
35 | echo "start suc! pid="$!
36 | else
37 | echo "start failed!"
38 | exit 2
39 | fi
40 | }
41 |
42 | function stop(){
43 | list=$(ps aux|grep "$RUN_CMD"|grep -v grep)
44 | if [ -z "${list}" ];then
45 | echo "no process to kill"
46 | else
47 | pid=$( echo "$list"|awk '{print $2}')
48 | kill $pid
49 | if [ "$?"=="0" ];then
50 | echo "stop suc! pid=${pid}"
51 | else
52 | echo "stop failed! pid=${pid}"
53 | exit 3
54 | fi
55 | fi
56 | }
57 |
58 | function restart(){
59 | stop
60 | start
61 | }
62 |
63 | function useage(){
64 | echo "pproxy useage:"
65 | echo $0 "start|stop|restart" [conf_path]
66 | echo -e "$INTRO"
67 | }
68 |
69 | if [ $# -lt 1 ]; then
70 | useage
71 | exit 1
72 | fi
73 |
74 | case "$1" in
75 | start)
76 | start
77 | ;;
78 | stop)
79 | stop
80 | ;;
81 | restart)
82 | restart
83 | ;;
84 | esac
--------------------------------------------------------------------------------
/script/windows_run.bat:
--------------------------------------------------------------------------------
1 | echo "start pproxy,don't close it"
2 | @echo off
3 | pproxy -conf=./conf/pproxy.conf
--------------------------------------------------------------------------------
/serve/auth.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | import (
4 | "encoding/base64"
5 | "net/http"
6 | "strings"
7 |
8 | "github.com/hidu/goutils/str_util"
9 | )
10 |
11 | var proxyAuthorizatonHeader = "Proxy-Authorization"
12 |
13 | func getAuthorInfo(req *http.Request) *User {
14 | defaultInfo := new(User)
15 | authheader := strings.SplitN(req.Header.Get(proxyAuthorizatonHeader), " ", 2)
16 | if len(authheader) != 2 || authheader[0] != "Basic" {
17 | return defaultInfo
18 | }
19 | userpassraw, err := base64.StdEncoding.DecodeString(authheader[1])
20 | if err != nil {
21 | return defaultInfo
22 | }
23 | userpass := strings.SplitN(string(userpassraw), ":", 2)
24 | if len(userpass) != 2 {
25 | return defaultInfo
26 | }
27 | return &User{Name: userpass[0], PswMd5: str_util.StrMd5(userpass[1]), Psw: userpass[1]}
28 | }
29 |
30 | func (ser *ProxyServe) checkUserLogin(userInfo *User) bool {
31 | if userInfo == nil || ser.Users == nil {
32 | return false
33 | }
34 |
35 | if userInfo.SkipCheckPsw {
36 | return true
37 | }
38 |
39 | if user, has := ser.Users[userInfo.Name]; has {
40 | return user.PswMd5 == userInfo.PswMd5
41 | }
42 | return false
43 | }
44 |
45 | // (ser.conf.AuthType == AuthType_Basic && !ser.CheckUserLogin(reqCtx.User))
46 | func (ser *ProxyServe) checkHTTPAuth(reqCtx *requestCtx) bool {
47 | switch ser.conf.AuthType {
48 | case authTypeNO:
49 | return true
50 | case authTypeBasic:
51 | return ser.checkUserLogin(reqCtx.User)
52 | case authTypeBasicWithAny:
53 | return reqCtx.User.Name != ""
54 | case authTypeBasicTry:
55 | if reqCtx.ClientSession.RequestNum == 1 {
56 | return reqCtx.User.Name != ""
57 | }
58 | return true
59 | default:
60 | return false
61 | }
62 | return false
63 | }
64 |
--------------------------------------------------------------------------------
/serve/broadcast.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | import (
4 | "strconv"
5 | )
6 |
7 | // broadcastReq broadcast request to user's browser
8 | func (ser *ProxyServe) broadcastReq(reqCtx *requestCtx) bool {
9 | req := reqCtx.Req
10 | data := make(map[string]any)
11 | data["docid"] = strconv.Itoa(reqCtx.Docid)
12 | data["sid"] = reqCtx.SessionID % 10000
13 | data["host"] = req.Host
14 | data["client_ip"] = req.RemoteAddr
15 | urlPath := req.URL.Path
16 | if req.URL.RawQuery != "" {
17 | urlPath += "?" + req.URL.RawQuery
18 | }
19 | data["path"] = urlPath
20 | data["url"] = req.URL.String()
21 | if req.Method == "CONNECT" && !ser.conf.SslOn {
22 | data["path"] = "https req,unknow path"
23 | }
24 | data["method"] = req.Method
25 | data["replay"] = reqCtx.IsRePlay
26 |
27 | hasSend := ser.wsSer.broadcastReq(req, reqCtx, data)
28 | return hasSend
29 | }
30 |
--------------------------------------------------------------------------------
/serve/certs.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | import (
4 | "crypto/tls"
5 | "crypto/x509"
6 | "log"
7 | "os"
8 | )
9 |
10 | func newCaCert(caCert []byte, caKey []byte) (tls.Certificate, error) {
11 | ca, err := tls.X509KeyPair(caCert, caKey)
12 | if err != nil {
13 | log.Println("NewCaCert error:", err)
14 | return ca, err
15 | }
16 | if ca.Leaf, err = x509.ParseCertificate(ca.Certificate[0]); err != nil {
17 | log.Println("NewCaCert error:", err)
18 | return ca, err
19 | }
20 | log.Println("NewCaCert Ok")
21 | return ca, nil
22 | }
23 |
24 | // getSslCert get user's caCert or use the default buildin
25 | func getSslCert(caCertPath string, caKeyPath string) (ca tls.Certificate, err error) {
26 | if caCertPath == "" {
27 | caCert := Assest.GetContent("/res/private/client_cert.pem")
28 | caKey := Assest.GetContent("/res/private/server_key.pem")
29 | return newCaCert([]byte(caCert), []byte(caKey))
30 | }
31 | cert, err := os.ReadFile(caCertPath)
32 | if err != nil {
33 | return ca, err
34 | }
35 | key, err := os.ReadFile(caKeyPath)
36 | if err != nil {
37 | return ca, err
38 | }
39 | return newCaCert(cert, key)
40 | }
41 |
--------------------------------------------------------------------------------
/serve/config.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | import (
4 | "crypto/tls"
5 | "errors"
6 | "fmt"
7 | "log"
8 | "net/http"
9 | "net/url"
10 | "strings"
11 |
12 | "github.com/Unknwon/goconfig"
13 | "github.com/hidu/goutils/fs"
14 | "github.com/hidu/goutils/str_util"
15 | )
16 |
17 | // Config pproxy's config
18 | type Config struct {
19 | Port int
20 | AdminPort int
21 | Title string
22 | Notice string
23 | AuthType int
24 | DataDir string
25 | FileDir string
26 | ResponseSave int
27 | SessionView int
28 | DataStoreDay float64
29 | ParentProxy *url.URL
30 |
31 | SslOn bool
32 |
33 | SslCert tls.Certificate
34 |
35 | ModifyRequest bool
36 | }
37 |
38 | const (
39 | authTypeNO = 0
40 | authTypeBasic = 1
41 | authTypeBasicWithAny = 2
42 | authTypeBasicTry = 3
43 |
44 | responseSaveAll = 0
45 | responseSaveHasBroad = 1 // has show
46 |
47 | sessionViewALL = 0
48 | sessionViewIPOrUser = 1
49 | )
50 |
51 | // User user struct
52 | type User struct {
53 | Name string
54 | Psw string
55 | PswMd5 string
56 | IsAdmin bool
57 | SkipCheckPsw bool
58 | }
59 |
60 | // String string format
61 | func (u *User) String() string {
62 | return fmt.Sprintf("Name:%s,Psw:%s,isAdmin:%v,SkipCheckPsw:%v", u.Name, u.Psw, u.IsAdmin, u.SkipCheckPsw)
63 | }
64 |
65 | // ConfigString one line in file
66 | func (u *User) ConfigString() string {
67 | return fmt.Sprintf("name:%s\tpsw:%s\tis_admin:%v\tpsw_md5:%s", u.Name, u.Psw, u.IsAdmin, u.PswMd5)
68 | }
69 |
70 | const (
71 | contentEncoding = "Content-Encoding"
72 | )
73 |
74 | // "0:no auth | 1:basic auth | 2:basic auth with any name"
75 |
76 | // GetVersion get current version
77 | func GetVersion() string {
78 | return Assest.GetContent("res/version")
79 | }
80 |
81 | // GetDemoConf get the demo config
82 | func GetDemoConf() string {
83 | return strings.TrimSpace(Assest.GetContent("res/conf/demo.conf"))
84 | }
85 |
86 | func (u *User) isPswEq(psw string) bool {
87 | return u.PswMd5 == str_util.StrMd5(psw)
88 | }
89 |
90 | // LoadConfig load the pproxy's config
91 | func LoadConfig(confPath string) (*Config, error) {
92 | gconf, err := goconfig.LoadConfigFile(confPath)
93 | if err != nil {
94 | log.Println("load config", confPath, "failed,err:", err)
95 | return nil, err
96 | }
97 | config := new(Config)
98 | config.Port = gconf.MustInt(goconfig.DEFAULT_SECTION, "port", 8080)
99 | config.AdminPort = gconf.MustInt(goconfig.DEFAULT_SECTION, "adminPort", 0)
100 |
101 | if config.AdminPort == 0 {
102 | config.AdminPort = config.Port
103 | }
104 |
105 | config.DataStoreDay = gconf.MustFloat64(goconfig.DEFAULT_SECTION, "dataStoreDay", 0)
106 | if config.DataStoreDay < 0 {
107 | log.Println("wrong DataStoreDay,skip")
108 | config.DataStoreDay = 0
109 | }
110 |
111 | config.Title = gconf.MustValue(goconfig.DEFAULT_SECTION, "title")
112 | config.Notice = gconf.MustValue(goconfig.DEFAULT_SECTION, "notice")
113 | config.DataDir = gconf.MustValue(goconfig.DEFAULT_SECTION, "dataDir", "../data/")
114 |
115 | config.FileDir = gconf.MustValue(goconfig.DEFAULT_SECTION, "fileDir", "../file/")
116 |
117 | _authType := strings.ToLower(gconf.MustValue(goconfig.DEFAULT_SECTION, "authType", "none"))
118 | authTypes := map[string]int{"none": 0, "basic": 1, "basic_any": 2, "basic_try": 3, "try_basic": 3}
119 |
120 | hasError := false
121 | if authType, has := authTypes[_authType]; has {
122 | config.AuthType = authType
123 | } else {
124 | hasError = true
125 | log.Println("conf error,unknow value authType:", _authType)
126 | }
127 |
128 | _responseSave := strings.ToLower(gconf.MustValue(goconfig.DEFAULT_SECTION, "responseSave", "all"))
129 | responseSaveMap := map[string]int{"all": 0, "only_broadcast": 1}
130 |
131 | if responseSave, has := responseSaveMap[_responseSave]; has {
132 | config.ResponseSave = responseSave
133 | } else {
134 | hasError = true
135 | log.Println("conf error,unknow value responseSave:", _authType)
136 | }
137 |
138 | _sessionView := strings.ToLower(gconf.MustValue(goconfig.DEFAULT_SECTION, "sessionView", "all"))
139 | sessionViewMap := map[string]int{"all": 0, "ip_or_user": 1}
140 |
141 | if sessionView, has := sessionViewMap[_sessionView]; has {
142 | config.SessionView = sessionView
143 | } else {
144 | hasError = true
145 | log.Println("conf error,unknow value responseSave:", _authType)
146 | }
147 |
148 | parentProxy := gconf.MustValue(goconfig.DEFAULT_SECTION, "parentProxy", "")
149 | if parentProxy != "" {
150 | _urlObj, err := url.Parse(parentProxy)
151 | if err != nil || _urlObj.Scheme != "http" {
152 | hasError = true
153 | log.Println("parentProxy wrong,must http proxy")
154 | } else {
155 | config.ParentProxy = _urlObj
156 | }
157 | }
158 | config.SslOn = gconf.MustValue(goconfig.DEFAULT_SECTION, "ssl", "off") == "on"
159 | if config.SslOn {
160 | _sslClientCert := gconf.MustValue(goconfig.DEFAULT_SECTION, "ssl_client_cert", "")
161 | _sslServerKey := gconf.MustValue(goconfig.DEFAULT_SECTION, "ssl_server_key", "")
162 | cert, err := getSslCert(_sslClientCert, _sslServerKey)
163 | if err != nil {
164 | hasError = true
165 | log.Println("ssl ca config error:", err)
166 | } else {
167 | config.SslCert = cert
168 | }
169 | }
170 |
171 | config.ModifyRequest = gconf.MustValue(goconfig.DEFAULT_SECTION, "modifyRequest", "on") == "on"
172 |
173 | if hasError {
174 | return config, errors.New("config error")
175 | }
176 |
177 | return config, nil
178 | }
179 |
180 | type configHosts map[string]string
181 |
182 | // loadHosts 读取host配置文件
183 | func loadHosts(confPath string) (hosts configHosts, err error) {
184 | hosts = make(configHosts)
185 | if !fs.FileExists(confPath) {
186 | return
187 | }
188 | hostsByte, err := fs.FileGetContents(confPath)
189 | if err != nil {
190 | log.Println("load hosts_file failed:", confPath, err)
191 | return nil, err
192 | }
193 | hostsArr := str_util.LoadText2Slice(string(hostsByte))
194 | for _, v := range hostsArr {
195 | if len(v) != 2 {
196 | log.Println("hosts file line wrong,ignore,", v)
197 | continue
198 | }
199 | hosts[v[0]] = v[1]
200 | }
201 | return
202 | }
203 |
204 | func loadUsers(confPath string) (users map[string]*User, err error) {
205 | users = make(map[string]*User)
206 | if !fs.FileExists(confPath) {
207 | return
208 | }
209 | userInfoByte, err := fs.FileGetContents(confPath)
210 | if err != nil {
211 | log.Println("load user file failed:", confPath, err)
212 | return
213 | }
214 | lines := str_util.LoadText2SliceMap(string(userInfoByte))
215 | for _, line := range lines {
216 | name, has := line["name"]
217 | if !has || name == "" {
218 | continue
219 | }
220 | if _, has := users[name]; has {
221 | log.Println("dup name in users:", name, line)
222 | continue
223 | }
224 |
225 | user := new(User)
226 | user.Name = name
227 | if val, has := line["is_admin"]; has && (val == "admin" || val == "true") {
228 | user.IsAdmin = true
229 | }
230 | if val, has := line["psw_md5"]; has {
231 | user.PswMd5 = val
232 | }
233 |
234 | if user.PswMd5 == "" {
235 | if val, has := line["psw"]; has {
236 | user.Psw = val
237 | user.PswMd5 = str_util.StrMd5(val)
238 | }
239 | }
240 | users[user.Name] = user
241 | }
242 | return
243 | }
244 |
245 | func (config *Config) getTransport() *http.Transport {
246 | if config.ParentProxy == nil {
247 | return nil
248 | }
249 | tr := &http.Transport{
250 | Proxy: func(req *http.Request) (*url.URL, error) {
251 | if config.ParentProxy.User.Username() == "pass" {
252 | user := getAuthorInfo(req)
253 | urlTmp, err := url.Parse(config.ParentProxy.String())
254 | if err != nil {
255 | return nil, err
256 | }
257 | urlTmp.User = url.UserPassword(user.Name, user.Psw)
258 | return urlTmp, nil
259 | }
260 | return config.ParentProxy, nil
261 | },
262 | }
263 | return tr
264 | }
265 |
--------------------------------------------------------------------------------
/serve/init.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | // 系统版本
4 | var PproxyVersion string
5 |
6 | func init() {
7 | PproxyVersion = GetVersion()
8 | }
9 |
--------------------------------------------------------------------------------
/serve/kvStore.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | import (
4 | "time"
5 |
6 | "github.com/boltdb/bolt"
7 | "github.com/hidu/goutils/time_util"
8 | )
9 |
10 | type KV_TBALE_NAME_TYPE string
11 |
12 | const (
13 | KV_TABLE_REQ KV_TBALE_NAME_TYPE = "req"
14 | KV_TABLE_RES KV_TBALE_NAME_TYPE = "res"
15 | )
16 |
17 | type kvStore struct {
18 | dbPath string
19 | db *bolt.DB
20 | tables map[KV_TBALE_NAME_TYPE]*kvStoreTable
21 | }
22 |
23 | type kvStoreTable struct {
24 | name KV_TBALE_NAME_TYPE
25 | kv *kvStore
26 | }
27 |
28 | type StoreType struct {
29 | Now int64 `json:"now"`
30 | Data KvType `json:"data"`
31 | }
32 |
33 | func newStoreType(data map[string]any) *StoreType {
34 | return &StoreType{Now: time.Now().Unix(), Data: data}
35 | }
36 |
37 | func newKvStore(dbPath string) (kv *kvStore, err error) {
38 | kv = &kvStore{
39 | dbPath: dbPath,
40 | }
41 | kv.db, err = bolt.Open(kv.dbPath, 0600, nil)
42 | if err != nil {
43 | return
44 | }
45 | kv.tables = make(map[KV_TBALE_NAME_TYPE]*kvStoreTable)
46 |
47 | kv.initTable(KV_TABLE_REQ)
48 | kv.initTable(KV_TABLE_RES)
49 |
50 | return
51 | }
52 |
53 | func (kv *kvStore) initTable(name KV_TBALE_NAME_TYPE) {
54 | kv.tables[name] = newkvStoreTable(name, kv)
55 | }
56 |
57 | func (kv *kvStore) GetkvStoreTable(name KV_TBALE_NAME_TYPE) (tb *kvStoreTable) {
58 | if tb, has := kv.tables[name]; has {
59 | return tb
60 | }
61 | return nil
62 | }
63 |
64 | func (kv *kvStore) Gc(max_life int64) {
65 | for _, tb := range kv.tables {
66 | tb.Gc(max_life)
67 | }
68 | }
69 |
70 | func (kv *kvStore) StartGcTimer(sec int64, max_life int64) {
71 | if max_life < 1 {
72 | return
73 | }
74 | time_util.SetInterval(func() {
75 | kv.Gc(max_life)
76 | }, sec)
77 | }
78 |
79 | func newkvStoreTable(name KV_TBALE_NAME_TYPE, kv *kvStore) *kvStoreTable {
80 | tb := &kvStoreTable{
81 | name: name,
82 | kv: kv,
83 | }
84 | tb.kv.db.Update(func(tx *bolt.Tx) error {
85 | _, err := tx.CreateBucketIfNotExists([]byte(name))
86 | return err
87 | })
88 | return tb
89 | }
90 |
91 | func (tb *kvStoreTable) Save(key []byte, val *StoreType) error {
92 | err := tb.kv.db.Update(func(tx *bolt.Tx) error {
93 | bk, _ := tx.CreateBucketIfNotExists([]byte(tb.name))
94 | return bk.Put(key, dataEncode(val))
95 | })
96 | return err
97 | }
98 |
99 | func (tb *kvStoreTable) Get(key []byte) (val *StoreType, err error) {
100 | err = tb.kv.db.View(func(tx *bolt.Tx) error {
101 | bk := tx.Bucket([]byte(tb.name))
102 | bs := bk.Get(key)
103 | if len(bs) > 0 {
104 | return dataDecode(bs, &val)
105 | }
106 | return nil
107 | })
108 | return
109 | }
110 |
111 | func (tb *kvStoreTable) Del(key []byte) (err error) {
112 | err = tb.kv.db.Update(func(tx *bolt.Tx) error {
113 | bk := tx.Bucket([]byte(tb.name))
114 | return bk.Delete(key)
115 | })
116 | return
117 | }
118 |
119 | func (tb *kvStoreTable) Gc(gc_life int64) {
120 | if gc_life < 1 {
121 | return
122 | }
123 | max_time := time.Now().Unix() - gc_life
124 | var val *StoreType
125 | tb.kv.db.View(func(tx *bolt.Tx) error {
126 | bk := tx.Bucket([]byte(tb.name))
127 | bk.ForEach(func(k, v []byte) error {
128 | dataDecode(v, &val)
129 | if val != nil && val.Now < max_time {
130 | tb.Del(k)
131 | }
132 | return nil
133 | })
134 | return nil
135 | })
136 | }
137 |
--------------------------------------------------------------------------------
/serve/proxy.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | import (
4 | "io"
5 | "log"
6 | "net"
7 | "net/http"
8 | "net/http/httputil"
9 | "strconv"
10 | "sync"
11 | "time"
12 |
13 | "github.com/elazarl/goproxy"
14 | )
15 |
16 | type HttpProxy struct {
17 | GoProxy *goproxy.ProxyHttpServer
18 | ser *ProxyServe
19 | ctxs map[string]*requestCtx
20 | mu sync.RWMutex
21 | goproxyMitmConnect *goproxy.ConnectAction
22 | }
23 |
24 | func NewHttpProxy(ser *ProxyServe) *HttpProxy {
25 | proxy := new(HttpProxy)
26 | proxy.ser = ser
27 | proxy.GoProxy = goproxy.NewProxyHttpServer()
28 | tr := ser.conf.getTransport()
29 | if tr != nil {
30 | proxy.GoProxy.Tr = tr
31 | }
32 | proxy.ctxs = make(map[string]*requestCtx)
33 | if proxy.ser.conf.SslOn {
34 | proxy.goproxyMitmConnect = &goproxy.ConnectAction{
35 | Action: goproxy.ConnectMitm,
36 | TLSConfig: goproxy.TLSConfigFromCA(&proxy.ser.conf.SslCert),
37 | }
38 | proxy.GoProxy.OnRequest().HandleConnectFunc(proxy.httpsHandle)
39 | }
40 | proxy.GoProxy.OnRequest().DoFunc(my_requestHanderFunc)
41 | proxy.GoProxy.OnResponse().DoFunc(proxy.onResponse)
42 | return proxy
43 | }
44 |
45 | func my_requestHanderFunc(r *http.Request, ctx *goproxy.ProxyCtx) (*http.Request, *http.Response) {
46 | log.Println("trace_my_requestHanderFunc call url:", r.URL.String())
47 | return r, nil
48 | }
49 |
50 | const PROXY_CTX_NAME = "X-PPROXY-CTX-ID"
51 |
52 | func (proxy *HttpProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
53 | // fmt.Println("call url:",req.URL.String())
54 | proxy.GoProxy.ServeHTTP(rw, req)
55 | }
56 |
57 | func (proxy *HttpProxy) httpsHandle(host string, ctx *goproxy.ProxyCtx) (*goproxy.ConnectAction, string) {
58 | log.Println("https conn", host, ctx.Req.URL.String())
59 | return proxy.goproxyMitmConnect, host
60 | }
61 |
62 | func (proxy *HttpProxy) RoundTrip(ctx *requestCtx) {
63 | sid := strconv.FormatInt(ctx.SessionID, 10)
64 | ctx.Req.Header.Set(PROXY_CTX_NAME, sid)
65 | func() {
66 | proxy.mu.Lock()
67 | defer proxy.mu.Unlock()
68 | proxy.ctxs[sid] = ctx
69 | }()
70 |
71 | defer func() {
72 | proxy.mu.Lock()
73 | defer proxy.mu.Unlock()
74 | if _, has := proxy.ctxs[sid]; has {
75 | delete(proxy.ctxs, sid)
76 | }
77 | }()
78 |
79 | if ctx.Req.Header.Get("Upgrade") != "" {
80 | proxy.roundTripUpgrade(ctx)
81 | return
82 | }
83 | proxy.ServeHTTP(ctx.Rw, ctx.Req)
84 | }
85 |
86 | func (proxy *HttpProxy) getReqCtx(req *http.Request) *requestCtx {
87 | sid := req.Header.Get(PROXY_CTX_NAME)
88 | if sid == "" {
89 | return nil
90 | }
91 | proxy.mu.RLock()
92 | defer proxy.mu.RUnlock()
93 | if ctx, has := proxy.ctxs[sid]; has {
94 | return ctx
95 | }
96 | return nil
97 | }
98 |
99 | func (proxy *HttpProxy) onResponse(resp *http.Response, ctx *goproxy.ProxyCtx) *http.Response {
100 | if resp == nil || resp.Request == nil {
101 | return resp
102 | }
103 | reqCtx := proxy.getReqCtx(resp.Request)
104 |
105 | if reqCtx != nil {
106 | reqCtx.saveResponse(resp)
107 | }
108 | return resp
109 | }
110 |
111 | func (proxy *HttpProxy) roundTripUpgrade(ctx *requestCtx) (err error) {
112 | // save it,so we know it has been closed
113 | defer func() {
114 | resp := &http.Response{
115 | Request: ctx.Req,
116 | Header: make(http.Header),
117 | Body: nil,
118 | }
119 | ctx.saveResponse(resp)
120 | }()
121 |
122 | reqDump, err := httputil.DumpRequest(ctx.Req, false)
123 | if err != nil {
124 | ctx.Msg = "dump req failed:" + err.Error()
125 | return
126 | }
127 | ctx.SetTimePoint("startDial")
128 | dia, err := net.Dial("tcp", ctx.DestAddr())
129 | if err != nil {
130 | ctx.Msg = "dia connect " + ctx.DestAddr() + " failed!" + err.Error()
131 | return
132 | }
133 | defer dia.Close()
134 | _, err = dia.Write(reqDump)
135 | if err != nil {
136 | return
137 | }
138 |
139 | hijack, _ := ctx.Rw.(http.Hijacker)
140 | conn, _, _ := hijack.Hijack()
141 |
142 | errc := make(chan error, 2)
143 |
144 | cp := func(dst io.Writer, src io.Reader) {
145 | _, err := io.Copy(dst, src)
146 | errc <- err
147 |
148 | time.AfterFunc(3*time.Second, func() {
149 | dia.Close()
150 | conn.Close()
151 | })
152 | }
153 |
154 | go cp(dia, conn)
155 | go cp(conn, dia)
156 | <-errc
157 | return
158 | }
159 |
--------------------------------------------------------------------------------
/serve/reqCtx.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | import (
4 | "encoding/base64"
5 | "errors"
6 | "fmt"
7 | "log"
8 | "net/http"
9 | "net/http/httputil"
10 | "net/url"
11 | "strconv"
12 | "strings"
13 | "time"
14 | )
15 |
16 | // requestCtx 一次http请求的数据结构
17 | type requestCtx struct {
18 | RemoteAddr string
19 | Req *http.Request
20 | Rw http.ResponseWriter
21 |
22 | Host string // eg www.baidu.com
23 | Port int // eg 80
24 |
25 | User *User
26 | Docid int
27 | IsRePlay bool
28 |
29 | SessionID int64
30 | HasBroadcast bool
31 | FormPost *url.Values
32 | ClientSession *clientSession
33 |
34 | OriginURL string
35 | logData map[any]any
36 | Msg string
37 |
38 | ser *ProxyServe
39 | startTime time.Time
40 | timeDurations map[string]time.Duration
41 | hasPrint bool
42 | }
43 |
44 | // NewRequestCtx 构建一个新的请求
45 | func NewRequestCtx(ser *ProxyServe, rw http.ResponseWriter, req *http.Request) *requestCtx {
46 | ctx := &requestCtx{}
47 | ctx.Req = req
48 | ctx.ser = ser
49 | ctx.Rw = rw
50 | ctx.SessionID = ser.reqNum
51 |
52 | ctx.logData = make(map[any]any)
53 | ctx.timeDurations = make(map[string]time.Duration)
54 |
55 | ctx.FormPost = &url.Values{}
56 | ctx.init()
57 | ctx.startTime = time.Now()
58 | return ctx
59 | }
60 |
61 | func (ctx *requestCtx) init() {
62 | if ctx.Req == nil {
63 | return
64 | }
65 | fixRequest(ctx.Req)
66 | req := ctx.Req
67 | ctx.Host, ctx.Port, _ = getHostPortFromReq(req)
68 |
69 | ctx.User = getAuthorInfo(req)
70 | ctx.FormPost = getPostData(req)
71 |
72 | ctx.OriginURL = req.URL.String()
73 | ctx.IsRePlay = len(req.Header.Get(REPLAY_FLAG)) > 0
74 | ctx.SetLog("url", req.URL.String())
75 |
76 | ctx.RemoteAddr = req.RemoteAddr
77 |
78 | if _replayAddr := req.Header.Get(REPLAY_REMOTEADDR); _replayAddr != "" {
79 | ctx.RemoteAddr = _replayAddr
80 | }
81 | if _replayUser := req.Header.Get(REPLAY_USER_NAME); _replayUser != "" {
82 | ctx.User = &User{Name: _replayUser, SkipCheckPsw: true}
83 | }
84 | ctx.Docid = ctx.getNewDocid()
85 | ctx.ser.regirestReq(ctx)
86 | }
87 |
88 | func fixRequest(req *http.Request) {
89 | if req.Method != "CONNECT" && !req.URL.IsAbs() {
90 | urlOrigin := req.URL.String()
91 | urlStr := "http://" + req.Host + req.URL.Path
92 | if req.URL.RawQuery != "" {
93 | urlStr += "?" + req.URL.RawQuery
94 | }
95 | var err error
96 | req.URL, err = url.Parse(urlStr)
97 | if err != nil {
98 | log.Println("fix url failed,originUrl:", urlOrigin, "err:", err)
99 | return
100 | }
101 | }
102 | }
103 |
104 | func (ctx *requestCtx) IsLocalRequest() bool {
105 | isLocalReq := ctx.Port == ctx.ser.conf.Port
106 | if isLocalReq {
107 | isLocalReq = IsLocalIP(ctx.Host)
108 | }
109 | return isLocalReq
110 | }
111 |
112 | func (ctx *requestCtx) GetIp() string {
113 | hostInfo := strings.Split(ctx.RemoteAddr, ":")
114 | return hostInfo[0]
115 | }
116 |
117 | func (ctx *requestCtx) PrintLog() {
118 | reqID := 0
119 | if ctx.ClientSession != nil {
120 | reqID = ctx.ClientSession.RequestNum
121 | }
122 | log.Println(
123 | "session_id:", ctx.SessionID,
124 | "remote:", ctx.RemoteAddr,
125 | "reqId:", reqID,
126 | "docid:", ctx.Docid,
127 | "uname:", ctx.User.Name,
128 | "broadcast:", ctx.HasBroadcast,
129 | "startTime:", ctx.startTime.Unix(),
130 | "timeUsed:", fmt.Sprintf("%.3fs", time.Since(ctx.startTime).Seconds()),
131 | "data:", ctx.logData,
132 | "times:", ctx.timeDurations,
133 | )
134 | }
135 |
136 | func (ctx *requestCtx) RoundTrip() {
137 | defer func() {
138 | ctx.hasPrint = true
139 | ctx.SetLog("logType", "defer")
140 | ctx.PrintLog()
141 | }()
142 |
143 | time.AfterFunc(10*time.Second, func() {
144 | if !ctx.hasPrint {
145 | ctx.SetLog("logType", "timeout10")
146 | ctx.PrintLog()
147 | }
148 | })
149 |
150 | removeHeader(ctx.Req)
151 | rewriteCode := ctx.ser.reqRewrite(ctx)
152 |
153 | ctx.HasBroadcast = ctx.ser.broadcastReq(ctx)
154 |
155 | // reqDump, _ := httputil.DumpRequest(ctx.Req, true)
156 | // fmt.Println("req dump3:\n",string(reqDump))
157 |
158 | ctx.SetLog("js_rewrite_code", rewriteCode)
159 |
160 | ctx.saveRequestData()
161 | // 异步的会导致req.body dump不了，先暂时这样，对接口会有一些影响
162 | // time.AfterFunc(1*time.Second, ctx.saveRequestData)
163 |
164 | if rewriteCode != 200 && rewriteCode != 304 {
165 | ctx.badGateway(errors.New("rewrite failed"))
166 | return
167 | }
168 | ctx.ser.proxy.RoundTrip(ctx)
169 | }
170 |
171 | func (ctx *requestCtx) badGateway(err error) {
172 | ctx.SetLog("errMsg", fmt.Sprintf("%s", err))
173 | ctx.Rw.WriteHeader(http.StatusBadGateway)
174 | ctx.Rw.Write([]byte("pproxy error"))
175 | }
176 |
177 | func (ctx *requestCtx) DestAddr() string {
178 | return fmt.Sprintf("%s:%d", ctx.Host, ctx.Port)
179 | }
180 |
181 | func (ctx *requestCtx) saveRequestData() {
182 | if ctx.ser.conf.ResponseSave == responseSaveAll ||
183 | (ctx.ser.conf.ResponseSave == responseSaveHasBroad && ctx.HasBroadcast) {
184 | logdata := KvType{}
185 | logdata["host"] = ctx.Req.Host
186 | logdata["schema"] = ctx.Req.URL.Scheme
187 | logdata["header"] = map[string][]string(ctx.Req.Header)
188 | logdata["url"] = ctx.Req.URL.String()
189 | logdata["url_origin"] = ctx.OriginURL
190 | logdata["path"] = ctx.Req.URL.Path
191 | // logdata["cookies"] = ctx.Req.Cookies()
192 | // logdata["now"] = time.Now().Unix()
193 | logdata["user"] = ctx.User.Name
194 | logdata["client_ip"] = ctx.RemoteAddr
195 | logdata["method"] = ctx.Req.Method
196 | logdata["form_get"] = ctx.Req.URL.Query()
197 | logdata["replay"] = ctx.IsRePlay
198 | logdata["msg"] = ctx.Msg
199 | logdata["id"] = strconv.Itoa(ctx.Docid)
200 |
201 | // 当无普通form post表单数据的时候，比如可能body也有数据
202 | // 比如request 的content-type=application/json
203 | dumpBody := len(*ctx.FormPost) == 0
204 | // fmt.Println("dumpBody",dumpBody)
205 | // dumpBody=false
206 | reqDump, errDump := httputil.DumpRequest(ctx.Req, dumpBody)
207 | if errDump != nil {
208 | ctx.SetLog("dumpMsg", fmt.Sprintf("dump request failed,%s", errDump.Error()))
209 | reqDump = []byte(fmt.Sprintf("dump failed,%s", errDump.Error()))
210 | }
211 | logdata["dump"] = base64.StdEncoding.EncodeToString(reqDump)
212 | // buf := forgetRead(&ctx.Req.Body)
213 | // logdata["dump"] = base64.StdEncoding.EncodeToString(buf.Bytes())
214 |
215 | logdata["form_post"] = ctx.FormPost
216 |
217 | tb := ctx.ser.mydb.GetkvStoreTable(KV_TABLE_REQ)
218 | data := newStoreType(logdata)
219 | err := tb.Save(IntToBytes(ctx.Docid), data)
220 | if err != nil {
221 | log.Println("save req failed:", err)
222 | }
223 | }
224 | }
225 |
226 | func (ctx *requestCtx) saveResponse(res *http.Response) {
227 | if ctx.Docid < 1 || res == nil {
228 | return
229 | }
230 | data := KvType{}
231 | data["now"] = time.Now().Unix()
232 | data["header"] = map[string][]string(res.Header)
233 | data["status"] = res.StatusCode
234 | data["content_length"] = res.ContentLength
235 | data["msg"] = ctx.Msg
236 | data["id"] = strconv.Itoa(ctx.Docid)
237 |
238 | resDump, dumpErr := httputil.DumpResponse(res, false)
239 | if dumpErr != nil {
240 | log.Println("dump res err", dumpErr)
241 | resDump = []byte("dump res failed")
242 | }
243 | data["dump"] = base64.StdEncoding.EncodeToString(resDump)
244 | // data["cookies"]=res.Cookies()
245 |
246 | body := []byte("pproxy skip")
247 | if res.Body != nil && res.ContentLength <= ctx.ser.MaxResSaveLength {
248 | buf := forgetRead(&res.Body)
249 | if res.Header.Get(contentEncoding) == "gzip" {
250 | body = []byte(gzipDocode(buf))
251 | } else {
252 | body = buf.Bytes()
253 | }
254 | l := int64(len(body))
255 | if l > ctx.ser.MaxResSaveLength {
256 | body = []byte(fmt.Sprintf("pproxy skip,body too large,[len=%d]", l))
257 | }
258 | }
259 | data["body"] = base64.StdEncoding.EncodeToString(body)
260 |
261 | tb := ctx.ser.mydb.GetkvStoreTable(KV_TABLE_RES)
262 | storeData := newStoreType(data)
263 | err := tb.Save(IntToBytes(ctx.Docid), storeData)
264 |
265 | log.Println("save_res", ctx.SessionID, "docid=", ctx.Docid, "body_len=", len(data["body"].(string)), err)
266 | }
267 |
268 | func (ctx *requestCtx) SetLog(k, v any) {
269 | ctx.logData[k] = v
270 | }
271 |
272 | func (ctx *requestCtx) SetTimePoint(key string) {
273 | ctx.timeDurations[key] = time.Since(ctx.startTime)
274 | }
275 |
276 | func (ctx *requestCtx) getNewDocid() int {
277 | idStr := fmt.Sprintf("%s%d", time.Now().Format("200601021504"), ctx.ser.reqNum)
278 | id, err := parseDocID(idStr)
279 | if err == nil {
280 | return id
281 | }
282 | log.Println("GetNewDocid failed", idStr, err)
283 | return int(time.Now().UnixNano() + ctx.ser.reqNum)
284 | }
285 |
--------------------------------------------------------------------------------
/serve/req_modifer.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | import (
4 | "errors"
5 | "fmt"
6 | "log"
7 | "os"
8 | "strings"
9 | "sync"
10 |
11 | "github.com/hidu/goutils/fs"
12 | "github.com/robertkrimen/otto"
13 | )
14 |
15 | var rewriteJsTpl = Assest.GetContent("res/sjs/req_rewrite.js")
16 |
17 | /*
18 | * request动态修改引擎
19 | * 使用javascript 来对请求进行修改
20 | */
21 | type requestModifier struct {
22 | mu sync.RWMutex
23 | jsVm *otto.Otto
24 | jsFns map[string]*otto.Value
25 | canMod bool
26 | ser *ProxyServe
27 | }
28 |
29 | func NewRequestModifier(ser *ProxyServe) *requestModifier {
30 | reqMod := &requestModifier{
31 | jsVm: otto.New(),
32 | jsFns: make(map[string]*otto.Value),
33 | ser: ser,
34 | }
35 | return reqMod
36 | }
37 |
38 | func (reqMod *requestModifier) getJsPath(name string) string {
39 | baseName := fmt.Sprintf("%s/req_rewrite_%d", reqMod.ser.configDir, reqMod.ser.conf.Port)
40 | if name == "" {
41 | return fmt.Sprintf("%s.js", baseName)
42 | }
43 | return fmt.Sprintf("%s_%s.js", baseName, name)
44 | }
45 |
46 | func (reqMod *requestModifier) tryLoadJs(name string) (err error) {
47 | jsContent, err := reqMod.getJsContent(name)
48 | if jsContent != "" && err == nil {
49 | err = reqMod.parseJs(jsContent, name, false)
50 | if err != nil {
51 | log.Println("load rewrite js failed:", err)
52 | return err
53 | }
54 | log.Println("load rewrite js[", name, "] suc")
55 | }
56 | return nil
57 | }
58 |
59 | func (reqMod *requestModifier) loadAllJs() error {
60 | if !reqMod.ser.conf.ModifyRequest {
61 | log.Println("ignore requestModifier loadAllJs")
62 | return nil
63 | }
64 | names := []string{""}
65 | for _, user := range reqMod.ser.Users {
66 | names = append(names, user.Name)
67 | }
68 | for _, name := range names {
69 | err := reqMod.tryLoadJs(name)
70 | if err != nil {
71 | return err
72 | }
73 | }
74 | return nil
75 | }
76 |
77 | func (reqMod *requestModifier) getJsContent(name string) (content string, err error) {
78 | jsPath := reqMod.getJsPath(name)
79 | if fs.FileExists(jsPath) {
80 | script, err := os.ReadFile(jsPath)
81 | if err == nil {
82 | return string(script), nil
83 | }
84 | return "", err
85 | }
86 | return "", nil
87 | }
88 |
89 | func (reqMod *requestModifier) CanMod() bool {
90 | return reqMod.canMod
91 | }
92 |
93 | func (reqMod *requestModifier) parseJs(jsStr string, name string, save2File bool) error {
94 | jsStr = strings.TrimSpace(jsStr)
95 | rewriteJs := strings.Replace(rewriteJsTpl, "CUSTOM_JS", jsStr, 1)
96 | rewriteJs = strings.Replace(rewriteJs, "PPROXY_HOST", fmt.Sprintf("127.0.0.1:%d", reqMod.ser.conf.Port), 1)
97 |
98 | reqMod.mu.Lock()
99 | defer reqMod.mu.Unlock()
100 | if reqMod.ser.Debug {
101 | log.Println("jsvm_execute:", rewriteJs)
102 | }
103 | reqMod.jsVm.Run(rewriteJs)
104 | jsFn, err := reqMod.jsVm.Get("pproxy_rewrite")
105 | if err != nil {
106 | log.Println("rewrite js init error:", err)
107 | return err
108 | }
109 |
110 | if strings.HasPrefix(jsStr, "//ignore") {
111 | if _, has := reqMod.jsFns[name]; has {
112 | delete(reqMod.jsFns, name)
113 | }
114 | log.Println("req_mod [", name, "] ignore")
115 | } else {
116 | reqMod.jsFns[name] = &jsFn
117 | log.Println("req_mod [", name, "] register suc")
118 | }
119 | reqMod.canMod = true
120 | if save2File {
121 | jsPath := reqMod.getJsPath(name)
122 | err = fs.FilePutContents(jsPath, []byte(jsStr))
123 | log.Println("save rewritejs ", jsPath, err)
124 | }
125 | return err
126 | }
127 |
128 | func (reqMod *requestModifier) getJsFnByName(name string) (*otto.Value, error) {
129 | names := []string{name, ""}
130 | for _, name := range names {
131 | if jsFn, has := reqMod.jsFns[name]; has {
132 | return jsFn, nil
133 | }
134 | }
135 | return nil, errors.New("no rewrite rules")
136 | }
137 |
138 | func (reqMod *requestModifier) rewrite(data map[string]any, name string) (map[string]any, error) {
139 | reqMod.mu.Lock()
140 | defer reqMod.mu.Unlock()
141 |
142 | reqJsObj, _ := reqMod.jsVm.Object(`req={}`)
143 | reqJsObj.Set("origin", data)
144 |
145 | jsFn, err := reqMod.getJsFnByName(name)
146 |
147 | if err != nil {
148 | return nil, err
149 | }
150 |
151 | defer func() {
152 | if caught := recover(); caught != nil {
153 | log.Println("fatal:requestModifer recover:", caught)
154 | }
155 | }()
156 |
157 | js_ret, err_js := (*jsFn).Call(*jsFn, reqJsObj)
158 |
159 | if err_js != nil {
160 | log.Println("parse js error:", err_js)
161 | return nil, err_js
162 | }
163 | if !js_ret.IsObject() {
164 | log.Println("wrong req_rewirte return value,not object:", js_ret)
165 | return nil, fmt.Errorf("wrong req_rewirte return value,not object.%t", js_ret)
166 | }
167 | obj, export_err := js_ret.Export()
168 |
169 | if export_err != nil {
170 | return nil, export_err
171 | }
172 | reqObjNew := obj.(map[string]any)
173 | return reqObjNew, nil
174 | }
175 |
--------------------------------------------------------------------------------
/serve/req_replay.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | import (
4 | "fmt"
5 | "net/http"
6 | "net/url"
7 | "strings"
8 | )
9 |
10 | const (
11 | REPLAY_FLAG = "Proxy-pproxy_replay"
12 | REPLAY_REMOTEADDR = "Proxy-pproxy_remoteaddr"
13 | REPLAY_USER_NAME = "Proxy-pproxy_user"
14 | )
15 |
16 | func (ctx *webRequestCtx) handleReplay() {
17 | if ctx.req.Method == "POST" {
18 | ctx.reqReplayPost()
19 | return
20 | }
21 | docidStr := strings.TrimSpace(ctx.req.FormValue("id"))
22 | if docidStr == "" {
23 | ctx.w.WriteHeader(http.StatusBadRequest)
24 | ctx.w.Write([]byte("empty id param"))
25 | return
26 | }
27 | docid, errInt := parseDocID(docidStr)
28 | if errInt != nil {
29 | ctx.w.WriteHeader(http.StatusInternalServerError)
30 | fmt.Fprintf(ctx.w, "param id[%s] error:\n%s", docidStr, errInt)
31 | return
32 | }
33 | reqDoc, _ := ctx.ser.getRequestByDocid(docid)
34 | if reqDoc == nil {
35 | ctx.w.WriteHeader(http.StatusNotFound)
36 | ctx.w.Write([]byte("request doc not found!"))
37 | return
38 | }
39 | _url := fmt.Sprintf("%s", reqDoc.Data["url"])
40 | u, err := url.Parse(_url)
41 | if err != nil {
42 | ctx.w.WriteHeader(http.StatusInternalServerError)
43 | fmt.Fprintf(ctx.w, "parse url[%s] error\n%s", _url, err)
44 | return
45 | }
46 | u.RawQuery = ""
47 |
48 | ctx.values["req"] = reqDoc
49 | ctx.values["action_url"] = u.String()
50 |
51 | ctx.render("replay.html", true)
52 | }
53 |
54 | var replaySkipHeaders = map[string]int{"Content-Length": 1}
55 |
56 | func (ctx *webRequestCtx) reqReplayPost() {
57 | replay := ctx.req.FormValue("replay")
58 | basic := make(map[string]string)
59 | basic["action_url"] = strings.TrimSpace(ctx.req.FormValue("basic_action_url"))
60 | method := strings.TrimSpace(strings.ToUpper(ctx.req.FormValue("basic_method")))
61 | basic["method"] = method
62 |
63 | host := strings.TrimSpace(ctx.req.FormValue("basic_host"))
64 |
65 | basicRemoteAddr := ctx.req.FormValue("basic_RemoteAddr")
66 | basicUser := ctx.req.FormValue("basic_user")
67 |
68 | header := getFormValuesWithPrefix(ctx.req.Form, "header_")
69 | get := getFormValuesWithPrefix(ctx.req.Form, "get_")
70 | post := getFormValuesWithPrefix(ctx.req.Form, "post_")
71 |
72 | formData := make(map[string]any)
73 | formData["basic"] = basic
74 |
75 | formData["header"] = header
76 | formData["get"] = get
77 | formData["post"] = post
78 |
79 | ctx.values["form"] = formData
80 | if replay == "direct" {
81 | ctx.render("replay_direct.html", true)
82 | return
83 | }
84 | reqBd := ""
85 | _url := basic["action_url"]
86 |
87 | if len(get) > 0 {
88 | formValues := make(url.Values)
89 | for k, v := range get {
90 | for _, _v := range v {
91 | formValues.Add(k, _v)
92 | }
93 | }
94 | if strings.Contains(_url, "?") {
95 | _url += "&"
96 | } else {
97 | _url += "?"
98 | }
99 | _url += formValues.Encode()
100 | }
101 |
102 | if len(post) > 0 {
103 | formValues := make(url.Values)
104 | for k, v := range post {
105 | for _, _v := range v {
106 | formValues.Add(k, _v)
107 | }
108 | }
109 | reqBd = formValues.Encode()
110 | }
111 |
112 | replayReq, err := http.NewRequest(method, _url, strings.NewReader(reqBd))
113 | if err != nil {
114 | ctx.w.Write([]byte("build request failed\n" + err.Error()))
115 | return
116 | }
117 | if host != "" {
118 | replayReq.Host = host
119 | }
120 | replayReq.Header.Set(REPLAY_FLAG, "replay")
121 |
122 | replayReq.Header.Set(REPLAY_REMOTEADDR, basicRemoteAddr)
123 | replayReq.Header.Set(REPLAY_USER_NAME, basicUser)
124 |
125 | for k, v := range header {
126 | if _, has := replaySkipHeaders[k]; has {
127 | continue
128 | }
129 | replayReq.Header.Set(k, strings.Join(v, ";"))
130 | }
131 | ctx.ser.ServeHTTPProxy(ctx.w, replayReq)
132 | }
133 |
--------------------------------------------------------------------------------
/serve/req_rewrite.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | import (
4 | "bytes"
5 | "fmt"
6 | "io"
7 | "log"
8 | "net/http"
9 | "net/url"
10 | "strconv"
11 | "strings"
12 | )
13 |
14 | func (ser *ProxyServe) reqRewriteByjs(reqCtx *requestCtx) int {
15 | modifer := ser.reqMod
16 | if !modifer.CanMod() {
17 | return 304
18 | }
19 | req := reqCtx.Req
20 | schema := req.URL.Scheme
21 | originURL := req.URL.String()
22 | originGetQuery := req.URL.Query()
23 | // /================================================================
24 | headerKv := make(map[string]string)
25 | headerKv["method"] = req.Method
26 | headerKv["schema"] = schema
27 | headerKv["path"] = req.URL.Path
28 |
29 | _host, portInt, _ := getHostPortFromReq(req)
30 |
31 | headerKv["host"] = _host
32 | headerKv["port"] = strconv.Itoa(portInt)
33 |
34 | username := ""
35 | psw := ""
36 | if req.URL.User != nil {
37 | username = req.URL.User.Username()
38 | psw, _ = req.URL.User.Password()
39 | }
40 | headerKv["username"] = username
41 |
42 | headerKv["proxy_user"] = reqCtx.User.Name
43 |
44 | headerKv["password"] = psw
45 |
46 | // ===================================================================
47 | rewriteData := make(map[string]any)
48 | rewriteData["header"] = headerKv
49 | rewriteData["get"] = originGetQuery
50 | rewriteData["post"] = *reqCtx.FormPost
51 |
52 | _buf := forgetRead(&reqCtx.Req.Body)
53 | var rawBody string
54 | // 暂时只考虑gip的，其他的压缩就不支持了
55 | if req.Header.Get(contentEncoding) == "gzip" {
56 | rawBody = gzipDocode(_buf)
57 | } else {
58 | rawBody = _buf.String()
59 | }
60 | rewriteData["body"] = rawBody
61 |
62 | reqObjNew, rErr := modifer.rewrite(rewriteData, reqCtx.User.Name)
63 | if rErr != nil {
64 | log.Println("rewrite failed:", rErr)
65 | }
66 |
67 | headerKvNew := make(map[string]string)
68 | isHeaderChange := false
69 |
70 | skipHeader := false
71 | var err error
72 |
73 | urlStrNew := getMapValStr(reqObjNew, "url")
74 |
75 | if urlStrNew != "" {
76 | req.URL, err = url.Parse(urlStrNew)
77 | if err != nil || req.URL.Scheme != "http" {
78 | log.Println("new url wrong!url is:", urlStrNew, err)
79 | return 500
80 | }
81 | req.Host = req.URL.Host
82 | skipHeader = true
83 | }
84 |
85 | if !skipHeader {
86 | for k, v := range headerKv {
87 | _newVal := getMapValStr(reqObjNew, k)
88 | headerKvNew[k] = _newVal
89 | if _newVal != v {
90 | isHeaderChange = true
91 | }
92 | }
93 | }
94 | // -------------------------------------------------------
95 | var getNew url.Values
96 |
97 | isGetChange := false
98 |
99 | if _get, has := reqObjNew["get"]; has {
100 | getNew = _reqMapToURLValue(_get)
101 | isGetChange = checkURLValuesChange(originGetQuery, getNew)
102 | }
103 | // -------------------------------------------------------
104 | var postNew url.Values
105 | isPostChange := false
106 |
107 | if schema == "http" {
108 | if _post, has := reqObjNew["post"]; has {
109 | postNew = _reqMapToURLValue(_post)
110 | isPostChange = checkURLValuesChange(*reqCtx.FormPost, postNew)
111 | }
112 | }
113 | isBodyChange := false
114 | bodyNew := ""
115 | if _bodyNew, has := reqObjNew["body"]; has {
116 | bodyNew = _bodyNew.(string)
117 | isBodyChange = rawBody != bodyNew
118 | }
119 |
120 | hostAddr := getMapValStr(reqObjNew, "hostAddr")
121 | isHostAddrChange := hostAddr != ""
122 |
123 | if ser.Debug {
124 | fmt.Println("rewriteChange:", "is_get_change:", isGetChange, "new_get:", getNew,
125 | "isPostChange:", isPostChange, "new_post:", postNew,
126 | "isHostAddrChange:", isHostAddrChange, "newHostAddr:", hostAddr,
127 | "isBodyChange:", isBodyChange,
128 | )
129 | }
130 |
131 | // /===============================================================================
132 | if !isHeaderChange && !isGetChange && !isPostChange && !isHostAddrChange && !isBodyChange {
133 | return 304
134 | }
135 | // /===============================================================================
136 |
137 | var urlBase string
138 |
139 | if isHeaderChange {
140 | // schema := headerKvNew["schema"]
141 | urlBase = schema + "://"
142 |
143 | if headerKvNew["username"] != "" {
144 | urlBase += fmt.Sprintf("%s:%s@", headerKvNew["username"], headerKvNew["password"])
145 | }
146 | urlBase += headerKvNew["host"]
147 | if headerKvNew["port"] != "" && headerKvNew["port"] != "80" {
148 | urlBase += ":" + headerKvNew["port"]
149 | }
150 | urlBase += headerKvNew["path"]
151 | } else {
152 | if req.URL.RawQuery == "" {
153 | urlBase = originURL
154 | } else {
155 | urlBase = originURL[:len(originURL)-len(req.URL.RawQuery)-1]
156 | }
157 | }
158 |
159 | if isGetChange {
160 | urlBase += "?" + getNew.Encode()
161 | } else {
162 | urlBase += "?" + req.URL.RawQuery
163 | }
164 |
165 | if isHeaderChange || isGetChange {
166 | var urlErr error
167 | req.URL, urlErr = url.Parse(urlBase)
168 | if ser.Debug {
169 | log.Println("DEBUG req_rewrite,url_new:", urlBase, "req_new:", req.URL)
170 | }
171 | if urlErr != nil {
172 | return 502
173 | }
174 |
175 | req.Host = req.URL.Host
176 | }
177 |
178 | // ////////////////////////////////////////////////////////////////////////////
179 |
180 | if isPostChange || isBodyChange {
181 | buf := bytes.NewBuffer([]byte{})
182 | var bodyData string
183 | if isPostChange {
184 | bodyData = postNew.Encode()
185 | } else if isBodyChange {
186 | bodyData = bodyNew
187 | }
188 | req.Header.Del("Content-Length")
189 | if req.Header.Get(contentEncoding) == "gzip" {
190 | tmp := gzipEncode([]byte(bodyData)).Bytes()
191 | buf.Write(tmp)
192 | } else {
193 | buf.WriteString(bodyData)
194 | }
195 | req.ContentLength = int64(buf.Len())
196 | req.Body = io.NopCloser(buf).(io.ReadCloser)
197 | }
198 |
199 | // //////////////////////////////////////////////////////////////////////////
200 |
201 | if isHostAddrChange {
202 | req.URL.Host = hostAddr
203 | if ser.Debug {
204 | log.Println("rewrite host addr:", req.URL.Host, "==>", hostAddr)
205 | }
206 | }
207 | return 200
208 | }
209 |
210 | func (ser *ProxyServe) reqRewrite(reqCtx *requestCtx) int {
211 | if !ser.conf.ModifyRequest {
212 | return 304
213 | }
214 | if reqCtx.Req.Method == "CONNECT" {
215 | return 304
216 | }
217 | originHost := reqCtx.Req.Host + "#" + reqCtx.Req.URL.Host
218 | statusCode1 := ser.reqRewriteByjs(reqCtx)
219 | newHost := reqCtx.Req.Host + "#" + reqCtx.Req.URL.Host
220 |
221 | if ser.Debug {
222 | log.Println("rewrte_debug:\n", "originHost:", originHost, "\nnewHost:", newHost, "\n")
223 | }
224 |
225 | statusCode2 := 304
226 | if originHost == newHost {
227 | statusCode2 = ser.reqRewriteByHosts(reqCtx.Req)
228 | }
229 | if statusCode1 == 200 || statusCode2 == 200 {
230 | return 200
231 | }
232 | if statusCode1 >= 500 || statusCode2 >= 500 {
233 | return 502
234 | }
235 | return 304
236 | }
237 |
238 | func (ser *ProxyServe) reqRewriteByHosts(req *http.Request) int {
239 | if ser.hosts == nil {
240 | return 304
241 | }
242 | if host, has := ser.hosts[req.URL.Host]; has {
243 | log.Println("rewrite host:", req.URL.Host, "==>", host)
244 | req.URL.Host = host
245 | return 200
246 | }
247 | hostInfo := strings.Split(req.URL.Host, ":")
248 | if len(hostInfo) == 1 {
249 | if req.URL.Scheme == "http" {
250 | hostInfo = append(hostInfo, "80")
251 | }
252 | }
253 | reqHost := strings.Join(hostInfo, ":")
254 | if host, has := ser.hosts[reqHost]; has {
255 | log.Println("rewrite host:", req.Host, "==>", host)
256 | req.URL.Host = host
257 | return 200
258 | }
259 |
260 | if host, has := ser.hosts[hostInfo[0]]; has {
261 | log.Println("rewrite host:", req.Host, "==>", host)
262 | req.URL.Host = host
263 | if !strings.Contains(host, ":") {
264 | req.URL.Host += ":" + hostInfo[1]
265 | }
266 | return 200
267 | }
268 | return 304
269 | }
270 |
271 | func _reqMapToURLValue(values any) url.Values {
272 | uValues := make(url.Values)
273 | if values == nil {
274 | return uValues
275 | }
276 | vs := values.(map[string]any)
277 |
278 | for k, arr := range vs {
279 | switch value := arr.(type) {
280 | case []any:
281 | for _, v := range value {
282 | uValues.Add(k, fmt.Sprintf("%v", v))
283 | }
284 | case any:
285 | uValues.Set(k, fmt.Sprintf("%v", value))
286 | default:
287 | log.Println("unkonw type:", value)
288 | }
289 | }
290 | return uValues
291 | }
292 |
--------------------------------------------------------------------------------
/serve/serve.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | import (
4 | "fmt"
5 | "log"
6 | "math/rand"
7 | "net/http"
8 | "net/http/httputil"
9 | "os"
10 | "path/filepath"
11 | "sync"
12 | "sync/atomic"
13 | "time"
14 |
15 | "github.com/hidu/goutils/fs"
16 | "github.com/hidu/goutils/time_util"
17 | )
18 |
19 | type ProxyServe struct {
20 | mydb *kvStore
21 | proxy *HttpProxy
22 |
23 | wsSer *wsServer
24 |
25 | startTime time.Time
26 |
27 | MaxResSaveLength int64
28 |
29 | mu sync.RWMutex
30 |
31 | Debug bool
32 |
33 | conf *Config
34 | configDir string
35 | hosts configHosts
36 |
37 | Users map[string]*User
38 | ProxyClients map[string]*clientSession
39 | reqNum int64
40 |
41 | reqMod *requestModifier
42 | }
43 |
44 | type KvType map[string]any
45 |
46 | func (ser *ProxyServe) ServeHTTP(w http.ResponseWriter, req *http.Request) {
47 | atomic.AddInt64(&ser.reqNum, 1)
48 |
49 | // reqDump, _ := httputil.DumpRequest(req, true)
50 | // fmt.Println("req dump:\n",string(reqDump))
51 |
52 | ctx := NewRequestCtx(ser, w, req)
53 | if ctx.Host == "p.info" || ctx.Host == "pproxy.info" {
54 | ser.handleUserInfo(w, req)
55 | return
56 | }
57 |
58 | if ctx.Host == "pproxy.man" || ctx.Host == "pproxy.com" || ctx.IsLocalRequest() {
59 | ser.handleLocalReq(w, req)
60 | } else {
61 | if ser.Debug {
62 | reqDumpDebug, _ := httputil.DumpRequest(req, req.Method == "GET")
63 | log.Println("DEBUG req BEFORE:\nurl_full:", req.URL.String(), "\nschema:", req.URL.Scheme, "\n", string(reqDumpDebug), "\n\n")
64 | }
65 | if !ser.checkHTTPAuth(ctx) {
66 | ctx.SetLog("msg", "login required")
67 | ctx.Rw.Header().Set("Proxy-Authenticate", "Basic realm=auth required")
68 | ctx.Rw.WriteHeader(http.StatusProxyAuthRequired)
69 | ctx.Rw.Write([]byte("auth required"))
70 | return
71 | }
72 | ctx.RoundTrip()
73 | }
74 | }
75 |
76 | // for replay
77 | func (ser *ProxyServe) ServeHTTPProxy(w http.ResponseWriter, req *http.Request) {
78 | atomic.AddInt64(&ser.reqNum, 1)
79 | ctx := NewRequestCtx(ser, w, req)
80 | ctx.RoundTrip()
81 | }
82 |
83 | func (ser *ProxyServe) Start() {
84 | addr := fmt.Sprintf("%s:%d", "", ser.conf.Port)
85 | fmt.Println("proxy listen at ", addr)
86 | defer log.Println("pproxy exit")
87 |
88 | ser.wsInit()
89 |
90 | wg := new(sync.WaitGroup)
91 | wg.Add(1)
92 | go func() {
93 | err := http.ListenAndServe(addr, ser)
94 | log.Println(err)
95 | fmt.Println(err)
96 | wg.Done()
97 | }()
98 |
99 | wg.Add(1)
100 | go func() {
101 | ser.startAdmin()
102 | wg.Done()
103 | }()
104 |
105 | wg.Wait()
106 | }
107 |
108 | func (ser *ProxyServe) startAdmin() {
109 | if ser.conf.Port == ser.conf.AdminPort {
110 | return
111 | }
112 | addr := fmt.Sprintf(":%d", ser.conf.AdminPort)
113 | fmt.Println("admin http service listen at ", addr)
114 | httpSer := http.NewServeMux()
115 | httpSer.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
116 | ser.handleLocalReq(w, req)
117 | })
118 | http.ListenAndServe(addr, httpSer)
119 | }
120 |
121 | func (ser *ProxyServe) getResponseByDocid(docid int) (resData *StoreType, err error) {
122 | tb := ser.mydb.GetkvStoreTable(KV_TABLE_RES)
123 | return tb.Get(IntToBytes(docid))
124 | }
125 |
126 | func (ser *ProxyServe) getRequestByDocid(docid int) (reqData *StoreType, err error) {
127 | tb := ser.mydb.GetkvStoreTable(KV_TABLE_REQ)
128 | return tb.Get(IntToBytes(docid))
129 | }
130 |
131 | func (ser *ProxyServe) getHostsFilePath() string {
132 | return fmt.Sprintf("%s/hosts_%d", ser.configDir, ser.conf.Port)
133 | }
134 |
135 | func (ser *ProxyServe) loadHosts() {
136 | ser.mu.Lock()
137 | defer ser.mu.Unlock()
138 | hostsPath := ser.getHostsFilePath()
139 | log.Println("load hosts:", hostsPath)
140 | ser.hosts, _ = loadHosts(hostsPath)
141 | }
142 |
143 | func NewProxyServe(confPath string, port int) (*ProxyServe, error) {
144 | conf, err := LoadConfig(confPath)
145 | if err != nil {
146 | log.Println("load config faield", err)
147 | return nil, err
148 | }
149 | if port > 0 && port < 65535 {
150 | conf.Port = port
151 | }
152 |
153 | absPath, err := filepath.Abs(confPath)
154 | if err != nil {
155 | log.Println("get config path failed", confPath)
156 | return nil, err
157 | }
158 | GetVersion()
159 | os.Chdir(filepath.Dir(absPath))
160 | setupLog(conf.DataDir, conf.Port)
161 |
162 | proxy := new(ProxyServe)
163 | proxy.configDir = filepath.Dir(absPath)
164 | proxy.Users, _ = loadUsers(proxy.configDir + "/users")
165 |
166 | conf.FileDir, _ = filepath.Abs(conf.FileDir)
167 |
168 | proxy.conf = conf
169 |
170 | proxy.reqMod = NewRequestModifier(proxy)
171 | err = proxy.reqMod.loadAllJs()
172 | if err != nil {
173 | return nil, err
174 | }
175 |
176 | proxy.loadHosts()
177 |
178 | dbPath := fmt.Sprintf("%s/%d.db", conf.DataDir, conf.Port)
179 |
180 | // proxy.mydb = NewTieDb(fmt.Sprintf("%s/%d/", conf.DataDir, conf.Port), conf.DataStoreDay)
181 | proxy.mydb, err = newKvStore(dbPath)
182 | if err != nil {
183 | log.Fatalln("init db failed", err)
184 | }
185 |
186 | proxy.startTime = time.Now()
187 | proxy.MaxResSaveLength = 2 * 1024 * 1024
188 |
189 | rand.Seed(time.Now().UnixNano())
190 |
191 | proxy.ProxyClients = make(map[string]*clientSession)
192 | proxy.proxy = NewHttpProxy(proxy)
193 |
194 | time_util.SetInterval(func() {
195 | proxy.cleanExpiredSession()
196 | }, 60)
197 | proxy.mydb.StartGcTimer(60, int64(conf.DataStoreDay*86400))
198 | return proxy, nil
199 | }
200 |
201 | func setupLog(dataDir string, port int) {
202 | logPath := fmt.Sprintf("%s/%d.log", dataDir, port)
203 |
204 | logFile, err := os.OpenFile(logPath, os.O_CREATE|os.O_RDWR|os.O_APPEND, 0644)
205 | if err != nil {
206 | log.Println("create log file failed [", logPath, "]", err)
207 | os.Exit(2)
208 | }
209 | log.SetOutput(logFile)
210 |
211 | time_util.SetInterval(func() {
212 | if !fs.FileExists(logPath) {
213 | logFile.Close()
214 | logFile, _ = os.OpenFile(logPath, os.O_CREATE|os.O_RDWR|os.O_APPEND, 0644)
215 | log.SetOutput(logFile)
216 | }
217 | }, 30)
218 | }
219 |
--------------------------------------------------------------------------------
/serve/sessions.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | import (
4 | "log"
5 | "time"
6 | )
7 |
8 | type clientSession struct {
9 | Ip string
10 | Port string
11 | RequestNum int
12 | FirstRequestTime time.Time
13 | LastRequestTime time.Time
14 | User *User
15 | }
16 |
17 | func (ser *ProxyServe) regirestReq(reqCtx *requestCtx) {
18 | ip := reqCtx.GetIp()
19 | now := time.Now()
20 | ser.mu.Lock()
21 | defer ser.mu.Unlock()
22 | var session *clientSession
23 | client, has := ser.ProxyClients[ip]
24 | if has {
25 | session = client
26 | } else {
27 | session = &clientSession{
28 | Ip: ip,
29 | RequestNum: 0,
30 | FirstRequestTime: now,
31 | LastRequestTime: now,
32 | }
33 | }
34 | if reqCtx.User.Name == "" && session.User != nil {
35 | reqCtx.User = session.User
36 | } else if reqCtx.User.Name != "" {
37 | session.User = reqCtx.User
38 | }
39 |
40 | session.LastRequestTime = now
41 | session.RequestNum++
42 | if ser.Debug {
43 | log.Println("session_debug:", session)
44 | }
45 | ser.ProxyClients[ip] = session
46 |
47 | reqCtx.ClientSession = session
48 |
49 | if !has {
50 | ser.wsSer.broadProxyClientNum()
51 | }
52 | }
53 |
54 | func (ser *ProxyServe) cleanExpiredSession() {
55 | ser.mu.Lock()
56 | defer ser.mu.Unlock()
57 | now := time.Now()
58 | deleteIps := []string{}
59 | for ip, session := range ser.ProxyClients {
60 | t := now.Sub(session.LastRequestTime)
61 | if t.Minutes() > 10 {
62 | deleteIps = append(deleteIps, ip)
63 | }
64 | }
65 | for _, ip := range deleteIps {
66 | delete(ser.ProxyClients, ip)
67 | log.Println("session expired:ip=", ip)
68 | }
69 | ser.wsSer.broadProxyClientNum()
70 | }
71 |
--------------------------------------------------------------------------------
/serve/util.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | import (
4 | "bytes"
5 | "compress/gzip"
6 | // "encoding/base64"
7 | "encoding/binary"
8 | "encoding/json"
9 | "errors"
10 | "fmt"
11 | "io"
12 | "log"
13 | "net"
14 | "net/http"
15 | "net/url"
16 | "strconv"
17 | "strings"
18 |
19 | // "gopkg.in/vmihailenco/msgpack.v2"
20 | )
21 |
22 | // Int64ToBytes int64转换为byte
23 | func Int64ToBytes(i int64) []byte {
24 | var buf = make([]byte, 8)
25 | binary.BigEndian.PutUint64(buf, uint64(i))
26 | return buf
27 | }
28 |
29 | // IntToBytes int转换为byte
30 | func IntToBytes(i int) []byte {
31 | var buf = make([]byte, 8)
32 | binary.BigEndian.PutUint64(buf, uint64(i))
33 | return buf
34 | }
35 |
36 | // IsLocalIP 判断一个host是否本地ip
37 | func IsLocalIP(host string) bool {
38 | ips, _ := net.LookupIP(host)
39 | for _, ip := range ips {
40 | if ip.IsLoopback() {
41 | return true
42 | }
43 | }
44 | if addrs, err := net.InterfaceAddrs(); err == nil {
45 | for _, addr := range addrs {
46 | _, ipG, err := net.ParseCIDR(addr.String())
47 | if err == nil {
48 | for _, ip := range ips {
49 | if ipG.Contains(ip) {
50 | return true
51 | }
52 | }
53 | }
54 | }
55 | }
56 | return false
57 | }
58 |
59 | func forgetRead(reader *io.ReadCloser) *bytes.Buffer {
60 | buf := bytes.NewBuffer([]byte{})
61 | io.Copy(buf, *reader)
62 | *reader = io.NopCloser(buf).(io.ReadCloser)
63 | return bytes.NewBuffer(buf.Bytes())
64 | }
65 |
66 | func dataEncode(data any) []byte {
67 | bf, err := json.Marshal(data)
68 | if err != nil {
69 | log.Println("data_encode_err", err)
70 | return bf
71 | }
72 | return bf
73 | }
74 |
75 | func dataDecode(dataInput []byte, out any) error {
76 | if len(dataInput) == 0 {
77 | return errors.New("empty dataInput")
78 | }
79 | err := json.Unmarshal(dataInput, &out)
80 | if err != nil {
81 | log.Println("json_decode_err:", err, "dataInput:", string(dataInput))
82 | return err
83 | }
84 | return err
85 | }
86 |
87 | func getMapValStr(m map[string]any, k string) string {
88 | if val, has := m[k]; has {
89 | return fmt.Sprintf("%s", val)
90 | }
91 | return ""
92 | }
93 |
94 | func gzipDocode(buf *bytes.Buffer) string {
95 | if buf.Len() < 1 {
96 | return ""
97 | }
98 | gr, err := gzip.NewReader(buf)
99 | defer gr.Close()
100 | if err == nil {
101 | bdBt, _ := io.ReadAll(gr)
102 | return string(bdBt)
103 | }
104 | log.Println("unzip body failed", err)
105 | return ""
106 | }
107 |
108 | func gzipEncode(data []byte) *bytes.Buffer {
109 | buf := bytes.NewBuffer([]byte{})
110 | gw := gzip.NewWriter(buf)
111 | defer gw.Close()
112 | gw.Write(data)
113 | return buf
114 | }
115 |
116 | func parseURLInputAsSlice(input string) []string {
117 | arr := strings.Split(input, "|")
118 | var result []string
119 | for _, val := range arr {
120 | val = strings.TrimSpace(val)
121 | if val != "" {
122 | result = append(result, val)
123 | }
124 | }
125 | return result
126 | }
127 |
128 | func getFormValuesWithPrefix(values url.Values, prefix string) map[string][]string {
129 | result := make(map[string][]string)
130 | for k, v := range values {
131 | if strings.HasPrefix(k, prefix) {
132 | k1 := strings.TrimPrefix(k, prefix)
133 | result[k1] = v
134 | }
135 | }
136 | return result
137 | }
138 |
139 | func getTextAreaHeightByString(mystr string, minHeight int) int {
140 | height := (len(strings.Split(mystr, "\n")) + 1) * 25
141 | if height < minHeight {
142 | height = minHeight
143 | }
144 | return height
145 | }
146 |
147 | func getHostPortFromReq(req *http.Request) (host string, port int, err error) {
148 | host, port, err = parseHostPort(req.Host)
149 | if err == nil && port == 0 {
150 | switch req.URL.Scheme {
151 | case "http":
152 | port = 80
153 | break
154 | case "https":
155 | port = 443
156 | break
157 | default:
158 | break
159 | }
160 | }
161 | return
162 | }
163 |
164 | func parseHostPort(hostPortstr string) (host string, port int, err error) {
165 | var portStr string
166 | if !strings.Contains(hostPortstr, ":") {
167 | hostPortstr += ":0"
168 | }
169 | host, portStr, err = net.SplitHostPort(hostPortstr)
170 | if err != nil {
171 | return
172 | }
173 | port, err = strconv.Atoi(portStr)
174 | if err != nil {
175 | return
176 | }
177 | return
178 | }
179 |
180 | func checkURLValuesChange(first url.Values, second url.Values) (change bool) {
181 | for k, v := range first {
182 | secV, has := second[k]
183 | if !has {
184 | return true
185 | }
186 | if len(v) != len(secV) || fmt.Sprintf("%v", v) != fmt.Sprintf("%v", secV) {
187 | return true
188 | }
189 | }
190 | for k, v := range second {
191 | firstV, has := first[k]
192 | if !has {
193 | return true
194 | }
195 | if len(v) != len(firstV) || fmt.Sprintf("%v", v) != fmt.Sprintf("%v", firstV) {
196 | return true
197 | }
198 | }
199 | return false
200 | }
201 |
202 | func parseDocID(strid string) (docid int, err error) {
203 | docid64, parseErr := strconv.ParseUint(strid, 10, 64)
204 | if parseErr == nil {
205 | return int(docid64), nil
206 | }
207 | return 0, parseErr
208 | }
209 |
210 | func removeHeader(req *http.Request) {
211 | for k := range req.Header {
212 | if len(k) > 5 && k[:6] == "Proxy-" {
213 | req.Header.Del(k)
214 | }
215 | }
216 | }
217 |
218 | func getPostData(req *http.Request) (post *url.Values) {
219 | post = new(url.Values)
220 | if strings.Contains(req.Header.Get("Content-Type"), "x-www-form-urlencoded") {
221 | buf := forgetRead(&req.Body)
222 | var bodyStr string
223 | if req.Header.Get(contentEncoding) == "gzip" {
224 | bodyStr = gzipDocode(buf)
225 | } else {
226 | bodyStr = buf.String()
227 | }
228 | var err error
229 | *post, err = url.ParseQuery(bodyStr)
230 | if err != nil {
231 | log.Println("parse post err", err, "url=", req.URL.String())
232 | }
233 | }
234 | return post
235 | }
236 |
237 | func headerEncode(data []byte) []byte {
238 | t := bytes.Replace(data, []byte("\r"), []byte("\\r"), -1)
239 | t = bytes.Replace(t, []byte("\n"), []byte("\\n"), -1)
240 | return t
241 | }
242 |
--------------------------------------------------------------------------------
/serve/web.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | import (
4 | "bytes"
5 | "encoding/base64"
6 | "fmt"
7 | "html"
8 | "log"
9 | "net"
10 | "net/http"
11 | "net/url"
12 | "regexp"
13 | "strconv"
14 | "strings"
15 | "text/template"
16 | "time"
17 |
18 | "github.com/hidu/goutils/fs"
19 | "github.com/hidu/goutils/html_util"
20 | "github.com/hidu/goutils/object"
21 | )
22 |
23 | type webRequestCtx struct {
24 | values map[string]any
25 | user *User
26 | isLogin bool
27 | isAdmin bool
28 | req *http.Request
29 | w http.ResponseWriter
30 | ser *ProxyServe
31 | }
32 |
33 | var cookieName = "pproxy"
34 |
35 | func (ser *ProxyServe) handleLocalReq(w http.ResponseWriter, req *http.Request) {
36 | accessLogStr := "web_access " + req.Method + " " + req.URL.String() + " " + req.RemoteAddr + " refer:" + req.Referer()
37 | defer (func() {
38 | log.Println(accessLogStr)
39 | })()
40 |
41 | if strings.HasPrefix(req.URL.Path, "/socket.io/") {
42 | ser.wsSer.server.ServeHTTP(w, req)
43 | return
44 | }
45 |
46 | if strings.HasPrefix(req.URL.Path, "/f/") {
47 | req.URL.Path = req.URL.Path[3:]
48 | http.FileServer(http.Dir(ser.conf.FileDir)).ServeHTTP(w, req)
49 | return
50 | }
51 |
52 | if strings.HasPrefix(req.URL.Path, "/res/") {
53 | Assest.HTTPHandler("/").ServeHTTP(w, req)
54 | return
55 | }
56 |
57 | values := make(map[string]any)
58 | values["title"] = ser.conf.Title
59 | values["subTitle"] = ""
60 | values["version"] = PproxyVersion
61 | values["notice"] = ser.conf.Notice
62 | values["port"] = strconv.Itoa(ser.conf.Port)
63 | values["userOnlineTotal"] = len(ser.ProxyClients)
64 | _host, _, _ := getHostPortFromReq(req)
65 | values["pproxy_host"] = _host
66 | values["pproxy_port"] = ser.conf.Port
67 |
68 | ctx := &webRequestCtx{
69 | values: values,
70 | w: w,
71 | req: req,
72 | ser: ser,
73 | }
74 | ctx.checkLogin()
75 |
76 | funcMap := make(map[string]func())
77 | funcMap["/"] = ctx.handle_index
78 | funcMap["/about"] = ctx.handle_about
79 | funcMap["/config"] = ctx.handleConfig
80 | funcMap["/useage"] = ctx.handle_useage
81 | funcMap["/replay"] = ctx.handleReplay
82 | funcMap["/login"] = ctx.handle_login
83 | funcMap["/logout"] = ctx.handle_logout
84 | funcMap["/response"] = ctx.handle_response
85 | funcMap["/file"] = ctx.handle_file
86 |
87 | if fn, has := funcMap[req.URL.Path]; has {
88 | if len(req.URL.Path) > 1 {
89 | ctx.values["subTitle"] = req.URL.Path[1:] + " |"
90 | }
91 | fn()
92 | } else {
93 | ctx.showError("404")
94 | }
95 | }
96 |
97 | func (ser *ProxyServe) web_checkLogin(req *http.Request) (user *User, isLogin bool) {
98 | if req == nil {
99 | return
100 | }
101 | cookie, err := req.Cookie(cookieName)
102 | if err != nil {
103 | return
104 | }
105 | info := strings.SplitN(cookie.Value, ":", 2)
106 | if len(info) != 2 {
107 | return
108 | }
109 | if user, has := ser.Users[info[0]]; has {
110 | if user.PswMd5 == info[1] {
111 | return user, true
112 | }
113 | }
114 | return
115 | }
116 |
117 | func (ctx *webRequestCtx) checkLogin() {
118 | user, isLogin := ctx.ser.web_checkLogin(ctx.req)
119 | if isLogin {
120 | ctx.user = user
121 | ctx.isLogin = true
122 | ctx.isAdmin = user.IsAdmin
123 | }
124 | ctx.values["isLogin"] = ctx.isLogin
125 | ctx.values["user"] = ctx.user
126 | ctx.values["isAdmin"] = ctx.isAdmin
127 | }
128 |
129 | func (ctx *webRequestCtx) handle_index() {
130 | ctx.render("network.html", true)
131 | }
132 |
133 | func (ctx *webRequestCtx) handle_useage() {
134 | ctx.render("useage.html", true)
135 | }
136 |
137 | func (ctx *webRequestCtx) getRewriteJsInfo(name string, title string) map[string]any {
138 | info := make(map[string]any)
139 | jsStr, _ := ctx.ser.reqMod.getJsContent(name)
140 |
141 | re := regexp.MustCompile(`use_file\(["'](.+)["']\)`)
142 | matches := re.FindAllStringSubmatch(jsStr, -1)
143 |
144 | // fmt.Println(matches)
145 |
146 | var useFile []map[string]any
147 | tmpNames := make(map[string]int)
148 |
149 | for _, subMatch := range matches {
150 | if len(subMatch) != 2 {
151 | continue
152 | }
153 | use := make(map[string]any)
154 | fileName := strings.TrimSpace(subMatch[1])
155 | use["name"] = subMatch[0]
156 | use["file"] = fileName
157 |
158 | if _, has := tmpNames[fileName]; has {
159 | continue
160 | }
161 | tmpNames[fileName] = 1
162 |
163 | isURL := strings.HasPrefix(fileName, "http://")
164 | use["isUrl"] = isURL
165 | if isURL {
166 | use["url"] = subMatch[1]
167 | } else {
168 | webFile, err := newWebFileInfo(ctx.ser.conf.FileDir, fileName)
169 | if err != nil {
170 | continue
171 | }
172 | use["url"] = webFile.link()
173 | defer webFile.Close()
174 | }
175 | useFile = append(useFile, use)
176 | }
177 |
178 | info["name"] = name
179 | info["use_file"] = useFile
180 | info["title"] = title
181 | info["rewriteJs"] = html.EscapeString(jsStr)
182 | info["jsHeight"] = getTextAreaHeightByString(jsStr, 100)
183 | return info
184 | }
185 |
186 | func (ctx *webRequestCtx) handleConfig() {
187 | if ctx.req.Method == "GET" {
188 | jsDataArr := make([]any, 0, 2)
189 | jsDataArr = append(jsDataArr, ctx.getRewriteJsInfo("", "global config"))
190 |
191 | if ctx.isLogin {
192 | jsDataArr = append(jsDataArr, ctx.getRewriteJsInfo(ctx.user.Name, ctx.user.Name+"'s config"))
193 | }
194 |
195 | ctx.values["jss"] = jsDataArr
196 |
197 | hostsByte, _ := fs.FileGetContents(ctx.ser.getHostsFilePath())
198 | ctx.values["hosts"] = html.EscapeString(string(hostsByte))
199 | ctx.values["hostsHeight"] = getTextAreaHeightByString("", 100)
200 |
201 | ctx.render("config.html", true)
202 | } else if ctx.req.Method == "POST" {
203 | if !ctx.isLogin {
204 | ctx.jsAlert("login first")
205 | return
206 | }
207 | do := ctx.req.PostFormValue("type")
208 | var err error
209 | if do == "js" {
210 | name := strings.TrimSpace(ctx.req.PostFormValue("name"))
211 | if !ctx.isAdmin && name != ctx.user.Name {
212 | ctx.jsAlert("you are not admin")
213 | return
214 | }
215 | jsStr := strings.TrimSpace(ctx.req.PostFormValue("js"))
216 | err = ctx.ser.reqMod.parseJs(jsStr, name, true)
217 | } else if do == "hosts" {
218 | if !ctx.isAdmin {
219 | ctx.jsAlert("you are not admin")
220 | return
221 | }
222 | hosts := strings.TrimSpace(ctx.req.PostFormValue("hosts"))
223 | log.Println("hosts_update", hosts)
224 | err = fs.FilePutContents(ctx.ser.getHostsFilePath(), []byte(hosts))
225 | ctx.ser.loadHosts()
226 | }
227 | if err != nil {
228 | ctx.jsAlert("save failed,err:" + err.Error())
229 | } else {
230 | ctx.w.Write([]byte(""))
231 | }
232 | }
233 | }
234 |
235 | func (ctx *webRequestCtx) handle_response() {
236 | docid, uintParseErr := parseDocID(ctx.req.FormValue("id"))
237 | if uintParseErr == nil {
238 | responseData, _ := ctx.ser.getResponseByDocid(docid)
239 | if responseData == nil {
240 | ctx.showError("response not found")
241 | } else {
242 | walker := object.NewInterfaceWalker(map[string]any(responseData.Data))
243 | var contentType string
244 | if typeHeader, has := walker.GetStringSlice("/header/Content-Type"); has {
245 | contentType = strings.Join(typeHeader, ";")
246 | }
247 |
248 | customContentType := ctx.req.FormValue("type")
249 | // set custom content type
250 | if customContentType != "" {
251 | switch customContentType {
252 | case "json":
253 | contentType = "application/json"
254 | case "html":
255 | contentType = "text/html;charset=utf-8"
256 | default:
257 | contentType = customContentType
258 | }
259 | }
260 | if contentType != "" {
261 | ctx.w.Header().Set("Content-Type", contentType)
262 | }
263 | if statusCode, has := walker.GetInt("/status"); has {
264 | ctx.w.WriteHeader(statusCode)
265 | }
266 | if bodyStr, has := walker.GetString("/body"); has {
267 | bodyByte, err := base64.StdEncoding.DecodeString(bodyStr)
268 | if err == nil {
269 | ctx.w.Write(bodyByte)
270 | } else {
271 | log.Println("decode body failed", err)
272 | }
273 | } else {
274 | ctx.showError("response body not found")
275 | }
276 | }
277 | } else {
278 | ctx.showError("param err")
279 | }
280 | }
281 |
282 | func (ctx *webRequestCtx) jsAlert(msg string) {
283 | fmt.Fprintf(ctx.w, "", html.EscapeString(msg))
284 | }
285 |
286 | func (ctx *webRequestCtx) jsAlertJump(msg string, urlStr string) {
287 | fmt.Fprintf(ctx.w, "", html.EscapeString(msg), urlStr)
288 | }
289 |
290 | func (ctx *webRequestCtx) handle_about() {
291 | ctx.render("about.html", true)
292 | }
293 |
294 | func (ctx *webRequestCtx) handle_logout() {
295 | cookie := &http.Cookie{Name: cookieName, Value: "", Path: "/"}
296 | http.SetCookie(ctx.w, cookie)
297 | http.Redirect(ctx.w, ctx.req, "/", 302)
298 | }
299 |
300 | func (ctx *webRequestCtx) handle_login() {
301 | if ctx.req.Method == "GET" {
302 | ctx.render("login.html", true)
303 | } else {
304 | name := strings.TrimSpace(ctx.req.FormValue("name"))
305 | psw := strings.TrimSpace(ctx.req.FormValue("psw"))
306 | if name == "" {
307 | ctx.jsAlert("empty name")
308 | return
309 | }
310 | if user, has := ctx.ser.Users[name]; has {
311 | if user.isPswEq(psw) {
312 | log.Println("login suc,name=", name)
313 | cookie := &http.Cookie{
314 | Name: cookieName,
315 | Value: fmt.Sprintf("%s:%s", name, user.PswMd5),
316 | Path: "/",
317 | Expires: time.Now().Add(86400 * time.Second),
318 | }
319 | http.SetCookie(ctx.w, cookie)
320 | ctx.w.Write([]byte(""))
321 | } else {
322 | log.Println("login failed psw incorrect,name=", name, "psw=", psw)
323 | ctx.jsAlert("password incorrect")
324 | }
325 | return
326 | }
327 | log.Println("login failed not exists,name=", name, "psw=", psw)
328 | ctx.jsAlert("user not exists")
329 | }
330 | }
331 |
332 | func (ctx *webRequestCtx) render(name string, layout bool) {
333 | html := render_html(name, ctx.values, layout)
334 | ctx.w.Write([]byte(html))
335 | }
336 |
337 | func (ctx *webRequestCtx) showError(msg string) {
338 | ctx.values["error"] = msg
339 | ctx.values["subTitle"] = "Error Page |"
340 | ctx.render("error.html", true)
341 | }
342 |
343 | func (ctx *webRequestCtx) showErrorOrAlert(msg string) {
344 | if ctx.req.Method == "POST" {
345 | ctx.jsAlert(msg)
346 | } else {
347 | ctx.showError(msg)
348 | }
349 | }
350 |
351 | func reader_html_include(fileName string) string {
352 | html := Assest.GetContent("/res/tpl/" + fileName)
353 | myfn := template.FuncMap{
354 | "my_include": func(name string) string {
355 | return reader_html_include(name)
356 | },
357 | }
358 | tpl, _ := template.New("page_include").Delims("{%", "%}").Funcs(myfn).Parse(html)
359 | var bf []byte
360 | w := bytes.NewBuffer(bf)
361 | tpl.Execute(w, make(map[string]string))
362 | body := w.String()
363 | return body
364 | }
365 |
366 | func render_html(fileName string, values map[string]any, layout bool) string {
367 | html := reader_html_include(fileName)
368 | funcs := template.FuncMap{
369 | "escape": func(str string) string {
370 | return url.QueryEscape(str)
371 | },
372 | "my_include": func(fileName string) string {
373 | return "include (" + fileName + ") with Delims {%my_include %}"
374 | },
375 | }
376 | tpl, _ := template.New("page").Funcs(funcs).Parse(html)
377 | var bf []byte
378 | w := bytes.NewBuffer(bf)
379 | tpl.Execute(w, values)
380 | body := w.String()
381 | if layout {
382 | values["body"] = body
383 | return render_html("layout.html", values, false)
384 | }
385 | return html_util.Html_reduceSpace(body)
386 | }
387 |
388 | func (ser *ProxyServe) handleUserInfo(w http.ResponseWriter, req *http.Request) {
389 | host, _, _ := net.SplitHostPort(req.RemoteAddr)
390 | data := "client ip:" + host
391 | w.Write([]byte(data))
392 | }
393 |
--------------------------------------------------------------------------------
/serve/web_file.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | import (
4 | "fmt"
5 | "io"
6 | "log"
7 | "net/url"
8 | "os"
9 | "path/filepath"
10 | "regexp"
11 | "strings"
12 |
13 | "github.com/hidu/goutils/fs"
14 | )
15 |
16 | type webFileInfo struct {
17 | Name string
18 | RootDir string
19 | IsDir bool
20 | Size int64
21 | Link string
22 | fullPath string
23 | file *os.File
24 | subFileInfos []*webFileInfo
25 | }
26 |
27 | func newWebFileInfo(rootDir, name string) (*webFileInfo, error) {
28 | rootDir = filepath.Clean(rootDir + "/")
29 | fullPath := filepath.Clean(fmt.Sprintf("%s/%s", rootDir, name))
30 | if !strings.HasPrefix(fullPath, rootDir) {
31 | return nil, fmt.Errorf("unsafe path:%s", name)
32 | }
33 | f, err := os.Open(fullPath)
34 | if err != nil {
35 | return nil, err
36 | }
37 | stat, err := f.Stat()
38 | if err != nil {
39 | return nil, err
40 | }
41 | info := &webFileInfo{
42 | Name: strings.TrimLeft(fullPath[len(rootDir):], "/"),
43 | RootDir: rootDir,
44 | IsDir: stat.IsDir(),
45 | Size: stat.Size(),
46 | fullPath: fullPath,
47 | file: f,
48 | }
49 | info.Link = info.link()
50 | return info, nil
51 | }
52 |
53 | func (f *webFileInfo) String() string {
54 | return fmt.Sprintf("Name:%s\nRootDir:%s\nisDir:%v\nSize:%d\nfullPath:%s\n", f.Name, f.RootDir, f.IsDir, f.Size, f.fullPath)
55 | }
56 |
57 | func (f *webFileInfo) link() string {
58 | values := make(url.Values)
59 | values.Set("name", f.Name)
60 | if !f.IsDir {
61 | values.Set("op", "edit")
62 | }
63 | return "/file?" + values.Encode()
64 | }
65 |
66 | func (f *webFileInfo) getContent() string {
67 | if f.IsDir {
68 | return ""
69 | }
70 | data, err := io.ReadAll(f.file)
71 | if err != nil {
72 | log.Println("read file failed:", err)
73 | return ""
74 | }
75 | return string(data)
76 | }
77 |
78 | func (f *webFileInfo) Close() {
79 | f.file.Close()
80 | if f.subFileInfos != nil {
81 | for _, info := range f.subFileInfos {
82 | info.Close()
83 | }
84 | }
85 | }
86 |
87 | func (f *webFileInfo) subFiles() ([]*webFileInfo, error) {
88 | names, err := f.file.Readdirnames(0)
89 | if err != nil {
90 | return nil, err
91 | }
92 | fileInfos := make([]*webFileInfo, 0)
93 |
94 | for _, name := range names {
95 | info, err := newWebFileInfo(f.RootDir, fmt.Sprintf("%s/%s", f.Name, name))
96 | if err != nil {
97 | log.Println("read file err,skip.name=", name, err)
98 | } else {
99 | fileInfos = append(fileInfos, info)
100 | }
101 | }
102 | f.subFileInfos = fileInfos
103 | return fileInfos, nil
104 | }
105 |
106 | func (ser *ProxyServe) getWebFilePath(name string) (fullPath string, nameNew string, err error) {
107 | rootDir := filepath.Clean(ser.conf.FileDir + "/")
108 | fullPath = filepath.Clean(fmt.Sprintf("%s/%s", rootDir, name))
109 | if !strings.HasPrefix(fullPath, rootDir) {
110 | return "", "", fmt.Errorf("unsafe path:%s", name)
111 | }
112 | nameNew = fullPath[len(rootDir):]
113 | re := regexp.MustCompile(`^[\w/\-\.]*$`)
114 | if !re.MatchString(nameNew) {
115 | err = fmt.Errorf("illegal path:%s", nameNew)
116 | }
117 | return fullPath, nameNew, err
118 | }
119 |
120 | func (ctx *webRequestCtx) handle_file() {
121 | if !ctx.isLogin {
122 | ctx.showError("need login")
123 | return
124 | }
125 |
126 | opMap := make(map[string]func())
127 | opMap["edit"] = ctx.handle_file_edit
128 | opMap["new"] = ctx.handle_file_new
129 | opMap["del"] = ctx.handle_file_del
130 | opMap["save"] = ctx.handle_file_save
131 |
132 | op := ctx.req.FormValue("op")
133 | if fn, has := opMap[op]; has {
134 | fn()
135 | return
136 | }
137 | name := ctx.req.FormValue("name")
138 | if !ctx.isAdmin && name == "" {
139 | name = ctx.user.Name
140 | dirFullPath, _, err := ctx.ser.getWebFilePath(name)
141 | if err != nil {
142 | ctx.showError("file dir wrong")
143 | return
144 | }
145 | if !fs.FileExists(dirFullPath) {
146 | os.MkdirAll(dirFullPath, os.ModePerm)
147 | }
148 | }
149 |
150 | dirInfo, err := newWebFileInfo(ctx.ser.conf.FileDir, name)
151 | if err != nil {
152 | ctx.showError("open file dir failed:" + name)
153 | return
154 | }
155 | defer dirInfo.Close()
156 |
157 | ctx.values["currentDir"] = dirInfo.Name
158 | ctx.values["isSubDir"] = dirInfo.Name != ""
159 | if !ctx.isAdmin && !strings.Contains(dirInfo.Name, "/") {
160 | ctx.values["isSubDir"] = false
161 | }
162 | files, err := dirInfo.subFiles()
163 | if err != nil {
164 | ctx.showError(err.Error())
165 | return
166 | }
167 | ctx.values["files"] = files
168 |
169 | ctx.render("file.html", true)
170 | }
171 |
172 | func (ctx *webRequestCtx) handle_file_edit() {
173 | name := ctx.req.FormValue("name")
174 | if name == "" {
175 | ctx.showError("params wrong")
176 | return
177 | }
178 | info, err := newWebFileInfo(ctx.ser.conf.FileDir, name)
179 | if err != nil {
180 | ctx.showError("read file info failed:" + err.Error())
181 | return
182 | }
183 | defer info.Close()
184 | if info.IsDir {
185 | ctx.showError("params wrong,only file can view")
186 | return
187 | }
188 | ctx.values["file"] = info
189 | fileContent := info.getContent()
190 | ctx.values["fileContent"] = fileContent
191 | ctx.values["fileContentRows"] = len(strings.Split(fileContent, "\n")) + 8
192 | ctx.render("file_edit.html", true)
193 | }
194 |
195 | func (ctx *webRequestCtx) handle_file_del() {}
196 |
197 | func (ctx *webRequestCtx) handle_file_new() {
198 | dirFullPath, dirNew, err := ctx.ser.getWebFilePath(ctx.req.FormValue("dir"))
199 | if err != nil {
200 | ctx.showErrorOrAlert("params err:" + err.Error())
201 | return
202 | }
203 | ctx.values["dir"] = dirNew
204 |
205 | if ctx.req.Method == "GET" {
206 | finfo, fErr := os.Stat(dirFullPath)
207 | if fErr != nil || !finfo.IsDir() {
208 | ctx.showErrorOrAlert("open dir failed")
209 | return
210 | }
211 | ctx.render("file_new.html", true)
212 | } else if ctx.req.Method == "POST" {
213 | name := strings.TrimSpace(ctx.req.FormValue("name"))
214 | if name == "" {
215 | ctx.jsAlert("empty filename")
216 | return
217 | }
218 | fpath := ctx.req.FormValue("dir") + "/" + ctx.req.FormValue("name")
219 |
220 | fileFullPath, fileName, err := ctx.ser.getWebFilePath(fpath)
221 |
222 | if err != nil {
223 | ctx.jsAlert("wrong fileName")
224 | return
225 | }
226 |
227 | if fileName == "" || strings.HasSuffix(fileName, "/") {
228 | ctx.jsAlert("wrong file name")
229 | return
230 | }
231 |
232 | if fs.FileExists(fileFullPath) {
233 | ctx.jsAlert("file already exists")
234 | return
235 | }
236 |
237 | if !strings.HasPrefix(fileFullPath, dirFullPath) {
238 | ctx.jsAlert("file name wrong")
239 | return
240 | }
241 |
242 | if !ctx.user.IsAdmin && !strings.HasPrefix(fileName+"/", "/"+ctx.user.Name+"/") {
243 | ctx.jsAlert("file path wrong:" + fileName)
244 | return
245 | }
246 |
247 | dirName := filepath.Dir(fileFullPath)
248 | if !fs.FileExists(dirName) {
249 | os.MkdirAll(dirName, os.ModePerm)
250 | }
251 | content := ctx.req.FormValue("content")
252 |
253 | wErr := fs.FilePutContents(fileFullPath, []byte(content))
254 | if wErr != nil {
255 | ctx.jsAlert("write file failed")
256 | return
257 | }
258 |
259 | finfo, _ := newWebFileInfo(ctx.ser.conf.FileDir, fpath)
260 | defer finfo.Close()
261 |
262 | ctx.jsAlertJump("save suc", finfo.link())
263 | }
264 | }
265 |
266 | func (ctx *webRequestCtx) handle_file_save() {
267 | nameOrigin := ctx.req.PostFormValue("nameOrigin")
268 | name := ctx.req.PostFormValue("name")
269 | content := ctx.req.PostFormValue("content")
270 |
271 | fullPath, nameFix, err := ctx.ser.getWebFilePath(name)
272 | if err != nil {
273 | ctx.jsAlert("file path wrong:" + err.Error())
274 | return
275 | }
276 | if name == "" || nameFix == "" || strings.HasSuffix(nameFix, "/") {
277 | ctx.jsAlert("wrong file name")
278 | return
279 | }
280 | fullPathOrigin, _, err := ctx.ser.getWebFilePath(nameOrigin)
281 |
282 | if fullPathOrigin == "" && err != nil {
283 | ctx.jsAlert("origin file path wrong:" + err.Error())
284 | return
285 | }
286 |
287 | dirName := filepath.Dir(fullPath)
288 | if !fs.FileExists(dirName) {
289 | os.MkdirAll(dirName, os.ModePerm)
290 | }
291 |
292 | errWrite := fs.FilePutContents(fullPath, []byte(content))
293 | if errWrite != nil {
294 | ctx.jsAlert("save failed:" + errWrite.Error())
295 | return
296 | }
297 | if fullPath != fullPathOrigin {
298 | os.Remove(fullPathOrigin)
299 | }
300 | info, _ := newWebFileInfo(ctx.ser.conf.FileDir, name)
301 | ctx.jsAlertJump("save suc", info.link())
302 | }
303 |
--------------------------------------------------------------------------------
/serve/wsClient.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | import (
4 | "net/http"
5 | "path/filepath"
6 | "strings"
7 |
8 | "github.com/googollee/go-socket.io"
9 | )
10 |
11 | type wsClient struct {
12 | ns *socketio.NameSpace
13 | user string
14 | filterUser []string
15 | filterIP []string
16 | filterHideExt []string
17 | filterURL []string
18 | filterURLHide []string
19 | LoginUser *User
20 | }
21 |
22 | var extTypes = map[string][]string{
23 | "js": {"js"},
24 | "css": {"css"},
25 | "image": {"jpg", "jpeg", "png", "gif", "bmp", "tiff", "jpe", "tif", "webp", "ico", "webp"},
26 | }
27 |
28 | func (client *wsClient) checkFilter(req *http.Request, reqCtx *requestCtx) bool {
29 | if len(client.filterUser) > 0 {
30 | userInList := false
31 | for _, name := range client.filterUser {
32 | if name == "any" && client.LoginUser != nil && client.LoginUser.IsAdmin {
33 | userInList = true
34 | break
35 | }
36 | if name != "" && name == reqCtx.User.Name {
37 | userInList = true
38 | break
39 | }
40 | }
41 | if !userInList {
42 | return false
43 | }
44 | }
45 |
46 | if len(client.filterIP) > 0 {
47 | addrInfo := strings.Split(reqCtx.RemoteAddr, ":")
48 | ipInList := false
49 | for _, ip := range client.filterIP {
50 | if ip == "*" {
51 | ipInList = true
52 | break
53 | }
54 |
55 | if ip != "" && addrInfo[0] == ip {
56 | ipInList = true
57 | break
58 | }
59 | }
60 | if !ipInList {
61 | return false
62 | }
63 | }
64 |
65 | if len(client.filterURL) > 0 {
66 | url := req.URL.String()
67 | hasKw := false
68 | for _, subURL := range client.filterURL {
69 | if strings.Contains(url, subURL) {
70 | hasKw = true
71 | break
72 | }
73 | }
74 | if !hasKw {
75 | return false
76 | }
77 | }
78 |
79 | if len(client.filterHideExt) > 0 {
80 | ext := strings.ToLower(strings.Trim(filepath.Ext(req.URL.Path), "."))
81 | for _, hideType := range client.filterHideExt {
82 | for _, hideExt := range extTypes[hideType] {
83 | if ext == hideExt {
84 | return false
85 | }
86 | }
87 | }
88 | }
89 | if len(client.filterURLHide) > 0 {
90 | _url := req.URL.String()
91 | for _, hideKw := range client.filterURLHide {
92 | if hideKw != "" && strings.Contains(_url, hideKw) {
93 | return false
94 | }
95 | }
96 | }
97 | return true
98 | }
99 |
--------------------------------------------------------------------------------
/serve/wsServer.go:
--------------------------------------------------------------------------------
1 | package serve
2 |
3 | import (
4 | "fmt"
5 | "log"
6 | "net/http"
7 | "net/url"
8 | "sync"
9 |
10 | "github.com/googollee/go-socket.io"
11 | "github.com/hidu/goutils/time_util"
12 | )
13 |
14 | type wsServer struct {
15 | clients map[string]*wsClient
16 | server *socketio.SocketIOServer
17 | mu sync.RWMutex
18 | proxySer *ProxyServe
19 | }
20 |
21 | func (ser *ProxyServe) wsInit() {
22 | ser.wsSer = newWsServer(ser)
23 | }
24 |
25 | func newWsServer(ser *ProxyServe) *wsServer {
26 | wsSer := &wsServer{
27 | clients: make(map[string]*wsClient),
28 | proxySer: ser,
29 | }
30 | var err error
31 | wsSer.server = socketio.NewSocketIOServer(&socketio.Config{})
32 | if err != nil {
33 | log.Fatal(err)
34 | }
35 | wsSer.init()
36 | return wsSer
37 | }
38 |
39 | func (wsSer *wsServer) init() {
40 | wsSer.server.On("connect", func(ns *socketio.NameSpace) {
41 | wsSer.mu.Lock()
42 | defer wsSer.mu.Unlock()
43 | wsSer.clients[ns.Id()] = &wsClient{ns: ns, user: "guest"}
44 | log.Println("ws connected", ns.Id(), "ws_client_num:", len(wsSer.clients))
45 | })
46 | wsSer.server.On("disconnect", func(ns *socketio.NameSpace) {
47 | wsSer.remove(ns.Id())
48 | log.Println("ws disconnect", ns.Id(), "ws_client_num:", len(wsSer.clients))
49 | })
50 | wsSer.server.On("error", func(ns *socketio.NameSpace, err error) {
51 | log.Println("ws error:", err)
52 | })
53 | wsSer.server.On("get_response", wsSer.getResponse)
54 | wsSer.server.On("client_filter", wsSer.saveFilter)
55 |
56 | time_util.SetInterval(func() {
57 | wsSer.broadcast("hello", "hello", false)
58 | }, 120)
59 | }
60 |
61 | func (wsSer *wsServer) remove(id string) {
62 | wsSer.mu.Lock()
63 | defer wsSer.mu.Unlock()
64 | if _, has := wsSer.clients[id]; has {
65 | delete(wsSer.clients, id)
66 | }
67 | }
68 |
69 | func (wsSer *wsServer) broadProxyClientNum() {
70 | wsSer.broadcast("user_num", len(wsSer.proxySer.ProxyClients), false)
71 | }
72 |
73 | /*
74 | * https://github.com/googollee/go-socket.io
75 | */
76 | func (wsSer *wsServer) getResponse(ns *socketio.NameSpace, docidStr string) {
77 | docid, uintParseErr := parseDocID(docidStr)
78 | if uintParseErr != nil {
79 | log.Println("parse str2int failed", docidStr, uintParseErr)
80 | return
81 | }
82 | log.Println("receive docid", docid)
83 | req, _ := wsSer.proxySer.getRequestByDocid(docid)
84 | res, _ := wsSer.proxySer.getResponseByDocid(docid)
85 | if wsSer.proxySer.Debug {
86 | fmt.Println("req:\n", req, "\n==========\n")
87 | fmt.Println("res:\n", res, "\n==========\n")
88 | }
89 | // delete(req,"header")
90 | data := make(map[string]any)
91 | data["req"] = nil
92 | data["res"] = nil
93 | if req != nil {
94 | data["req"] = req.Data
95 | }
96 | if res != nil {
97 | data["res"] = res.Data
98 | }
99 | wsSer.send(ns, "res", data, true)
100 | }
101 |
102 | func (wsSer *wsServer) saveFilter(ns *socketio.NameSpace, formData string) {
103 | m, err := url.ParseQuery(formData)
104 | if err != nil {
105 | log.Println("parse filter data err", err)
106 | return
107 | }
108 | wsSer.mu.Lock()
109 | defer wsSer.mu.Unlock()
110 | if nsClient, has := wsSer.clients[ns.Id()]; has {
111 | nsClient.filterIP = parseURLInputAsSlice(m.Get("client_ip"))
112 | nsClient.filterHideExt = m["hide"]
113 | nsClient.filterURL = parseURLInputAsSlice(m.Get("url_match"))
114 | nsClient.filterURLHide = parseURLInputAsSlice(m.Get("hide_url"))
115 | nsClient.filterUser = parseURLInputAsSlice(m.Get("user"))
116 | loginUser, isLogin := wsSer.proxySer.web_checkLogin(ns.Session.Request)
117 | if isLogin {
118 | nsClient.LoginUser = loginUser
119 | }
120 | } else {
121 | log.Println("ws_saveFilter failed,ws not exists")
122 | }
123 | }
124 |
125 | var nnnn int
126 |
127 | func (wsSer *wsServer) send(ns *socketio.NameSpace, msgName string, data any, encode bool) {
128 | wsSer.mu.Lock()
129 |
130 | defer func(ns *socketio.NameSpace) {
131 | wsSer.mu.Unlock()
132 | if e := recover(); e != nil {
133 | log.Println("ws_send failed", e, ns.Session.Request.RemoteAddr, "msgName:", msgName, "client:", len(wsSer.clients))
134 | wsSer.remove(ns.Id())
135 | }
136 | }(ns)
137 | var err error
138 | encode = false
139 | if encode {
140 | err = ns.Emit(msgName, dataEncode(data))
141 | } else {
142 | err = ns.Emit(msgName, data)
143 | }
144 | if err != nil {
145 | log.Println("emit_failed", msgName, err)
146 | }
147 | }
148 |
149 | func (wsSer *wsServer) broadcastReq(req *http.Request, reqCtx *requestCtx, data any) bool {
150 | wsSer.mu.RLock()
151 | defer wsSer.mu.RUnlock()
152 |
153 | hasSend := false
154 | for _, client := range wsSer.clients {
155 | if wsSer.proxySer.conf.SessionView == sessionViewIPOrUser && len(client.filterIP) == 0 && len(client.filterUser) == 0 {
156 | continue
157 | }
158 |
159 | if reqCtx.User.Name != "" && len(client.filterUser) < 1 {
160 | continue
161 | }
162 |
163 | if client.checkFilter(req, reqCtx) {
164 | go wsSer.send(client.ns, "req", data, true)
165 | hasSend = true
166 | }
167 | }
168 | return hasSend
169 | }
170 |
171 | func (wsSer *wsServer) broadcast(name string, data any, encode bool) {
172 | wsSer.mu.RLock()
173 | defer wsSer.mu.RUnlock()
174 | for _, client := range wsSer.clients {
175 | go wsSer.send(client.ns, name, data, encode)
176 | }
177 | }
178 |
--------------------------------------------------------------------------------
3 |
Useage
4 |1.Client（eg:phone）
5 |
6 | set wifi http proxy:
7 | proxy host ： {{.pproxy_host}}
8 | proxy port ： {{.pproxy_port}}
9 |
10 |
11 | android users can use proxyDroid to manager proxys
12 |
13 | 2.Server:user interface
14 |15 | visit Session List Page to view all the http request through this proxy. 16 | in the session filter form, all text input can use| to enter multiple conditions. 17 | eg user:,it mean user is a or b. 18 | you can use replay to replay a request. 19 |20 | 21 |
3.Modify Requests
22 |you can modify http request.GET、POST paramas and http headers.
23 | pproxy use javascript to achieve it:
24 |
25 | function rewrite(req){
26 | //you code start
27 | if(req.host=="www.baidu.com"){
28 | req.host="www.163.com"
29 | req.host_addr="127.0.0.0:81" // send req to 127.0.0.1:81
30 | form_get.add("a","a")
31 | //form_post.set("d","a")
32 | }
33 |
34 | // you code end
35 | return req
36 | }
37 |
38 | req object has these attributes(url=http://www.example.com/album/list?cid=126)：
39 |
40 | schema : http
41 | host : www.example.com
42 | port : 80
43 | path : /album/list
44 | get: {cid:[123]}
45 | post: {}
46 | username :
47 | password :
48 | method: GET
49 | form_get : {add:function(k,v){},set:function(k,v){},get:function(k){},len:function(){}}
50 | form_post : {add:function(k,v){},set:function(k,v){},get:function(k){},len:function(){}}
51 |
52 | host_addr: #the real host you wish，eg 127.0.0.1:3218
53 |
54 |
55 | 4.Modify Hosts
56 |57 | #all port 58 | news.baidu.com 127.0.0.1 59 | 60 | #only 81 port match 61 | news.baidu.com:81 127.0.0.1:82 62 | 63 | news.163.com 127.0.0.1:8080 64 |65 |