关于finalshell的使用

常见的作用：

一，连接虚拟机

二，ssh加密隧道

一，先说连接虚拟机：

我这里说一个大致的流程：

首先看清楚自己是那一种连接方式

1，NAT

2.,NAT网络

3，桥

4，仅主机

首先我们要了解不同连接模式的不同，可以去看B站的技术蛋，重要的点简单来说，NAT连接：自己和虚拟机的连接关系像公网和局域网的关系，我们无法直接访问NAT连接的虚拟机，我们只能访问到虚拟机那个网络下的网关，这里就是本机，所以就是127.0.0.1，NAT网络是指虚拟机之间也可以直接互相ping，桥连接是相当于和你的电脑一样给他分配进局域网了，仅主机就是只有虚拟机和主机之间可以通信

这下面是千问的解释：

就像你直接利用windows的自带的ssh连接linux一样

ssh -p 2222 liptga@127.0.0.1

所以桥因该是这样

二，隧道加密：

三种SSH隧道的完整角色分解

我们定义三个角色：

你的电脑（本地）：运行 FinalShell 的机器
SSH 跳板机：你有 SSH 权限的中间服务器
目标设备：真正提供服务的机器（可能是跳板机本身，也可能是跳板机内网的其他机器）

一、本地隧道（Local Port Forwarding）

核心目标：让你的电脑能访问"跳板机后面"的服务

角色职责表

表格

角色	需要监听的端口	需要开启的服务	连接的目标
你的电脑（本地）	监听一个本地端口（如 `127.0.0.1:3306`）	无（只是监听转发）	本地程序连接这个端口
SSH 跳板机	无（只是转发通道）	必须运行 SSH 服务（端口 22）	接收 SSH 连接，转发流量
目标设备	监听目标服务端口（如 `3306`）	运行目标服务（如 MySQL）	跳板机向它发起连接

数据流向详解

复制代码

1┌─────────────────────────────────────────────────────────────────┐
2│                        你的电脑（本地）                          │
3│                                                                 │
4│  本地程序（Navicat）                                            │
5│        ↓                                                        │
6│  连接 127.0.0.1:3306  ←─┐                                      │
7│        ↓                 │                                      │
8│  [本地监听端口 3306]     │  ←─ FinalShell 在此监听              │
9│        ↓                 │                                      │
10│  [SSH 隧道加密] ─────────┘                                      │
11│        ↓                                                        │
12│  通过 SSH 连接发送到跳板机（端口 22）                           │
13└─────────────────────────────────────────────────────────────────┘
14                              ↓
15┌─────────────────────────────────────────────────────────────────┐
16│                        SSH 跳板机                                │
17│                                                                 │
18│  [SSH 服务] 接收加密流量（端口 22）                             │
19│        ↓                                                        │
20│  [SSH 服务] 解密流量                                            │
21│        ↓                                                        │
22│  [SSH 服务] 向目标设备发起 TCP 连接：10.0.0.5:3306              │
23└─────────────────────────────────────────────────────────────────┘
24                              ↓
25┌─────────────────────────────────────────────────────────────────┐
26│                        目标设备                                  │
27│                                                                 │
28│  [MySQL 服务] 监听 3306 端口                                    │
29│        ↓                                                        │
30│  接收请求 → 处理 → 返回数据                                     │
31└─────────────────────────────────────────────────────────────────┘

配置参数对应关系（FinalShell）

表格

配置项	填写值	对应哪个角色的哪个端口？
本地端口	`3306`	你的电脑监听的端口
目标主机	`10.0.0.5`	目标设备的 IP（从跳板机视角看）
目标端口	`3306`	目标设备上服务监听的端口
SSH 主机	`203.0.113.10`	跳板机的公网 IP
SSH 端口	`22`	跳板机上 SSH 服务监听的端口

关键要点

谁监听 ：你的电脑监听本地端口（如 127.0.0.1:3306）
谁提供服务：目标设备运行着真实服务（如 MySQL）
跳板机角色：纯转发通道，不需要运行目标服务
连接目标 ：本地程序连接 127.0.0.1:3306，但实际访问的是 10.0.0.5:3306

二、远程隧道（Remote Port Forwarding）

核心目标：让外网能访问"你电脑上"的服务

角色职责表

表格

