Un VPS appena acquistato è come una porta senza serratura, con script kiddie di tutto il mondo che bussano alla porta. Questo articolo ti guida a mettere una bella serratura. Così il tuo “gamberetto” (openclaw) non se ne va in giro a combinare guai.

0. Prima di iniziare

Hai appena preso un VPS, tutto gasato con IP e password di root in mano, e poi?

L’approccio di molti è: partire subito a installare roba e deployare progetti.

È un’abitudine pericolosa.

Il tuo VPS ha un IP pubblico, il che significa che chiunque nel mondo può provare a connettersi. E nella configurazione di default:

  • La porta esposta è la 22
  • L’utente è il classico root
  • A proteggerti è rimasta solo una password

Ogni giorno un’infinità di script automatizzati scansiona interi range di IP, provando a forzare l’accesso con password comuni. Il tuo server è già sotto attacco dal momento esatto in cui va online.

Quindi, la primissima cosa da fare appena ottenuto un VPS non è installare software, ma eseguire l’hardening iniziale.

1. L’obiettivo

L’obiettivo di questo articolo è:

  • ✅ Metti in piedi un accesso remoto sicuro: login con chiave SSH + porta non di default
  • ✅ Crea un utente normale: evita di usare direttamente root
  • ✅ Configura il firewall: apri solo le porte strettamente necessarie
  • ✅ Attiva l’accelerazione di rete: con BBR la connessione decolla
  • ✅ Blocca i tentativi di brute-force: fail2ban banna in automatico gli IP malevoli

Fatto tutto questo, il tuo VPS avrà una base solida e potrai distribuire i tuoi servizi in tutta tranquillità.

2. Pianificazione e ragionamento

Perché fare tutte queste configurazioni?

Un VPS appena acquistato è come un appartamento appena consegnato, grezzo e da sistemare:

Situazione di default Rischio La nostra soluzione
Login diretto con root Troppi permessi, rischio altissimo se sbagli Creare un utente normale + sudo
Login con password Vulnerabile a attacchi brute-force Login con chiave SSH
Porta 22 di default Primo bersaglio degli scanner Cambiare a una porta non standard
Firewall disattivato Tutte le porte esposte UFW: aprire solo le porte necessarie
Rete nativa Tasso di packet loss alto, latenza elevata Algoritmo di controllo della congestione BBR

Flusso generale

VPS初始化流程

Seguiamo esattamente quest’ordine, e ti spiego il perché di ogni passaggio man mano che andiamo avanti.

3. Passaggi operativi

3.1 Primo accesso e aggiornamento del sistema

Recuperare l’IP del server

Dopo aver comprato il VPS, il provider ti darà:

  • Indirizzo IP: ad esempio 192.168.1.100
  • Porta: di solito è 22 (alcuni provider potrebbero usarne una diversa)
  • Username: di solito è root
  • Password: una stringa di caratteri generata casualmente

VPS 服务商后台的登录信息页面

Connessione SSH

Utenti Mac / Linux: aprite il terminale e digitate direttamente:

1
2
ssh root@你的服务器IP
# 例如：ssh [email protected]

Utenti Windows:

  • Windows 10/11 ha OpenSSH già integrato, quindi potete usare lo stesso comando direttamente in PowerShell o CMD
  • In alternativa, potete appoggiarvi a tool come Termius o MobaXterm

Al primo accesso vi imbatterete in un avviso per confermare l’impronta digitale:

1
2
3
The authenticity of host '192.168.1.100 (192.168.1.100)' can't be established.
ED25519 key fingerprint is SHA256:xxxxxxxxxxxxxxxxxxx.
Are you sure you want to continue connecting (yes/no/[fingerprint])?

In pratica vi sta chiedendo: «Non conosco questa macchina, sei sicuro di volerti connettere?»

Digitate yes e premete Invio. Poi inserite la password (attenzione: mentre la digitate non comparirà nessun carattere a schermo, è una normale misura di sicurezza) e premete di nuovo Invio.

首次 SSH 连接的完整过程，包含指纹确认

Se vi ritrovate davanti a un prompt simile a questo, il login è andato a buon fine:

1
2
3
Welcome to Ubuntu 24.04 LTS (GNU/Linux 6.x.x-x-generic x86_64)
...
root@hostname:~#

