1. VPS - SSH蜜罐搭建
   1. 工作动机
      1. 背景
      2. 查看日志情况
         1. auth.log文件介绍
         2. 查看auth.log文件内容
            1. 使用grep命令筛选SSH失败连接
            2. 使用python脚本处理日志数据
      3. 为什么要搭建蜜罐
         1. 可能的解决办法
         2. 为什么要搭建蜜罐
   2. 蜜罐搭建
      1. 工作准备
      2. 编辑docker-compose.yml
      3. 编辑cowire配置
      4. 使用docker-compose构建并启动容器
      5. 配置MySQL数据库
      6. 重新配置端口
         1. 修改SSH配置文件以启用新的端口
         2. 配置iptables进行端口重定向
      7. 效果
   3. 参考文档

VPS - SSH蜜罐搭建

工作动机

背景

我的服务器22端口对所有IP开放，任何IP都可以连接到我的SSH服务。

服务器的系统为 Ubuntu

查看日志情况

在查看日志时发现有许多连接失败的尝试，表明我的VPS受到了SSH暴力破解攻击。

auth.log文件介绍

auth.log 文件是Linux系统中用于记录身份验证相关事件的日志文件。它包含系统启动、登录尝试、成功和失败的身份验证事件以及SSH连接尝试等信息。

该文件位于/var/log/目录下。

1
2
3
4
5

$ ls /var/log/
alternatives.log  auth.log.1     chrony                 dmesg     kern.log       lastlog   syslog.2.gz
apache2           auth.log.2.gz  cloud-init-output.log  dmesg.0   kern.log.1     private   unattended-upgrades
apt               azure          cloud-init.log         dpkg.log  kern.log.2.gz  syslog    waagent.log
auth.log          btmp           dist-upgrade           journal   landscape      syslog.1  wtmp

查看auth.log文件内容

通过查看 auth.log 文件中的内容，可以了解系统的登录活动，尤其是识别出失败的登录尝试，可能是恶意攻击的迹象。

auth.log文件中可能包含以下格式的数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Jul 26 07:08:12 Azure-jay1an SSHd[130241]: Failed password for root from 119.202.128.28 port 33216 SSH2
Jul 26 07:09:01 Azure-jay1an SSHd[130247]: Failed password for invalid user testuser from 119.202.128.28 port 50334 SSH2
Jul 26 07:10:07 Azure-jay1an SSHd[130255]: Accepted password for user from 192.168.1.2 port 52326 SSH2
Jul 26 07:11:30 Azure-jay1an SSHd[130274]: Accepted publickey for admin from 203.0.113.42 port 51422 SSH2: RSA SHA256:...
Jul 26 07:12:22 Azure-jay1an SSHd[130284]: Failed publickey for root from 203.0.113.57 port 58231 SSH2: RSA SHA256:...
Jul 26 07:13:45 Azure-jay1an SSHd[130297]: Connection closed by 192.168.1.3 port 51130 [preauth]
Jul 26 07:14:11 Azure-jay1an SSHd[130308]: pam_unix(SSHd:session): session opened for user root by (uid=0)
Jul 26 07:15:09 Azure-jay1an SSHd[130318]: pam_unix(SSHd:session): session closed for user root
Jul 26 07:16:47 Azure-jay1an SSHd[130330]: Received disconnect from 198.51.100.14 port 53332:11: disconnected by user
Jul 26 07:17:33 Azure-jay1an SSHd[130338]: Received signal 15; terminating.
Jul 26 07:18:05 Azure-jay1an sudo: pam_unix(sudo:session): session opened for user root by someuser(uid=1000)
Jul 26 07:18:32 Azure-jay1an sudo: someuser : TTY=pts/1 ; PWD=/home/someuser ; USER=root ; COMMAND=/bin/ls
Jul 26 07:19:07 Azure-jay1an sudo: pam_unix(sudo:session): session closed for user root
Jul 26 07:20:01 Azure-jay1an CRON[130350]: pam_unix(cron:session): session opened for user root by (uid=0)
Jul 26 07:21:05 Azure-jay1an CRON[130350]: pam_unix(cron:session): session closed for user root
Jul 26 07:21:45 Azure-jay1an SSHd[130360]: Invalid user guest from 198.51.100.7 port 60934
Jul 26 07:22:23 Azure-jay1an SSHd[130362]: Failed keyboard-interactive/pam for invalid user guest from 198.51.100.7 port 60934 SSH2
Jul 26 07:23:11 Azure-jay1an su[130374]: pam_unix(su:session): session opened for user root by someuser(uid=1000)
Jul 26 07:24:09 Azure-jay1an su[130374]: pam_unix(su:session): session closed for user root
Jul 26 07:25:10 Azure-jay1an gnome-keyring-daemon[130390]: The SSH agent was already initialized

