内网穿透反向隧道代理技术

admin

本文的主要目的是利用使 ssh 服务器（外网）通过客户端（内网）代理上网以及反向控制客户端（内网），不需要网络管理员权限，不需要 NAT。即可上网主机 A 位于内网，不可上网主机 B 位于外网，A 能直接访问 B，但 B 无法访问防火墙内的 A，这样 B 就可以使用 SSH 隧道访问 A 主机上的代理服务器上网。（估计有这种变态需求的人只存在于大学中）

1. B(210.77.*.*)---->(210.77.*.*)FW(192.168.0.*)|--->(192.168.0.*)A---->(192.168.0.*)FW(123.*.*.*)---->Internet
   
2. B(210.77.*.*)< ----(210.77.*.*)FW(192.168.0.*)-----(192.168.0.*)A<----(192.168.0.*)FW(123.*.*.*)<----Internet

复制代码

一、代理
首先在客户端上安装 socks 代理（HTTP 代理可以使用 Squid，同理）。socks 代理软件使用 Dante。Dante 的启动以及配置需要手动调整，下面是 Dante 的配置文件 /etc/sockd.conf:

1. compatibility:reuseaddr
   
2. internal:0.0.0.0 port = 1080
   
3. external:eth0
   
4. logoutput:/var/log/sockd/sockd
   
5. clientmethod:none
   
6. method:none
   
7. user.privileged:root
   
8. user.notprivileged:solrex
   
9. connecttimeout:60
   
10. iotimeout:86400
    
11. 
    
12. ## client access rules
    
13. client pass {
    
14. from: 127.0.0.1/0 port 1-65535 to: 0.0.0.0/0
    
15. log: connect disconnect
    
16. }
    
17. 
    
18. ## server operation access rules
    
19. #allow bind to ports greater than 1023
    
20. pass {
    
21.   from: 0.0.0.0/0 to: 0.0.0.0/0 port gt 1023
    
22.   command: bind bindreply udpassociate udpreply
    
23.   log: connect disconnect
    
24. }
    
25. 
    
26. pass {
    
27.   from: 0.0.0.0/0 to: 0.0.0.0/0 port 1-65535
    
28.   protocol: tcp udp
    
29.   log: connect disconnect
    
30. }
    
31. 
    
32. #allow outgoing connections (tcp and udp)
    
33. pass {
    
34.   from: 127.0.0.1/0 to: 0.0.0.0/0
    
35.   command: bind bindreply connect udpassociate udpreply
    
36.   log: connect disconnect
    
37. }
    
38. 
    
39. #allow replies to bind, and incoming udp packets
    
40. pass {
    
41.    from: 0.0.0.0/0 to: 0.0.0.0/0
    
42.    command: bind bindreply connect udpassociate udpreply
    
43.    log: connect error
    
44. }
    
45. 
    
46. #log the rest
    
47. block {
    
48.    from: 0.0.0.0/0 to: 0.0.0.0/0
    
49.    log: connect error
    
50. }

复制代码

下面是 Dante 的启动脚本 /etc/init.d/sockd：

1. #!/bin/sh
   
2. set -e
   
3. 
   
4. . /lib/lsb/init-functions
   
5. 
   
6. [ -f /usr/local/sbin/sockd ] || exit 0
   
7. 
   
8. [ ! -f /etc/sockd.conf ] && exit 1
   
9. SOCKD_CONF="-f /etc/sockd.conf"
   
10. 
    
11. SOCKD_OPTS="-D"
    
12. 
    
13. case "$1" in
    
14.   start)
    
15.     # Start daemons.
    
16.     log_daemon_msg "Starting Dante socks proxy server" "sockd"
    
17.     if start-stop-daemon --start --quiet --oknodo --pidfile /var/run/sockd.pid --exec /usr/local/sbin/sockd -- $SOCKD_OPTS; then
    
18.             log_end_msg 0
    
19.         else
    
20.             log_end_msg 1
    
21.         fi
    
22.     ;;
    
23.   stop)
    
24.     # Stop daemons.
    
25.     log_daemon_msg "Stoping Dante socks proxy server" "sockd"
    
26.         if start-stop-daemon --stop --quiet --oknodo --pidfile /var/run/sockd.pid; then
    
27.             log_end_msg 0
    
28.         else
    
29.             log_end_msg 1
    
30.         fi
    
31.         ;;
    
32.   restart)
    
33.     log_daemon_msg "Restarting Dante socks proxy server" "sockd"
    
34.         start-stop-daemon --stop --quiet --oknodo --retry 30 --pidfile /var/run/sockd.pid
    
35.         if start-stop-daemon --start --quiet --oknodo --pidfile /var/run/sockd.pid --exec /usr/local/sbin/sockd -- $SOCKD_OPTS; then
    
36.             log_end_msg 0
    
37.         else
    
38.             log_end_msg 1
    
39.         fi
    
40.         ;;
    
41.   *)
    
42.     log_action_msg "Usage: /etc/init.d/sockd {start|stop|restart}\n"
    
43.     exit 1
    
44. esac
    
45. 
    
46. exit 0

复制代码