💡 Perché verificare l’impronta digitale?

Serve a prevenire gli attacchi “man-in-the-middle”. Al primo accesso ti segni l’impronta digitale del server: se in futuro dovesse cambiare, significa che qualcuno potrebbe star fingendo di essere il tuo server.

登录成功了

Prendi confidenza con il tuo server

Appena fatto login, diamo un’occhiata alle informazioni di base di questa macchina:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 查看系统版本
cat /etc/os-release

# 查看内核版本
uname -r

# 查看 CPU 核心数和型号
nproc
lscpu | grep "Model name"

# 查看内存
free -h

# 查看磁盘
df -h

服务器基本信息输出

Tieni a mente queste info, ti torneranno utili più avanti per risolvere eventuali problemi.

Aggiornamento del sistema

Dopo aver controllato le info del server, la prima cosa seria da fare è aggiornare il sistema. L’immagine di sistema di un server nuovo potrebbe risalire a qualche mese fa, e nel frattempo potrebbero essere usciti dei patch di sicurezza:

1
2
# 更新软件包列表 + 升级所有软件 + 清理
apt update && apt full-upgrade -y && apt autoremove -y && apt autoclean

Spiegazione dei parametri:

  • apt update: aggiorna l’indice dei pacchetti
  • apt full-upgrade: aggiorna tutti i software, kernel compreso
  • -y: conferma automatica, così non devi digitare yes a mano
  • apt autoremove: rimuove le dipendenze che non servono più
  • apt autoclean: pulisce la cache dei pacchetti di installazione scaricati

apt update 和 apt upgrade 执行过程

⏱️ Questo passaggio potrebbe richiedere qualche minuto, dipende da quanti aggiornamenti ci sono. Se ogni tanto ti chiede conferma, praticamente basta seguire la sua logica e vai tranquillo.

Controlla se serve un riavvio

Dopo un aggiornamento del kernel, in genere serve un riavvio per farlo andare effettivamente:

1
2
# 检查是否需要重启
cat /var/run/reboot-required 2>/dev/null && echo ">>> 需要重启" || echo ">>> 无需重启"

是否需要重启

Se ti dice che serve riavviare:

1
reboot

Dopo il riavvio dovrai riconnetterti via SSH.

Installa gli strumenti di uso comune

1
apt install -y sudo curl wget git vim htop tree unzip net-tools ufw fail2ban neofetch

A cosa servono 'sti attrezzi:

Strumento Uso
sudo Permette agli utenti normali di eseguire comandi come amministratore
curl / wget Scaricare file
git Controllo versione
vim Editor di testo
htop Monitor dei processi più carino
tree Mostra la struttura delle directory ad albero
net-tools Strumenti di rete (ifconfig, netstat, ecc.)
ufw Firewall semplice e facile da usare
fail2ban Protezione contro il brute-force
neofetch Mostra le informazioni di sistema in modo carino
neofetch 显示的系统信息

3.2 Creare un utente non root

Perché non usare direttamente root?

I permessi dell’utente root sono troppo ampi: un semplice errore di distrazione con rm -rf / e saluta tutto. Per le operazioni di tutti i giorni usa un utente normale; quando ti servono i privilegi di amministratore, basta lanciare sudo.

L’aragosta (openclaw) è una bestia, mica posso darle l’accesso root!

Creare l’utente

1
2
# 创建用户（把 ittinker 换成你想要的用户名）
adduser ittinker

Il sistema ti chiederà di impostare una password e qualche altra informazione:

1
2
3
4
5
6
7
8
New password:              # 输入密码（不会显示）
Retype new password:       # 再输入一次
Full Name []:              # 可以直接回车跳过
Room Number []:            # 回车跳过
Work Phone []:             # 回车跳过
Home Phone []:             # 回车跳过
Other []:                  # 回车跳过
Is the information correct? [Y/n]   # 输入 Y 确认

adduser 创建用户的完整交互过程

Assegnare i privilegi sudo

1
2
# 把用户加入 sudo 组, ittinker 换成你自己上面创建的那个用户
usermod -aG sudo ittinker

Facciamo una verifica:

1
2
3
4
5
# 切换到新用户 ittinker 换成你自己上面创建的那个用户
su - ittinker