角色	需要监听的端口	需要开启的服务	连接的目标
你的电脑（本地）	监听本地服务端口（如 `127.0.0.1:5000`）	运行本地服务（如 Flask Web）	跳板机通过隧道连接到此端口
SSH 跳板机	监听一个远程端口（如 `203.0.113.10:8080`）	必须运行 SSH 服务（端口 22）	外网用户连接这个端口
目标设备	无（这里目标设备就是你的电脑）	无	---

注意：远程隧道中，你的电脑就是目标设备，没有第三个独立的目标设备。

数据流向详解

复制代码

1┌─────────────────────────────────────────────────────────────────┐
2│                        外网用户                                  │
3│                                                                 │
4│  浏览器访问 http://203.0.113.10:8080                            │
5└─────────────────────────────────────────────────────────────────┘
6                              ↓
7┌─────────────────────────────────────────────────────────────────┐
8│                        SSH 跳板机                                │
9│                                                                 │
10│  [监听端口 8080] ←─ 外网请求到达                                │
11│        ↓                                                        │
12│  [SSH 服务] 接收到 8080 端口的请求                              │
13│        ↓                                                        │
14│  [SSH 隧道加密] 将请求转发给你的电脑（通过已建立的 SSH 连接）   │
15└─────────────────────────────────────────────────────────────────┘
16                              ↓
17┌─────────────────────────────────────────────────────────────────┐
18│                        你的电脑（本地）                          │
19│                                                                 │
20│  [SSH 隧道] 接收加密流量                                        │
21│        ↓                                                        │
22│  [SSH 隧道] 解密流量                                            │
23│        ↓                                                        │
24│  [SSH 隧道] 向本地服务发起连接：127.0.0.1:5000                  │
25│        ↓                                                        │
26│  [Flask 服务] 监听 5000 端口                                    │
27│        ↓                                                        │
28│  接收请求 → 处理 → 返回数据                                     │
29│        ↓                                                        │
30│  数据原路返回：Flask → SSH 隧道 → 跳板机 → 外网用户             │
31└─────────────────────────────────────────────────────────────────┘

配置参数对应关系（FinalShell）

表格

配置项	填写值	对应哪个角色的哪个端口？
远程端口	`8080`	跳板机监听的端口（外网访问点）
目标主机	`127.0.0.1`	你的电脑上的本地地址
目标端口	`5000`	你的电脑上本地服务监听的端口
SSH 主机	`203.0.113.10`	跳板机的公网 IP
SSH 端口	`22`	跳板机上 SSH 服务监听的端口

关键要点

谁监听 ：跳板机监听远程端口（如 203.0.113.10:8080）
谁提供服务：你的电脑运行着本地服务（如 Flask）
跳板机角色：接收外网请求并转发到你的电脑
连接目标 ：外网用户连接 203.0.113.10:8080，但实际访问的是 你的电脑:5000

重要补充：跳板机的 SSH 配置

默认情况下，跳板机上建立的远程隧道只能被跳板机本机访问 （绑定到 127.0.0.1:8080），外网无法访问。

要让外网能访问，需要在跳板机的 /etc/ssh/sshd_config 中添加：

bash

复制代码

1GatewayPorts yes

然后重启 SSH 服务：

bash

复制代码

1sudo systemctl restart sshd

这样远程隧道监听的端口会绑定到 0.0.0.0:8080，外网才能访问。

三、动态隧道（Dynamic Port Forwarding / SOCKS Proxy）

核心目标：创建一个加密的 SOCKS 代理，让你的流量经跳板机转发到任意公网

角色职责表

表格

角色	需要监听的端口	需要开启的服务	连接的目标
你的电脑（本地）	监听 SOCKS 代理端口（如 `127.0.0.1:1080`）	无（只是 SOCKS 代理）	本地程序连接这个 SOCKS 代理
SSH 跳板机	无（动态决定目标）	必须运行 SSH 服务（端口 22）必须能访问公网	接收 SOCKS 请求，动态连接任意公网目标
目标设备	任意公网服务的端口（如 `google.com:443`）	任意公网服务（如 HTTPS 网站）	跳板机根据 SOCKS 协议动态连接

数据流向详解

复制代码