每一条记录通常都包含以下几个部分：

日期和时间：日志条目生成的日期和时间。

主机名：日志生成的计算机名称。

服务名和进程ID：产生日志的服务名称和进程ID。

消息内容：描述事件的详细信息。

示例：

1

Jul 26 07:08:12 Azure-jay1an SSHd[130241]: Failed password for root from 119.202.128.28 port 33216 SSH2

Jul 26 07:08:12：日期和时间

Azure-jay1an：主机名

SSHd[130247] ：服务名 SSHd 和进程ID 130241

Failed password for root from 119.202.128.28 port 33216 SSH2：消息内容，表示119.202.128.28主机使用root账号登陆失败。

使用grep命令筛选SSH失败连接

可以使用grep命令筛选出通过SSH所有失败的连接尝试记录。

1

grep 'SSHd.*Failed password' /var/log/auth.log

运行该命令后，终端打印出很多的信息，表明有很多主机都在尝试暴力破解我的SSH服务。

一部分记录如下：

1
2
3
4
5
6
7
8
9
10

Jul 26 07:13:07 Azure-jay1an SSHd[130272]: Failed password for invalid user devops from 187.251.123.99 port 35058 SSH2
Jul 26 07:14:02 Azure-jay1an SSHd[130274]: Failed password for root from 187.251.123.99 port 54888 SSH2
Jul 26 07:21:20 Azure-jay1an SSHd[130286]: Failed password for invalid user admin from 111.70.9.148 port 60815 SSH2
Jul 26 07:23:37 Azure-jay1an SSHd[130293]: Failed password for invalid user admin from 208.48.253.178 port 58872 SSH2
Jul 26 07:23:43 Azure-jay1an SSHd[130297]: Failed password for invalid user admin from 60.167.19.30 port 59719 SSH2
Jul 26 07:30:10 Azure-jay1an SSHd[131231]: Failed password for invalid user config from 116.235.180.116 port 48617 SSH2
Jul 26 07:37:17 Azure-jay1an SSHd[131251]: Failed password for invalid user user from 118.218.209.149 port 52664 SSH2
Jul 26 07:37:21 Azure-jay1an SSHd[131253]: Failed password for root from 104.248.129.160 port 44810 SSH2
Jul 26 07:37:52 Azure-jay1an SSHd[131259]: Failed password for invalid user admin from 223.197.199.52 port 44007 SSH2
Jul 27 09:58:27 Azure-jay1an SSHd[136025]: Failed password for root from 110.191.181.36 port 53809 SSH2

使用python脚本处理日志数据

本想使用awk命令提取出IP地址，并作一些简单的统计，但是日志里的信息格式并不是特别统一，为了方便起见，还是使用python脚本处理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

import re
import requests
import time
import json
import random
from collections import defaultdict

# 初始化字典
user_attempts = defaultdict(int)
ip_attempts = defaultdict(int)
ip_cache = {}

# 正则表达式模式
user_pattern = re.compile(r'Failed password for (invalid user )?(\w+)')
ip_pattern = re.compile(r'from ([\d\.]+)')

# 读取auth.log文件
with open('/var/log/auth.log', 'r') as file:
    for line in file:
        # 查找用户名
        user_match = user_pattern.search(line)
        if user_match:
            user = user_match.group(2)
            user_attempts[user] += 1
        
        # 查找IP地址
        ip_match = ip_pattern.search(line)
        if ip_match:
            ip = ip_match.group(1)
            ip_attempts[ip] += 1

# 从文件加载缓存的IP位置信息
def load_ip_cache(filename='ip_cache.json'):
    global ip_cache
    try:
        with open(filename, 'r') as f:
            ip_cache = json.load(f)
    except FileNotFoundError:
        ip_cache = {}