# 测试 sudo 是否生效
sudo whoami

Se l’output è root, significa che sudo è configurato correttamente.
测试sudo

💡 Dritta

Se digiti exit torni all’utente root. Per le prossime configurazioni continuiamo a usare root, poi, a lavoro finito, passeremo al nostro utente normale.

3.3 Configurare il login con chiavi SSH

Autenticazione a chiave vs autenticazione a password

SSH密钥认证原理

L’autenticazione a chiave è molto più sicura della password:

  • Le password possono subire attacchi brute force, le chiavi praticamente impossibili
  • Niente più password da digitare ogni volta, molto più comodo
  • Anche se la password venisse compromessa, senza la chiave privata non entra nessuno

Passaggio 1: generare la coppia di chiavi in locale

Esegui sul tuo computer (non sul server):

1
2
# 生成 ED25519 密钥（推荐，更安全更快）
ssh-keygen -t ed25519 -C "[email protected]"

Ti verrà chiesto:

1
Enter file in which to save the key (/Users/你/.ssh/id_ed25519):

Premi direttamente Invio per usare il percorso predefinito. Noi qui abbiamo usato ./ittinker, che significa semplicemente salvare il file nella directory corrente con il nome ittinker.

1
Enter passphrase (empty for no passphrase):

Puoi impostare una password per la chiave (uno strato extra di protezione) oppure premere direttamente Invio per lasciare vuoto.

本地生成 SSH 密钥的过程

Una volta completata la generazione, troverai due file nella directory ~/.ssh/ (qui sotto ci sono i nomi predefiniti, se hai premuto Invio prima verranno chiamati così):

  • id_ed25519: la chiave privata, non deve mai assolutamente finire in mani sbagliate!
  • id_ed25519.pub: la chiave pubblica, da caricare sul server

💡 ed25519 vs RSA

ed25519 è l’algoritmo attualmente consigliato, più sicuro e con chiavi più corte rispetto al tradizionale RSA. Se il tuo sistema è troppo vecchio e non lo supporta, puoi usare ssh-keygen -t rsa -b 4096.

Un piccolo dettaglio: le chiavi generate con ed25519 sono più piccole, mentre i file RSA sono grandi. L’ho chiesto all’AI e ho scoperto che le dimensioni non contano, dipende solo dal tipo di algoritmo.

Passaggio due: carica la chiave pubblica sul server

Metodo A: usa ssh-copy-id (consigliato)

1
2
# 在你的电脑上执行
ssh-copy-id -i ~/.ssh/id_ed25519.pub yourname@你的服务器IP

Dopo aver inserito la password, la chiave pubblica verrà copiata automaticamente sul server.

ssh-copy-id 执行成功

Metodo B: copia manuale

Se ssh-copy-id non è disponibile, puoi farlo manualmente:

1
2
# 1. 在你的电脑上，查看公钥内容
cat ~/.ssh/id_ed25519.pub

Copia l’output (una lunga stringa di testo che inizia con ssh-ed25519).

1
2
3
4
5
6
7
8
9
10
11
# 2. 在服务器上，为新用户创建 .ssh 目录, ittinker 换成你刚刚创建的用户名
mkdir -p /home/ittinker/.ssh
chmod 700 /home/ittinker/.ssh

# 3. 创建 authorized_keys 文件并粘贴公钥
vim /home/ittinker/.ssh/authorized_keys
# 按 i 进入编辑模式，粘贴公钥，按 Esc，输入 :wq 保存退出

# 4. 设置正确的权限
chmod 600 /home/ittinker/.ssh/authorized_keys
chown -R ittinker:ittinker /home/ittinker/.ssh

⚠️ I permessi sono fondamentali!

SSH è molto pignolo sui permessi dei file:

  • .ssh directory: 700 (accessibile solo dal tuo utente)
  • authorized_keys file: 600 (leggibile e scrivibile solo dal tuo utente)

Se i permessi non sono esatti, SSH rifiuterà di usare la chiave per il login.

Passaggio 3: Testa il login con la chiave

Apri una nuova finestra del terminale (non chiudere quella originale, così se sbagli qualcosa puoi sempre rimediare) e testa il login con la chiave:

1
ssh ittinker@你的服务器IP

Se riesci ad accedere senza inserire la password, la configurazione della chiave è andata a buon fine! 🎉