1┌─────────────────────────────────────────────────────────────────┐
2│                        你的电脑（本地）                          │
3│                                                                 │
4│  浏览器设置代理：SOCKS5 127.0.0.1:1080                          │
5│        ↓                                                        │
6│  访问 https://google.com                                        │
7│        ↓                                                        │
8│  [SOCKS 代理 1080] 接收请求                                     │
9│        ↓                                                        │
10│  [SOCKS 协议] 告诉代理："我要连 google.com:443"                 │
11│        ↓                                                        │
12│  [SSH 隧道加密] 将请求发送到跳板机                              │
13└─────────────────────────────────────────────────────────────────┘
14                              ↓
15┌─────────────────────────────────────────────────────────────────┐
16│                        SSH 跳板机                                │
17│                                                                 │
18│  [SSH 服务] 接收加密流量（端口 22）                             │
19│        ↓                                                        │
20│  [SSH 服务] 解密流量                                            │
21│        ↓                                                        │
22│  [SSH 服务] 解析 SOCKS 请求："目标是 google.com:443"            │
23│        ↓                                                        │
24│  [SSH 服务] 直接向 google.com:443 发起 TCP 连接                 │
25└─────────────────────────────────────────────────────────────────┘
26                              ↓
27┌─────────────────────────────────────────────────────────────────┐
28│                        公网目标（google.com）                    │
29│                                                                 │
30│  [HTTPS 服务] 监听 443 端口                                     │
31│        ↓                                                        │
32│  接收请求 → 处理 → 返回数据                                     │
33│        ↓                                                        │
34│  数据原路返回：Google → 跳板机 → SSH 隧道 → 你的电脑 → 浏览器   │
35└─────────────────────────────────────────────────────────────────┘

📝 配置参数对应关系（FinalShell）

表格

配置项	填写值	对应哪个角色的哪个端口？
本地端口	`1080`	你的电脑监听的 SOCKS 代理端口
SSH 主机	`203.0.113.10`	跳板机的公网 IP
SSH 端口	`22`	跳板机上 SSH 服务监听的端口

📌 动态隧道没有"目标主机"和"目标端口"，因为目标是动态的，由 SOCKS 客户端（如浏览器）在运行时指定。

关键要点

谁监听 ：你的电脑监听 SOCKS 代理端口（如 127.0.0.1:1080）
谁提供服务：公网上的任意服务（如 Google、GitHub）
跳板机角色：既是 SSH 服务端，也是 SOCKS 代理的"出口"，直接连接公网目标
连接目标 ：本地程序连接 127.0.0.1:1080（SOCKS 代理），但实际访问的是任意公网服务

三种隧道终极对比表

表格

特性	本地隧道	远程隧道	动态隧道
核心目的	访问跳板机后面的内网服务	暴露本地服务给外网	创建加密的全局代理
谁监听端口	你的电脑监听本地端口	跳板机监听远程端口	你的电脑监听 SOCKS 端口
谁提供服务	目标设备（内网）	你的电脑（本地）	公网任意服务
跳板机角色	纯转发通道	接收外网请求并转发	SOCKS 代理出口
目标是否固定	是（配置时指定）	是（配置时指定）	否（运行时动态决定）
典型场景	访问内网 MySQL/Redis	内网穿透、调试回调	科学上网、安全代理
FinalShell 配置	隧道 → 本地需填：本地端口、目标主机、目标端口	隧道 → 远程需填：远程端口、目标主机、目标端口	隧道 → 动态只需填：本地端口
数据流向	本地 → 跳板机 → 目标设备	外网 → 跳板机 → 本地	本地 → 跳板机 → 任意公网

一句话总结

本地隧道 ：你监听端口，访问内网服务
远程隧道 ：跳板机 监听端口，暴露你的服务
动态隧道 ：你监听 SOCKS 端口，访问任意公网

其实，简短来说原理就是，因为和你直连的是ssh所以，只需要监听一个ssh的映射端口，ssh看不同的作用，如果是访问别人就不用建立端口，但是如果当作服务器来接受，就需要监听被访问呢的端口，然后要注意跳板机也就是ssh加密的必须和你要访问的是在同意个网络范围里（核心目的局就是因为你的电脑和要访问不在一个访问的网络范围，但是跳板机在）

不知道说的清楚u不清楚，之后我们大概可以知道流程，但是如果你还有问题，为啥需要sock，或者跳板机如何连接，请接着往下看：

SOCKS 是啥，干嘛用的？

什么是 SOCKS？

SOCKS （Socket Secure）是一种网络代理协议，用于在客户端和服务器之间建立一个中间代理层，让客户端通过代理访问目标服务器。

与 HTTP 代理的区别

表格