# 将IP位置信息缓存到文件
def save_ip_cache(filename='ip_cache.json'):
    with open(filename, 'w') as f:
        json.dump(ip_cache, f)

# 查询IP地址的地理位置信息
def get_ip_location(ip):
    if ip in ip_cache:
        return ip_cache[ip]
    response = requests.get(f"https://ipinfo.io/{ip}/json")
    time.sleep(random.uniform(0.3, 1))  # 添加随机请求间隔，避免频繁访问API
    if response.status_code == 200:
        ip_cache[ip] = response.json()
        return ip_cache[ip]
    return {}

# 加载IP缓存
load_ip_cache()

# 打印用户名尝试次数
print("用户名尝试次数:")
for user, count in sorted(user_attempts.items(), key=lambda item: item[1], reverse=True):
    print(f"{user}: {count}")

print("\nIP尝试次数和地理位置:")

# 打印IP尝试次数，并获取地理位置信息
for ip, count in sorted(ip_attempts.items(), key=lambda item: item[1], reverse=True):
    if count > 50:
        location_info = get_ip_location(ip)
        location = location_info.get("city", "Unknown city") + ", " + location_info.get("region", "Unknown region") + ", " + location_info.get("country", "Unknown country")
        print(f"{ip}: {count} 次尝试 - 位置: {location}")
    else:
        print(f"{ip}: {count} 次尝试")

# 保存IP缓存
save_ip_cache()

该脚本由ChatGPT生成，可以统计哪些用户名被尝试了，失败了多少次；哪些IP尝试了，失败了多少次。同时，使用网络上的现成API查询IP地址的地理位置。为了避免对API频繁的请求以及避免被识别成爬虫，还设计了简单的IP缓存并在每一次请求间隔加上随机延时。

脚本的运行结果（简略版）如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

$ python3 SSH_login_attempts.py
用户名尝试次数:
root: 20563
admin: 929
ubuntu: 487
user: 451
test: 424
ftpuser: 282
oracle: 266
debian: 194
test1: 146
ubnt: 134
usuario: 134
test2: 123
postgres: 122
deploy: 96
git: 96
pi: 93
dev: 75
guest: 75
...
IP尝试次数和地理位置:
185.133.250.70: 5837 次尝试 - 位置: Frankfurt am Main, Hesse, DE
111.10.36.20: 2565 次尝试 - 位置: Chongqing, Chongqing, CN
38.6.164.6: 1689 次尝试 - 位置: Hong Kong, Hong Kong, HK
183.81.169.238: 1063 次尝试 - 位置: Amsterdam, North Holland, NL
209.38.25.214: 852 次尝试 - 位置: Sydney, New South Wales, AU
209.38.17.101: 848 次尝试 - 位置: Sydney, New South Wales, AU
117.144.99.175: 742 次尝试 - 位置: Shanghai, Shanghai, CN
170.64.142.212: 735 次尝试 - 位置: Sydney, New South Wales, AU
95.214.27.253: 488 次尝试 - 位置: Kerkrade, Limburg, NL
146.190.101.111: 466 次尝试 - 位置: Singapore, Singapore, SG
209.38.241.226: 327 次尝试 - 位置: Frankfurt am Main, Hesse, DE
193.32.162.65: 314 次尝试 - 位置: Budapest, Budapest, HU
156.251.135.252: 296 次尝试 - 位置: Los Angeles, California, US
91.92.245.92: 233 次尝试 - 位置: Amsterdam, North Holland, NL
192.180.14.56: 233 次尝试 - 位置: Fostoria, Ohio, US
192.36.73.247: 233 次尝试 - 位置: Växjö, Kronoberg, SE
...

从统计的结果来看，我的VPS确实受到了大量的 SSH 爆破攻击，攻击者通过不断尝试不同的用户名和密码，试图以SSH的方式的登陆系统。

为什么要搭建蜜罐

可能的解决办法

可以在Azure的管理页面设置网络规则，限制使用SSH登录的源IP，可是我们现在使用的设备的IP都是被DHCP服务器分配的，可能一段时间之后就会改变，之后如果再想以SSH的方式登录VPS就又要修改网络规则，在规则上移除原地址加入新地址，不太方便，所以我还是决定不限制SSH登录的源IP，并设置一个更强的密码，避免被成功爆破。