(Se hai impostato una passphrase per la chiave privata, ti verrà chiesta: è del tutto normale)
使用密钥成功登录（无需服务器密码）

Qui abbiamo aggiunto il parametro -i perché questa chiave non si trova nel percorso predefinito, ma nella directory corrente. Se non lo specifichi, il sistema userà la chiave di default.

3.4 Rafforzare la sicurezza di SSH

Ora che il login con la chiave funziona, andiamo a blindare un po’ la configurazione SSH:

  1. Cambia la porta predefinita (così eviti le scansioni automatiche)
  2. Disabilita il login con password
  3. Impedisci il login diretto come root

Modifica il file di configurazione SSH

1
2
3
4
5
# 备份原配置
cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak

# 编辑配置
nano /etc/ssh/sshd_config

修改前

Trova e modifica le seguenti impostazioni (alcune potrebbero essere commentate, rimuovi il # all’inizio):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 修改端口（选一个 1024-65535 之间的数字）
Port 22000

# 禁止 root 登录
PermitRootLogin no

# 允许密钥登录
PubkeyAuthentication yes
AuthorizedKeysFile .ssh/authorized_keys

# 禁止密码登录（确保密钥登录测试成功后再改！）
PasswordAuthentication no

# 使用更安全的 SSH2 协议
Protocol 2

# 最大认证尝试次数
MaxAuthTries 3

# 客户端超时设置
ClientAliveInterval 300
ClientAliveCountMax 2

修改后的 sshd_config 关键配置

Salva ed esci (ctrl + o).

Con Nano, per salvare premi ctrl + o: ti chiederà di confermare il nome del file, premi semplicemente Invio. Per uscire, invece, ctrl + x.

Riavvia il servizio SSH

1
systemctl restart sshd.service

⚠️ Attenzione!

Non chiudere il terminale attuale! Prima di farlo, apri una nuova finestra e verifica se riesci ad accettare con la nuova configurazione:

1
ssh -p 22000 yourname@你的服务器IP

Se il login va a buon fine, puoi chiudere la vecchia finestra. Se non riesci a entrare, puoi comunque correggere la configurazione dalla sessione precedente.

Se hai acquistato un server leggero, è molto probabile che questa porta non sia modificabile. I classici ECS lo permettono, quindi fai attenzione.

3.5 Configura il firewall UFW

UFW防火墙规则

UFW (Uncomplicated Firewall) è lo strumento firewall predefinito di Ubuntu: facile da configurare, ma molto potente.

Configurazione di base

1
2
3
4
5
6
7
8
9
10
11
# 设置默认策略：拒绝所有入站，允许所有出站
ufw default deny incoming
ufw default allow outgoing

# 允许 SSH（使用你设置的端口）
ufw allow 22000/tcp comment 'SSH'
ufw allow 22/tcp comment 'SSH'  # 如果是轻量服务器，还是开22端口

# 允许 HTTP 和 HTTPS
ufw allow 80/tcp comment 'HTTP'
ufw allow 443/tcp comment 'HTTPS'

Abilita il firewall

1
ufw enable

Ti verrà mostrato questo prompt:

1
Command may disrupt existing ssh connections. Proceed with operation (y|n)?

Digita y per confermare.

Verifica lo stato

1
ufw status verbose

ufw status 的输出结果

23022 è un refuso mio, regolatevi in base alla vostra situazione reale

Output tipo:

1
2
3
4
5
6
7
8
9
10
11
12
Status: active
Logging: on (low)
Default: deny (incoming), allow (outgoing), disabled (routed)

To                         Action      From
--                         ------      ----
22000/tcp (SSH)            ALLOW IN    Anywhere
80/tcp (HTTP)              ALLOW IN    Anywhere
443/tcp (HTTPS)            ALLOW IN    Anywhere
22000/tcp (SSH (v6))       ALLOW IN    Anywhere (v6)
80/tcp (HTTP (v6))         ALLOW IN    Anywhere (v6)
443/tcp (HTTPS (v6))       ALLOW IN    Anywhere (v6)

Cheat sheet dei comandi principali

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 查看状态
ufw status

# 添加规则
ufw allow 8080/tcp

# 删除规则
ufw delete allow 8080/tcp

# 允许特定 IP 访问所有端口
ufw allow from 192.168.1.100

# 禁用防火墙（不推荐）
ufw disable

# 重置所有规则
ufw reset

3.6 Attiva l’accelerazione BBR

BBR (Bottleneck Bandwidth and Round-trip propagation time) è un algoritmo di controllo della congestione TCP sviluppato da Google, in grado di migliorare nettamente le prestazioni di rete.

Attivazione con un clic

1
2
3
4
5
6
# 添加 BBR 配置
echo "net.core.default_qdisc=fq" >> /etc/sysctl.conf
echo "net.ipv4.tcp_congestion_control=bbr" >> /etc/sysctl.conf

# 使配置生效
sysctl -p

Verifica che sia attivo

1
2
# 查看当前拥塞控制算法
sysctl net.ipv4.tcp_congestion_control

L’output dovrebbe essere:

1
net.ipv4.tcp_congestion_control = bbr
1
2
# 确认 BBR 模块已加载
lsmod | grep bbr

Output tipo:

1
tcp_bbr    20480  3

💡 L’effetto di BBR

Una volta attivato BBR, soprattutto in ambienti con rete instabile o latenza elevata, noterai chiaramente:

  • Download più veloci
  • Operazioni SSH più fluide
  • Caricamento delle pagine più rapido

bbr 开启

3.7 Configura fail2ban per difenderti dai brute-force

fail2ban monitora i log e banna automaticamente gli IP dopo ripetuti tentativi di login falliti.

Configurazione di base

1
2
3
4
5
# 复制默认配置（不要直接修改 jail.conf）
cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local

# 编辑配置
vim /etc/fail2ban/jail.local

Trova la sezione [sshd] e assicurati di avere questa configurazione:

1
2
3
4
5
6
7
8
[sshd]
enabled = true
port = 22000          # 改成你的 SSH 端口
filter = sshd
logpath = /var/log/auth.log
maxretry = 3          # 最大尝试次数
bantime = 3600        # 封禁时间（秒），这里是 1 小时
findtime = 600        # 在这个时间窗口内

fail2ban

Avvia i servizi

1
2
3
4
5
# 重启 fail2ban
systemctl restart fail2ban

# 设置开机自启
systemctl enable fail2ban

Controlla lo stato

1
2
3
4
5
# 查看 fail2ban 状态
fail2ban-client status

# 查看 SSH 监控状态
fail2ban-client status sshd

fail2ban-client status sshd 的输出

L’output sarà simile a questo:

1
2
3
4
5
6
7
8
9
Status for the jail: sshd
|- Filter
|  |- Currently failed: 0
|  |- Total failed:     0
|  `- File list:        /var/log/auth.log
`- Actions
   |- Currently banned: 0
   |- Total banned:     0
   `- Banned IP list:

Comandi utili

1
2
3
4
5
6
7
8
# 手动封禁 IP
fail2ban-client set sshd banip 1.2.3.4

# 手动解封 IP
fail2ban-client set sshd unbanip 1.2.3.4

# 查看被封禁的 IP
fail2ban-client status sshd

3.8 [Opzionale] Gestire più server con SSH Config

Se hai più server, digitare ssh -p 22000 user@ip ogni volta è una vera scocciatura. Puoi semplificare tutto usando SSH Config.

File di configurazione

Modifica il file ~/.ssh/config sul tuo computer locale:

1
vim ~/.ssh/config

Aggiungi questa configurazione:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 第一台服务器
Host vps1
    HostName 192.168.1.100
    User yourname
    Port 22000
    IdentityFile ~/.ssh/id_ed25519

# 第二台服务器
Host vps2
    HostName 192.168.1.101
    User admin
    Port 22222
    IdentityFile ~/.ssh/id_ed25519

# 通用设置（应用于所有连接）
Host *
    ServerAliveInterval 60
    ServerAliveCountMax 3
    AddKeysToAgent yes

Come usarlo

Ora puoi connetterti direttamente usando l’alias:

1
2
3
4
5
# 连接第一台服务器
ssh vps1

# 连接第二台服务器
ssh vps2

Niente più stress a ricordare IP, porte e nomi utente!

3.9 [Opzionale] Consentire l’accesso solo a Cloudflare

Se il tuo sito si trova completamente dietro Cloudflare, puoi impostare le regole del firewall in modo da consentire l’accesso alle porte 80/443 solo agli IP di Cloudflare, mettendo così una bella sicurezza in più.

⚠️ Attenzione: per fare questa configurazione, il tuo dominio deve essere già integrato con la CDN di Cloudflare.

Script di configurazione automatica

1
2
3
4
5
6
7
8
# 下载脚本
wget -O ~/.cloudflare-ufw.sh https://gist.githubusercontent.com/Xm798/12560579ce11f62027ea8da1fae37456/raw/b07ac8cfe09badf02fc70e2d8bc2da68cabbda50/cloudflare-ufw.sh

# 添加执行权限
chmod +x ~/.cloudflare-ufw.sh

# 执行脚本
~/.cloudflare-ufw.sh

Questo script si occuperà di:

  1. Prendi i range IP ufficiali più recenti direttamente da Cloudflare
  2. Aggiungi le regole UFW per consentire l’accesso alle porte 80/443 solo a questi IP
  3. Ricarica UFW

Impostare l’aggiornamento automatico

I range IP di Cloudflare possono cambiare nel tempo, quindi impostiamo un aggiornamento automatico settimanale:

1
2
# 添加 cron 任务（每周一凌晨执行）
(crontab -l 2>/dev/null; echo "0 0 * * 1 /root/.cloudflare-ufw.sh > /dev/null 2>&1") | crontab -

3.10 Impostare il fuso orario

Il fuso orario di default potrebbe essere UTC: cambialo con il tuo per rendere la lettura dei log molto più comoda:

1
2
3
4
5
6
7
8
# 查看当前时区
timedatectl

# 设置为上海时区（中国用户）
sudo timedatectl set-timezone Asia/Shanghai

# 验证
date

设置时区

3.11 [Opzionale] Configurare gli aggiornamenti di sicurezza automatici

Facciamo in modo che il sistema installi da solo le patch di sicurezza, così non devi pensarci ogni volta a mano:

1
2
3
4
5
# 安装自动更新工具
sudo apt install -y unattended-upgrades

# 配置
sudo dpkg-reconfigure --priority=low unattended-upgrades

Scegli “Yes” per attivare gli aggiornamenti automatici.

💡 Questa funzione si occupa di installare solo gli aggiornamenti di sicurezza, senza fare il salto a nuove major version. Quindi è abbastanza sicuro.

Checklist di inizializzazione

Finita tutta la configurazione, usa questa checklist per fare un giro di controllo:

Cosa verificare Comando Risultato atteso
Sistema aggiornato apt update && apt list --upgradable Nessun pacchetto da aggiornare
L’utente normale può usare sudo sudo whoami Output root
Login con chiave funzionante ssh yourname@ip -p port Accesso senza password
Login con password disabilitato grep PasswordAuth /etc/ssh/sshd_config PasswordAuthentication no
Porta SSH modificata grep Port /etc/ssh/sshd_config La porta che hai impostato
Firewall attivo ufw status Status: active
BBR attivato sysctl net.ipv4.tcp_congestion_control = bbr
fail2ban in esecuzione systemctl status fail2ban active (running)
Fuso orario impostato timedatectl Asia/Shanghai o il tuo fuso orario
SSH Config locale cat ~/.ssh/config Alias del server configurato

Posizione dei file chiave

1
2
3
4
/etc/ssh/sshd_config        # SSH 服务端配置
~/.ssh/authorized_keys      # 允许登录的公钥
~/.ssh/config               # 本地 SSH 客户端配置（在你电脑上）
/etc/fail2ban/jail.local    # fail2ban 配置

Best practice di sicurezza

  1. Aggiorna regolarmente il sistema: apt update && apt upgrade
  2. Controlla spesso i log di accesso: lastb (login falliti), last (login riusciti)
  3. Tieni d’occhio i ban di fail2ban
  4. Fai un backup prima di modificare i file di configurazione importanti

5. Troubleshooting

Q1: Login con chiave fallito, ti chiede ancora la password?

Possibili cause:

  1. Problemi di permessi (il più comune)

    1
    2
    3
    # 检查并修复权限
    chmod 700 ~/.ssh
    chmod 600 ~/.ssh/authorized_keys

  2. Chiave pubblica non copiata correttamente

    1
    2
    3
    # 检查 authorized_keys 内容
    cat ~/.ssh/authorized_keys
    # 应该是一行完整的公钥，以 ssh-ed25519 或 ssh-rsa 开头

  3. Interferenza di SELinux (su sistemi CentOS/RHEL)

    1
    restorecon -Rv ~/.ssh

Q2: Dopo aver cambiato la porta non riesci più a connetterti?

Passaggi per risolvere:

  1. Assicurati che la nuova porta sia aperta nel firewall:

    1
    ufw status | grep 你的端口

  2. Verifica che la configurazione di SSH sia corretta:

    1
    grep Port /etc/ssh/sshd_config

  3. Controlla che il servizio SSH sia in esecuzione:

    1
    systemctl status sshd

  4. Se non riesci proprio a connetterti, usa la console VNC del tuo provider per accedere e sistemare il problema.

Q2.5: Il cambio di porta non ha proprio effetto? (Server lightweight dei provider cloud)

Sintomo: hai modificato /etc/ssh/sshd_config, ma dopo aver riavviato il servizio la porta 22 risulta ancora aperta e quella nuova non funziona.

Come diagnosticare:

bash

1
2
# 查看是谁在监听 22 端口
netstat -lntp | grep :22

Se l’output è simile a questo:

1
tcp  0  0.0.0.0:22  0.0.0.0:*  LISTEN  1/init

significa che la porta 22 è in ascolto da parte di init (PID 1), e non dal processo sshd.

Perché: con alcuni provider cloud, l’SSH dei loro “server applicativi leggeri” o delle “istanze container” passa tramite un proxy a livello di piattaforma, quindi le configurazioni di sshd che fai dentro il tuo server non hanno alcun effetto.

Soluzione:

Tipo di istanza Come modificare la porta SSH
ECS tradizionale Modifica sshd_config ✅
Server leggero Forse va fatto dal pannello di controllo del cloud, oppure non è proprio supportato
Istanza container Di solito non è supportato

Se la tua istanza non supporta il cambio di porta, le altre misure di sicurezza diventano ancora più importanti:

  • ✅ Creare un utente normale + disabilitare il login root
  • ✅ Login SSH con chiave + disabilitare il login con password
  • ✅ fail2ban per fermare gli attacchi brute-force

Se metti in pratica queste misure, il livello di sicurezza resta comunque molto alto.

Q3: fail2ban mi ha bannato da solo?

1
2
3
4
5
# 用 VNC 登录后解封
fail2ban-client set sshd unbanip 你的IP

# 把你的 IP 加入白名单，编辑 jail.local
ignoreip = 127.0.0.1/8 ::1 你的IP

Q4: Dopo aver attivato UFW il sito non è più raggiungibile?

1
2
3
4
5
6
# 检查 80/443 是否开放
ufw status

# 如果没有，添加规则
ufw allow 80/tcp
ufw allow 443/tcp

Q5: Eseguendo un comando mi dice che non trova sudo?

Sull’installazione minimale di Debian potrebbe non esserci sudo, installalo usando root:

1
2
apt install sudo
usermod -aG sudo ittinker

6. Script di inizializzazione con un clic (da usare quando hai preso confidenza)

Se hai già familiarità con i passaggi precedenti, puoi usare questo script per inizializzare tutto in un attimo.

⚠️ Attenzione: prima di lanciare lo script, assicurati di avere già pronta la tua chiave pubblica SSH.

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
78
79
80
81
82
83
84
85
86
87
88
89
#!/bin/bash
# VPS 初始化脚本
# 使用方法：以 root 身份运行

set -e

# === 配置区域（根据你的需求修改）===
NEW_USER="ittinker"           # 新用户名
NEW_SSH_PORT="22000"          # 新 SSH 端口
TIMEZONE="Asia/Shanghai"      # 时区
# =====================================

echo "=== VPS 初始化脚本 ==="
echo ""

# 1. 更新系统
echo "[1/8] 更新系统..."
apt update && apt upgrade -y

# 2. 安装基础工具
echo "[2/8] 安装基础工具..."
apt install -y sudo curl wget git vim htop tree unzip net-tools ufw fail2ban neofetch

# 3. 创建新用户
echo "[3/8] 创建用户 $NEW_USER..."
if id "$NEW_USER" &>/dev/null; then
    echo "用户已存在，跳过创建"
else
    adduser --gecos "" $NEW_USER
    usermod -aG sudo $NEW_USER
fi

# 4. 配置 SSH 目录
echo "[4/8] 配置 SSH 目录..."
mkdir -p /home/$NEW_USER/.ssh
chmod 700 /home/$NEW_USER/.ssh
touch /home/$NEW_USER/.ssh/authorized_keys
chmod 600 /home/$NEW_USER/.ssh/authorized_keys
chown -R $NEW_USER:$NEW_USER /home/$NEW_USER/.ssh

echo ""
echo ">>> 请将你的公钥粘贴到下面（粘贴后按 Ctrl+D 结束）："
cat >> /home/$NEW_USER/.ssh/authorized_keys
echo ""

# 5. 修改 SSH 配置
echo "[5/8] 修改 SSH 配置..."
cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak
sed -i "s/^#*Port .*/Port $NEW_SSH_PORT/" /etc/ssh/sshd_config
sed -i "s/^#*PermitRootLogin .*/PermitRootLogin no/" /etc/ssh/sshd_config
sed -i "s/^#*PasswordAuthentication .*/PasswordAuthentication no/" /etc/ssh/sshd_config
sed -i "s/^#*PermitEmptyPasswords .*/PermitEmptyPasswords no/" /etc/ssh/sshd_config

# 6. 配置防火墙
echo "[6/8] 配置防火墙..."
ufw default deny incoming
ufw default allow outgoing
ufw allow $NEW_SSH_PORT/tcp
ufw allow 80/tcp
ufw allow 443/tcp
echo "y" | ufw enable

# 7. 开启 BBR
echo "[7/8] 开启 BBR..."
echo "net.core.default_qdisc=fq" >> /etc/sysctl.conf
echo "net.ipv4.tcp_congestion_control=bbr" >> /etc/sysctl.conf
sysctl -p

# 8. 设置时区
echo "[8/8] 设置时区..."
timedatectl set-timezone $TIMEZONE

# 重启 SSH
systemctl restart sshd

echo ""
echo "=========================================="
echo "  ✅ 初始化完成！"
echo "=========================================="
echo ""
echo "  新 SSH 端口: $NEW_SSH_PORT"
echo "  新用户: $NEW_USER"
echo "  时区: $TIMEZONE"
echo ""
echo "  请使用以下命令登录："
echo "    ssh -p $NEW_SSH_PORT $NEW_USER@$(curl -s ifconfig.me 2>/dev/null || echo '你的IP')"
echo ""
echo "  ⚠️ 重要：请先测试新配置能否登录，再关闭当前终端！"
echo ""

7. Fatto tutto questo, quanto è migliorata la sicurezza?

Passaggio Cosa abbiamo fatto Perché è importante
Aggiornamento del sistema Installazione delle ultime patch Risolve le vulnerabilità note
Creazione di un nuovo utente Non usare più direttamente root Riduce il rischio di errori umani
Chiavi SSH Sostituzione della password con una chiave Impossibile da forzare con attacchi brute force
Cambio di porta Evitare la porta 22 di default Riduce le probabilità di essere scansionati
Disabilitazione della password Accesso solo tramite chiave Elimina alla radice gli attacchi basati su password
Disabilitazione di root root non può fare login diretto Alza l’asticella per gli attacchi
Firewall UFW Apertura solo delle porte necessarie Riduce la superficie di attacco
Accelerazione BBR Ottimizzazione delle prestazioni di rete Aumenta la velocità di accesso
fail2ban Ban automatico degli IP malevoli Blocca gli attacchi prolungati

Con questa messa a punto, la sicurezza del tuo server ha già superato quella di 90% dei VPS.

Anteprima del prossimo articolo

Nel prossimo parleremo di Configurazione rapida del login con chiavi SSH, entrando più nel dettaglio su:

  • Come generare le chiavi sui diversi sistemi operativi
  • Gestione di chiavi multiple
  • Configurazione di SSH Agent
  • Impostazioni dei client SSH più comuni

Ultimo aggiornamento dell’articolo: gennaio 2026

Serie “Cassetta degli attrezzi per indie developer”, seguimi!