特性	HTTP 代理	SOCKS 代理
协议层级	应用层（只能代理 HTTP/HTTPS）	会话层（可代理任意 TCP/UDP 流量）
支持的协议	HTTP、HTTPS	TCP、UDP（SOCKS5）、FTP、SMTP、游戏、P2P 等
是否解析内容	是（可以看到 HTTP 请求内容）	否（只转发原始字节流，不解析内容）
速度	较慢（需要解析 HTTP 协议）	较快（直接转发）
适用场景	浏览网页	全局代理、游戏、P2P、任意网络应用

SOCKS 的工作原理

复制代码

1你的电脑 (客户端)
2    ↓
3连接 SOCKS 代理 (如 127.0.0.1:1080)
4    ↓
5发送请求："我要连接 google.com:443"
6    ↓
7SOCKS 代理收到请求
8    ↓
9代理直接连接 google.com:443
10    ↓
11建立连接后，代理在客户端和目标之间转发数据

为什么动态隧道要用 SOCKS？

在 动态隧道（Dynamic Port Forwarding） 中：

目标不固定 ：你可能访问 google.com，也可能访问 github.com，还可能访问 stackoverflow.com...
需要通用协议：如果用本地隧道，你需要为每个网站配置一个端口映射，非常麻烦
SOCKS 的优势 ：
- 客户端在运行时告诉代理"我要访问哪个地址"
- 代理动态建立连接
- 一个代理端口搞定所有网站

实际使用示例

在浏览器中使用 SOCKS 代理

Chrome + SwitchyOmega 插件：

安装 SwitchyOmega
新建情景模式 → 代理协议选 SOCKS5
代理服务器：127.0.0.1
代理端口：1080
启用该情景模式

结果：你访问的所有网站流量都经过 SSH 隧道，出口 IP 是跳板机的公网 IP。

在系统中全局使用 SOCKS 代理

Windows：

设置 → 网络和 Internet → 代理 → 手动设置代理
地址：127.0.0.1，端口：1080
类型：SOCKS

macOS：

系统偏好设置 → 网络 → 高级 → 代理
勾选 SOCKS 代理
地址：127.0.0.1，端口：1080

Linux：

bash

复制代码

1export ALL_PROXY=socks5://127.0.0.1:1080

SOCKS 的典型应用场景

表格

场景	说明
科学上网	通过国外跳板机访问被限制的网站
公共 Wi-Fi 安全	在咖啡厅等公共网络下，所有流量加密
访问地区限制内容	让跳板机的 IP 作为出口，绕过地区限制
游戏加速	通过优化线路的跳板机降低延迟
P2P 下载	隐藏真实 IP，保护隐私

一句话总结

SOCKS 是一种通用的代理协议，动态隧道使用它是因为目标地址不固定，需要一个能在运行时动态决定连接目标的代理机制。

问题三：如何用 SSH 连接到跳板机，需要什么？

连接 SSH 跳板机的必备要素

要通过 SSH 连接到跳板机，你需要以下信息：

跳板机的网络地址

表格

项目	说明	示例
主机名 / IP 地址	跳板机的公网地址	`203.0.113.10` 或 `jump.example.com`
SSH 端口	跳板机上 SSH 服务监听的端口	`22`（默认），如果改过可能是 `2222`、`60022` 等

⚠️ 注意：跳板机必须有公网 IP 或可通过公网访问的域名，否则你无法从外网连接。

认证凭证（二选一）

方式一：密码认证（简单但安全性较低）

表格

项目	说明	示例
用户名	跳板机上的系统用户	`root`、`ubuntu`、`admin`
密码	该用户的登录密码	`your_password`

优点：配置简单
缺点：容易被暴力破解，不推荐生产环境使用

方式二：密钥认证（推荐，安全性高）

表格

项目	说明	示例
用户名	跳板机上的系统用户	`root`、`ubuntu`
私钥文件	本地保存的私钥文件	`~/.ssh/id_rsa` 或 `id_rsa.pem`

工作原理：

你生成一对密钥：公钥（public key）和私钥（private key）
把公钥上传到跳板机的 ~/.ssh/authorized_keys 文件中
连接时，SSH 客户端用私钥签名，跳板机用公钥验证
验证通过即可登录，无需密码

优点：

安全性极高（私钥不会在网络上传输）
可以实现免密登录
可以设置私钥密码（passphrase）二次保护

缺点：配置稍复杂

FinalShell 中的配置步骤

方法一：密码认证