也可以通过修改/etc/SSH/SSHd_config文件，配置一些安全措施：

1
2
3
4
5

LoginGraceTime 30s        # 将登录超时时间设置为30秒
PermitRootLogin no        # 禁止root用户登录
StrictModes yes           # 启用严格模式
MaxAuthTries 3            # 允许最多3次认证尝试
MaxSessions 5             # 限制单个连接最多5个会话

这在一定程度上可以缓解SSH爆破。

还有一种办法就是安装Fail2Ban工具，它可以自动检测日志文件中的失败尝试，并根据预定义的规则封禁相应的 IP 地址。

但后面要搭建蜜罐，我就保留了原来的配置，也没有配置安全工具。

为什么要搭建蜜罐

恰巧我的本科专业是网络空间安全，了解过一些蜜罐的概念，于是我试一下通过搭建一个SSH蜜罐来收集攻击者信息，就是尝试使用一下。

Just for fun

蜜罐搭建

选择Cowrie蜜罐，可以直接搭建在VPS上，也可以通过Docker搭建在容器上。

由于我的VPS并不会承载太多工作，性能还有很多剩余（这里伏笔了，虽然是剩了性能，但不多…所以导致后面我的VPS直接卡死），所以我选择将Cowrie搭建在Docker容器上。

工作准备

下载docker，docker-compose，将cowrie项目克隆到本地。

1
2
3
4
5
6

$ docker --version
Docker version 24.0.7, build 24.0.7-0ubuntu2~22.04.1
$ docker-compose --version
docker-compose version 1.29.2, build unknown
$ ls
cowrie  ip_cache.json  MySQL  ssh_login_attempts.py

编辑docker-compose.yml

github项目代码里有一份docker-compose.yml，需要配置过后才可以使用，以下是我修改之后的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

---
version: '3'

volumes:
  cowrie-var:

services:
  cowrie:
    restart: always
    build:
      context: ./
      dockerfile: Dockerfile
    ports:
      - "2222:2222"
        # - "2223:2223"
    volumes:
      - ./etc:/cowrie/cowrie-git/etc
      - cowrie-var:/cowrie/cowrie-git/var

下面是配置的简要解释：

volumes:

• cowrie-var: 定义了一个 Docker 卷，用于持久化存储。

services:

• cowrie: 定义了一个名为 cowrie 的服务。

• restart: always: 指定容器在停止后总是重新启动。

• build:

  • context: ./: 表示 Dockerfile 位于当前目录。
  • dockerfile: Dockerfile: 指定 Dockerfile 的名称。

• ports:

  • "2222:2222": 将宿主机的 2222 端口映射到容器的 2222 端口。

• volumes:

  • ./etc:/cowrie/cowrie-git/etc: 将当前目录的 etc 文件夹挂载到容器内的 /cowrie/cowrie-git/etc。
  • cowrie-var:/cowrie/cowrie-git/var: 将定义的 cowrie-var 卷挂载到容器内的 /cowrie/cowrie-git/var。

这里docker会创建一个名为cowrie-var的卷，同步容器里对应的var文件，使得容器重启或宿主机重启后仍然能保留关键数据。能够使用当前目录中的 etc 配置文件，因为docker将当前目录下的cowrie/etc文件映射到了容器中的cowrie-git/etc中。

编辑cowire配置

配置文件位于etc目录下，基本上默认的配置就足够使用。直接复制文件:

1
2

cp etc/cowrie.cfg.dist etc/cowrie.cfg
cp etc/userdb.example etc/userdb.txt

cowrie.cfg 是 Cowrie 的主配置文件，用于配置 Cowrie 的各种选项和参数。

userdb.txt 是 Cowrie 的用户数据库文件，用于定义 Honeypot 中可用的用户名和密码。

The configuration for Cowrie is stored in cowrie.cfg.dist and cowrie.cfg (Located in cowrie/etc). Both files are read on startup, where entries from cowrie.cfg take precedence. The .dist file can be overwritten by upgrades, cowrie.cfg will not be touched. To run with a standard configuration, there is no need to change anything.

使用docker-compose构建并启动容器

在docker-compose.yml目录下使用up命令即可。