二、ssh 服务器
服务器端 ssh 服务器最好采用 Openssh，Windows 下应该使用 Cygwin 运行 sshd，FreeSSHd 实践证明崩溃比较频繁。同一台机器的 Windows 和 Linux 上运行的 ssh 服务器最好使用相同的 host key，将 /etc/ssh/ 下面的文件保持一致即可。最好配置服务器为使用公钥进行登录验证，这样能使用自动脚本进行端口映射。
三、手动建立隧道（客户端到服务器端口映射）
用下面命令建立客户端到服务器的端口映射，将客户端的 socks 代理端口 1080 映射到服务器的端口 8080。这样服务器就可以通过自己的 8080 端口反向隧道到客户端的 socks 代理 1080 端口上网。
ssh -C -f -N -g -o PreferredAuthentications=publickey -R SERVER:8080:127.0.0.1:1080 USRNAME@SERVER
# 参数含义：
# -C: 要求对数据进行压缩
# -f：要求 ssh 执行完交互后进入后台运行
# -N：不用建立一个终端
# -g：允许远程服务器连接客户端转发端口
# -R SERVER:8080:127.0.0.1:1080：将客户机(127.0.0.1)的 1080 端口绑定到服务器(SERVER)的 8080 端口。
# USRNAME@SERVER：ssh服务器的用户名和密码
# -p 3022：ssh服务器的端口
为了方便控制，最好也将客户端的 ssh 服务器端口映射到服务器端，服务器端就可以通过登录自己的 8022 端口来登录客户端的 ssh 服务器：

1. ssh -C -f -N -g -o PreferredAuthentications=publickey -R SERVER:8022:127.0.0.1:22 USRNAME@SERVER

复制代码

这样两台被防火墙隔开的主机就能实现双向控制。
四、自动建立隧道
手动建立隧道的缺陷是服务器端必须长期开机，并且连接只能用户在客户端手动发起。可以考虑间接的办法，比如使用两台主机均可访问的服务器作为跳板，或者客户端自动登录聊天软件，利用聊天软件接受指令。下面给出一种使用共享服务器的方法：

1. #!/bin/bash
   
2. # {start|stop|restart:username:ipaddress}
   
3. 
   
4. COMMAND="stop"
   
5. SERVER="0.0.0.0"
   
6. USRNAME=""
   
7. PORT="22"
   
8. 
   
9. INFOURL="http://someserver.com/somepage"
   
10. 
    
11. SSHOPTS="-C -f -N -g -o PreferredAuthentications=publickey -o StrictHostKeyChecking=no"
    
12. 
    
13. get_server_info()
    
14. {
    
15.   #info=`wget -nv -O - $INFOURL 2> /dev/null | iconv -f gbk -t utf8 |
    
16.         grep -o -e "{.*}" | tr -d '{}'`
    
17.   info=`wget -nv -O - $INFOURL 2> /dev/null | iconv -f gbk -t utf8 |
    
18.         sed -n "/{*}/s/.*{\(.*\)}.*/\1/p"`
    
19.   COMMAND=${info%%:*}
    
20.   SERVER=${info#*:}
    
21.   USRNAME=${SERVER%:*}
    
22.   SERVER=${SERVER#*:}
    
23. }
    
24. 
    
25. tunneling_status()
    
26. {
    
27.   tun_ps=`ps aux | grep "ssh -C" | wc -l`
    
28.   if [ $tun_ps -gt 4 ]; then
    
29.     echo -n "running"
    
30.   else
    
31.     echo -n "died"
    
32.   fi
    
33. }
    
34. 
    
35. start_tunneling()
    
36. {
    
37.   ssh $SSHOPTS -R 3128:127.0.0.1:3128 ${USRNAME}@${SERVER} -p $PORT
    
38.   ssh $SSHOPTS -R 8022:127.0.0.1:22 ${USRNAME}@${SERVER} -p $PORT
    
39. }
    
40. 
    
41. failsafe_tunneling()
    
42. {
    
43.   ssh $SSHOPTS -R 8022:127.0.0.1:22 ${USRNAME}@${SERVER} -p $PORT
    
44. }
    
45. 
    
46. stop_tunneling()
    
47. {
    
48.   killall -e ssh
    
49. }
    
50. 
    
51. echo -n "[`date +%F\ %R`] "
    
52. get_server_info
    
53. 
    
54. case "$COMMAND" in
    
55.   start)
    
56.     if [ $(tunneling_status) = "running" ]; then
    
57.       echo "Starting ssh tunneling.(started, do nothing)"
    
58.     else
    
59.       echo "Starting ssh tunneling."
    
60.       start_tunneling
    
61.     fi
    
62.     ;;
    
63.   restart)
    
64.     if [ $(tunneling_status) = "running" ]; then
    
65.       echo "Restarting ssh tunneling."
    
66.       stop_tunneling
    
67.       start_tunneling
    
68.     else
    
69.       echo "Restarting ssh tunneling."
    
70.       start_tunneling
    
71.     fi
    
72.     ;;
    
73.   stop)
    
74.     if [ $(tunneling_status) = "running" ]; then
    
75.       echo "Stoping ssh tunneling."
    
76.       stop_tunneling
    
77.     else
    
78.       echo "Stoping ssh tunneling.(stoped, do nothing)"
    
79.     fi
    
80.     ;;
    
81.   failsafe)
    
82.     echo "Starging ssh tunneling.(failsafe mode)"
    
83.     failsafe_tunneling
    
84.     ;;
    
85.   sleep)
    
86.     echo "Sleeping."
    
87.     exit 0
    
88.     ;;
    
89.   *)
    
90.     echo "Unrecogenized server command ($COMMAND)."
    
91.     exit 1
    
92.     ;;
    
93. esac
    
94. 
    
95. exit 0

复制代码

将上面脚本加入 crontab 每十分钟运行一次，就能实现在服务器端对客户端进行有限的控制。

帮帮顶顶！！

我是个凑数的。。。