打开 FinalShell
点击左上角 + → 选择 "SSH 连接"
填写以下信息：
- 名称：JumpServer（自定义，方便识别）
- 主机：203.0.113.10（跳板机公网 IP）
- 端口：22（或跳板机的 SSH 端口）
- 用户名 ：root（或跳板机上的用户名）
- 认证方式 ：选择 "密码"
- 密码：输入跳板机用户的密码
点击 "测试连接" 验证配置是否正确
点击 "确定" 保存

方法二：密钥认证

打开 FinalShell
点击左上角 + → 选择 "SSH 连接"
填写以下信息：
- 名称：JumpServer
- 主机：203.0.113.10
- 端口：22
- 用户名 ：root
- 认证方式 ：选择 "私钥"
- 私钥文件 ：点击 "浏览" 选择你的私钥文件（如 id_rsa.pem）
- 私钥密码：如果私钥有密码，输入密码
点击 "测试连接"
点击 "确定" 保存

连接流程详解

文本

复制代码

1┌─────────────────────────────────────────────────────────────┐
2│                    你的电脑（运行 FinalShell）               │
3│                                                             │
4│  1. FinalShell 发起 TCP 连接                                │
5│     目标：203.0.113.10:22                                   │
6└─────────────────────────────────────────────────────────────┘
7                            ↓
8┌─────────────────────────────────────────────────────────────┐
9│                    跳板机                                    │
10│                                                             │
11│  2. 跳板机的 SSH 服务（sshd）监听 22 端口                   │
12│     接收到连接请求                                          │
13│                                                             │
14│  3. 双方协商加密算法、协议版本等                            │
15│                                                             │
16│  4. 跳板机发送自己的公钥给 FinalShell                       │
17│                                                             │
18│  5. FinalShell 验证跳板机身份（防止中间人攻击）             │
19│     - 首次连接会提示："是否信任此主机？"                    │
20│     - 选择"是"后，跳板机公钥会保存到本地                    │
21│                                                             │
22│  6. 认证阶段：                                              │
23│     ┌─────────────────────────────────────────────────┐    │
24│     │ 密码认证：                                          │    │
25│     │   - FinalShell 发送用户名 + 密码（加密传输）         │    │
26│     │   - 跳板机验证密码是否正确                          │    │
27│     │   - 验证通过 → 建立会话                             │    │
28│     │                                                     │    │
29│     │ 密钥认证：                                          │    │
30│     │   - FinalShell 发送用户名                           │    │
31│     │   - 跳板机查找该用户的 authorized_keys              │    │
32│     │   - 跳板机发送一个随机挑战（challenge）              │    │
33│     │   - FinalShell 用私钥签名挑战并返回                 │    │
34│     │   - 跳板机用公钥验证签名                            │    │
35│     │   - 验证通过 → 建立会话                             │    │
36│     └─────────────────────────────────────────────────┘    │
37│                                                             │
38│  7. 会话建立成功                                            │
39│     - FinalShell 打开终端窗口                               │
40│     - 你可以执行命令、传输文件等                            │
41└─────────────────────────────────────────────────────────────┘

常见问题和注意事项

表格

问题	原因	解决方法
连接超时	跳板机防火墙未开放 22 端口	联系管理员开放端口
连接被拒绝	跳板机未运行 SSH 服务	检查 `systemctl status sshd`
认证失败	用户名/密码错误或私钥不匹配	检查凭证是否正确
主机密钥变更	跳板机重装系统或更换 SSH 密钥	删除本地已知主机记录重新连接
权限被拒绝	用户无 SSH 登录权限	检查 `/etc/ssh/sshd_config` 中的 `AllowUsers`

检查清单：连接前确认

在尝试连接之前，请确认以下信息：

跳板机有公网 IP 或可访问的域名
跳板机的 SSH 端口（通常是 22）已开放
你有跳板机的用户名
你有正确的认证方式（密码或私钥文件）
你的网络可以访问跳板机（没有防火墙拦截）
跳板机的 SSH 服务正在运行

一句话总结

用 SSH 连接跳板机，你需要：跳板机的公网地址和端口 + 用户名 + 认证凭证（密码或私钥）。在 FinalShell 中配置这些信息，点击连接即可。

总结

表格

问题	核心答案
本地程序连接本地端口是干啥的？	让本地程序透明地访问远程内网服务，程序以为在访问本地服务
SOCKS 是啥？	一种通用代理协议，动态隧道用它是因为目标地址不固定，需要运行时动态决定连接目标
如何用 SSH 连接跳板机？	需要：跳板机公网地址 + 端口 + 用户名 + 认证凭证（密码/私钥）