但前几次构建都失败了，根据错误提示又做了一些修改，最后容器始终都不能正常工作，在查看Dockerfile中内容后才知道，构建的途中会将Dockerfile所在目录中的所有文件复制到cowrie-git，而一开始我是在/cowrie/docker目录下操作的，所以最后构建出来的容器的目录内没有对应的文件，所以容器不能正常工作……..

因为不是很会docker，所以在这里走了一些岔路，浪费了些时间。

所以解决办法就是，将dockerfile和docker-compose.yml都移到cowrie/目录下，再使用docker-compose命令启动容器即可。

成功之后使用docker ps 命令查看容器状态。

1
2
3

~/cowrie$ sudo docker ps
CONTAINER ID   IMAGE           COMMAND                  CREATED          STATUS          PORTS                                                  NAMES
039b3420c979   cowrie_cowrie   "/cowrie/cowrie-env/…"   7 hours ago      Up 46 minutes   0.0.0.0:2222->2222/tcp, :::2222->2222/tcp, 2223/tcp    cowrie_cowrie_1

配置MySQL数据库

了解到cowrie支持将收集到的信息存储到MySQL中，便于查看，于是我又尝试构建一个MySQL服务。

但是如果要连接MySQL的话，需要运行cowrie的容器连接我服务器的端口，我将cowrie部署到docker上而不是服务器上的本意就是防止cowrie的可能的漏洞会使得服务器面临危险，但是如果cowrie要连接服务器的端口，这又将cowrie和服务器连接起来了….与我的本意又冲突了。

所以我想通过docker容器的方式运行一个数据库服务，于是我又通过docker-compose的方式构建并运行了一个MySQL服务的docker容器。

这是我的docker-compose.yml文件内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

version: '3.8'

services:
  MySQL:
    image: MySQL:8.0
    container_name: MySQL_container
    restart: always
    environment:
      # (root账户的密码)
      MySQL_ROOT_PASSWORD: *****  
      MySQL_DATABASE: cowire
    ports:
      - "3306:3306"
    volumes:
      - MySQL_data:/var/lib/MySQL

volumes:
  MySQL_data:

构建好后之后，使用docker ps命令查看，已经开启了两个容器，并且正常运行。

1
2
3
4

~/MySQL$ sudo docker ps
CONTAINER ID   IMAGE           COMMAND                  CREATED             STATUS             PORTS                                                  NAMES
dfb2032ec83c   MySQL:8.0       "docker-entrypoint.s…"   About an hour ago   Up About an hour   0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp   MySQL_container
039b3420c979   cowrie_cowrie   "/cowrie/cowrie-env/…"   7 hours ago         Up 59 minutes      0.0.0.0:2222->2222/tcp, :::2222->2222/tcp, 2223/tcp    cowrie_cowrie_1

然后在VPS上再下载一个MySQL客户端，使用以下命令然后再输入密码就可以连接到容器的数据库服务了。

1

MySQL -h 127.0.0.1 -u root -p

这里不能省略 -h 127.0.0.1 ，因为如果省略就代表用localhost，虽然也是这个IP地址，但是系统会默认使用Unix socket进行连接，而不会用TCP的方式进行连接。

用Unix socket会报错。

---

Unix Socket通信原理

Unix socket 仅在本地计算机上使用，不涉及网络传输。它通过文件系统中的一个特殊文件来进行通信，而不是通过网络接口。

使用文件系统中的一个特殊文件作为通信的端点。这个文件通常位于 /tmp 或 /var/run 等目录中，例如 /var/run/MySQL/MySQL.sock。客户端和服务器进程通过这个文件进行读写操作。

有以下三种类型

• Stream Sockets（流套接字）：提供面向连接的、可靠的字节流通信。类似于网络中的 TCP。
• Datagram Sockets（数据报套接字）：提供无连接的、独立的数据报通信。类似于网络中的 UDP。
• Raw Sockets（原始套接字）：提供对底层网络协议的访问，通常不用于一般应用程序。

通信过程：

• 服务器：在指定的 Unix socket 文件路径上监听客户端的连接请求。服务器进程创建一个 Unix socket，并将其绑定到一个文件路径上。然后，它会监听来自客户端的连接请求。
• 客户端：通过访问服务器指定的 Unix socket 文件来连接服务器。客户端进程打开这个文件并与服务器建立通信。

优点：

• 高效：由于 Unix socket 不涉及网络协议栈，它们在同一台机器上进行进程间通信时比网络套接字更高效。
• 安全性：Unix socket 文件的权限可以控制访问，进程之间的通信可以更加安全。

---

chatGPT：

区别解析

1. -h 127.0.0.1

   当你使用 -h 127.0.0.1 时，MySQL 客户端通过 TCP/IP 协议连接到 MySQL 服务。这是因为 127.0.0.1 明确指定了使用 TCP/IP 连接，并且你已正确映射了容器的端口到本地端口。

2. -h localhost

   当你使用 -h localhost 时，MySQL 客户端默认尝试通过 Unix socket 进行连接。在 Linux 系统上，localhost 通常指的是一个 Unix socket 文件。因为 Docker 容器和主机系统的 Unix socket 文件系统是隔离的，所以客户端尝试通过 Unix socket 连接时会失败，尤其是在容器内运行的服务无法映射到主机的 Unix socket 上。

再根据cowrie官方文档的指示，最好为cowrie创建专门的数据库，并且创建一个专门用于管理该数据库的用户（权限管理）。

1
2
3

CREATE USER 'cowrie'@'$IP' IDENTIFIED BY '********';
GRANT INSERT, SELECT, UPDATE ON cowrie.* TO 'cowrie'@'$IP';
FLUSH PRIVILEGES;

通过上面的命令，我创建了密码为********的用户cowrie，并规定了登录的IP地址和权限。

这里的$IP，一定是VPS对于MySQL容器的IP地址，因为这里做的是本机到服务器的映射，如果设置成localhost或者是127.0.0.1就会导致登陆失败。

要找到这个对应的IP地址，就先要找到MySQL容器所对应的网域。（查看docker容器的网络配置）

然后创建cowrie数据库，并在该库中执行/cowrie/docs/sql/MySQL.sql脚本，创建对应的表。

最后还需要在cowrie/etc/cowrie.cfg配置文件中，找到output_MySQL模块，做如下修改。

1
2
3
4
5
6
7
8
9
10

[output_MySQL]
enabled = true
# VPS对于cowrie容器的IP地址
host = $IP    
database = cowrie
username = cowrie
# 填写给cowrie设置的密码
password = ********
port = 3306
debug = false

这样就成功了，重新构建容器并启动即可。

现在使用下面的命令

1

SSH root@localhost -p 2222

即可在本地访问cowrie蜜罐进程，该进程会记录每一次操作并写入MySQL数据库中。

重新配置端口

为了捕获外部对SSH服务的爆破，还需要完成最后一步：将22端口重定向到2222端口并将SSH连接更改到另一个端口。

修改SSH配置文件以启用新的端口

修改/etc/SSH/SSHd_config文件，在原本的Port 22上再添加一个端口：

1
2

Port 22
Port *****

然后使用sudo systemctl restart SSH 重启SSH服务。

记得在Azure管理界面的入栈端口规则做一下修改。

---

如果配置出了问题导致无法连接到VPS，还可以通过在Azure管理界面直接向VPS运行bash脚本的方式恢复SSH配置。

配置iptables进行端口重定向

添加一条规则，将22端口的所有流量重定向到2222端口，也就是SSH蜜罐监听的端口。

1

sudo iptables -t nat -A PREROUTING -p tcp --dport 22 -j REDIRECT --to-port 2222

保存iptables规则，使其在重启后仍然有效

1

sudo sh -c "iptables-save > /etc/iptables/rules.v4"

这样，外部访问VPS的22号端口就会访问到蜜罐程序的假的SSH服务，真正的SSH服务开放在我们刚才设置的另外的端口上，如果要通过SSH远程连接VPS，就需要指定正确的端口。

最后我还是弃用了iptables

– 2024-7-29

效果

为了便于查看，我在Azure管理界面配置了3306端口的限制，现在我可以在自己的笔记本上使用navicat连接该数据库。

（但是查询的速度有点慢….应该是因为我的服务器配置太差了）

可以看到，已经有很多尝试爆破SSH的连接了。

过几天再更新一下收集数据的情况。

参考文档

Cowrie 官方文档

站长手册（二）服务器安全之SSH蜜罐 | 青果君的小站 (qingguojun.com)