Passaggi per proteggere il nostro VPS

Questo tutorial mostra come preparare e proteggere un Virtual Private Server (VPS) con Debian GNU / Linux. Prima di iniziare, si ipotizzano alcune cose:

1. Hai un livello intermedio di familiarità con GNU / Linux.
2. Esiste un VPS per uso personale a cui abbiamo accesso tramite SSH.
3. Il VPS ha l'ipv4 esterno dedicato 250.250.250.155 e il nostro provider possiede il blocco 250.250.0.0/16. (1)
4. Nel nostro VPS avremo solo i servizi http, https e ssh abilitati per l'accesso dall'esterno.
5. Il DNS esterno non sarà abilitato poiché di solito viene eseguito nel pannello del nostro provider. (2)
6. Funzionerà come un superutente.

Installazione

Come primo passo, aggiorniamo il server e installiamo alcuni pacchetti di cui avremo bisogno:

# aptitude update e aptitude safe-upgrade # aptitude -RvW install dropbear gesftpserver sslh iptables-persistent ulogd fail2ban nginx-light apache2-utils dnsutils telnet ghostscript poppler-utils zip unzip unrar-free p7zip-full less multitail tee mc

Configurazione

Ora creeremo un utente di lavoro. Lavorare come root su un server non è sicuro, quindi creeremo prima un utente speciale:

operatore adduser usermod -aG operatore sudo

Il primo comando crea l'utente operatore, il secondo lo aggiunge al gruppo sudo, che ti consentirà di eseguire le applicazioni come root.

Modifica le autorizzazioni per i super utenti

Per funzionare regolarmente useremo l'utente operatore creato in precedenza, dobbiamo regolare le opzioni di esecuzione del comando come superutente, per il quale eseguiamo il seguente comando:

visto

Questo comando fondamentalmente permette di modificare il file / etc / sudoers; in cui dovremmo contenere queste righe:

Predefiniti env_reset, timestamp_timeout = 0% sudo ALL = (ALL: ALL) ALL

Nella prima riga l'opzione viene aggiunta ai valori predefiniti timestamp_timeout che consente di impostare il tempo di scadenza (in minuti) della password quando viene eseguito il comando sudo. Il valore predefinito è 5, ma a volte non è sicuro per due motivi:

1. Se inavvertitamente lasciamo il nostro computer connesso prima che la password scada, qualcuno potrebbe eseguire un comando come root senza alcuna restrizione.
2. Se per ignoranza eseguiamo un'applicazione o uno script che contiene codice dannoso prima della scadenza della password, l'applicazione potrebbe avere accesso al nostro sistema come superutente, senza il nostro esplicito consenso.

Quindi per evitare rischi, abbiamo impostato il valore a zero, ovvero, ogni volta che viene eseguito il comando sudo, dovrà essere inserita la password. Se un valore negativo è impostato come -1, l'effetto è che la password non scade mai, il che produrrebbe il risultato opposto di quello che vogliamo.

La seconda riga chiarisce che il gruppo sudo può eseguire qualsiasi comando su qualsiasi computer, il che è normale, sebbene possa essere regolato. (3) C'è chi per comodità mette la riga così per evitare di dover digitare la password:

% sudo ALL = (ALL: ALL) NOPASSWD: ALL

Tuttavia, come abbiamo spiegato prima, questo è rischioso e quindi non è raccomandato.

Disabilita il riavvio

Per motivi di sicurezza, disabiliteremo anche il riavvio utilizzando la combinazione di tasti Ctrl + Alt + Canc, per il quale dobbiamo aggiungere questa riga nel file /etc/inittab:

ca: 12345: ctrlaltdel: / bin / echo "Ctrl + Alt + Canc è stato disabilitato."

Sostituisci OpenSSH con DropBear

La maggior parte dei VPS viene fornita con OpenSSH installato, il che è sicuramente molto utile, ma a meno che non sia necessario sfruttare tutte le funzionalità di OpenSSH, ci sono alternative più leggere per un VPS, come Dropbear Drop, che di solito è sufficiente per un uso regolare. Tuttavia, uno svantaggio di questa applicazione è che non viene fornita con un server SFTP integrato, ed è per questo che all'inizio abbiamo installato il pacchetto gesftpserver.

Per configurare Dropbear, modificheremo il file / etc / default / dropbear in modo che contenga queste due righe:

NO_START = 0 DROPBEAR_EXTRA_ARGS = "- w -p 127.0.0.1:22 -I 1200 -m"

La prima riga abilita semplicemente il servizio e la seconda fa diverse cose:

1. Evita l'accesso root.
2. Rende il servizio in ascolto sulla porta 22 dell'interfaccia locale (spiegheremo il motivo in seguito).
3. Imposta il tempo di attesa (20 minuti).

SSLH

La porta 22 (SSH) è ben nota ed è generalmente una delle prime che gli hacker tentano di violare, quindi useremo invece la porta 443 (SSL). Succede che questa porta viene utilizzata per la navigazione sicura su HTTPS.

Per questo utilizzeremo il pacchetto sslh, che altro non è che un multiplexer che analizza i pacchetti che arrivano alla porta 443, e li instrada internamente ad un servizio o ad un altro a seconda che il tipo di traffico sia SSH o SSL.

SSLH non può ascoltare su un'interfaccia in cui un altro servizio è già in ascolto, motivo per cui in precedenza abbiamo fatto ascoltare Dropbear sull'interfaccia locale.

Ora quello che dobbiamo fare è indicare a sslh l'interfaccia e la porta attraverso la quale dovrebbe ascoltare e dove reindirizzare i pacchetti a seconda del tipo di servizio, e per questo modificheremo il file di configurazione / etc / default / sslh:

DAEMON = / usr / sbin / sslh DAEMON_OPTS = "- user sslh --listen 250.250.250.155:443 --ssh 127.0.0.1:22 --ssl 127.0.0.1:443 --pidfile / var / run / sslh / sslh. pid "RUN = sì

Infine, riavviamo i servizi:

service ssh stop & & service dropbear start & & service sslh restart

Dopo il comando precedente, la nostra sessione sicura verrà probabilmente interrotta, nel qual caso è sufficiente effettuare nuovamente il login, ma questa volta con l'utente di lavoro e utilizzando la porta 443. Se la sessione non viene interrotta, è consigliabile chiuderla e ricominciare con i valori appropriati.

Se tutto funziona correttamente, possiamo continuare a lavorare come root e, se lo desideriamo, disinstallare OpenSSH:

sudo su - aptitude -r elimina openssh-server

cortafuegos

La prossima cosa che faremo è separare i log dal firewall in un file separato /var/log/firewall.log per facilitare ulteriori analisi, motivo per cui abbiamo installato il pacchetto ulogd all'avvio. Per questo modificheremo il file /etc/logd.conf per regolare la sezione pertinente:

[LOGEMU] file = "/ var / log / firewall.log" sync = 1

Successivamente, modificheremo il file di rotazione del record / etc / logrotate / ulogd per mantenere una rotazione giornaliera (con data) e salvare le salve compresse nella directory / var / log / ulog /:

/var/log/ulog/*.log /var/log/firewall.log {daily dateext missingok compress delaycompress sharedscripts create 640 root adm postrotate /etc/init.d/ulogd reload mv /var/log/firewall.log-* .gz / var / log / ulog / endscript}

Quindi creeremo le regole di netfilter eseguendo quanto segue:

IPT = $ (quale iptables) IPEXT = 250.250.250.155 IPEXTBLK = 250.250.0.0 / 16 IPBCAST = 255.255.255.255 $ IPT -F $ IPT -X $ IPT -Z $ IPT -A INPUT -i lo -j ACCEPT $ IPT - P INPUT DROP $ IPT -P FORWARD DROP $ IPT -P OUTPUT ACCEPT $ IPT -A INPUT -m state --state INVALID -j ULOG --ulog-prefix IN_INVALID $ IPT -A INPUT -p igmp -j ULOG --ulog -prefisso IN_IGMP $ IPT -A INPUT -m pkttype --pkt-type broadcast -j ULOG --ulog-prefix IN_BCAST $ IPT -A INPUT -m pkttype --pkt-type multicast -j ULOG --ulog-prefix IN_MCAST $ IPT -A FORWARD -j ULOG --ulog-prefix FORWARD $ IPT -N ICMP_IN $ IPT -A INPUT!  -i lo -p icmp -j ICMP_IN $ IPT -A ICMP_IN -p icmp -f -j ULOG --ulog-prefix IN_ICMP_FRAGMENTED $ IPT -A ICMP_IN -p icmp -m icmp -m length!  --length 28: 1322 -j ULOG --ulog-prefix IN_ICMP_INVALIDSIZE $ IPT -A ICMP_IN -p icmp -m icmp -m hashlimit --hashlimit-above 4 / sec --hashlimit-mode srcip --hashlimit-srcmask 24 - -hashlimit-name icmpflood -j ULOG --ulog-prefix IN_ICMP_FLOOD $ IPT -A ICMP_IN -p icmp -m icmp -m hashlimit --hashlimit-upto 64kb / min --hashlimit-mode srcip --hashlimit-srcmask 24 - hashlimit -name icmpattack -j ULOG --ulog-prefix IN_ICMP_FLOOD $ IPT -A ICMP_IN -p icmp -m icmp -m u32!  --u32 "0x4 & 0x3fff = 0x0" -j ULOG --ulog-prefix IN_ICMP_ATTACK $ IPT -A ICMP_IN -p icmp -m icmp!  --icmp-type echo-request -m state --state NEW -j ULOG --ulog-prefix IN_ICMP_INVALID $ IPT -A ICMP_IN -p icmp -m icmp --icmp-type echo-request -j ULOG --ulog- prefisso IN_ICMP $ IPT -A ICMP_IN -p icmp -m icmp --icmp-type echo-request -m limit --limit 1 / sec --limit-burst 4 -j ACCEPT $ IPT -A ICMP_IN -p icmp -m icmp --icmp-type echo-reply -m limit --limit 2 / sec --limit-burst 4 -j ACCEPT $ IPT -A ICMP_IN -p icmp -m icmp --icmp-type destination-unreachable -m limit - limit 2 / sec --limit-burst 4 -j ACCEPT $ IPT -A ICMP_IN -p icmp -m icmp --icmp-type tempo superato -m limit --limit 2 / sec --limit-burst 4 -j ACCEPT $ IPT -A ICMP_IN -p icmp -m icmp --icmp-type problema-parametro -m limit --limit 2 / sec --limit-burst 4 -j ACCEPT $ IPT -A ICMP_IN -j RETURN $ IPT -N UDP_IN $ IPT -A INPUT!  -i lo -p udp -j UDP_IN $ IPT -A UDP_IN!  -i lo!  -p udp -f -j ULOG --ulog-prefix IN_UDP_FRAGMENTED $ IPT -A UDP_IN -p udp -m udp --sport 53 -m di lunghezza!  --length 28: 576 -j ULOG --ulog-prefix IN_UDP_DNS_INVALIDSIZE $ IPT -A UDP_IN -p udp -m udp --dport 53 -m -state --state NEW -j ULOG --ulog-prefix IN_UDP_DNSREQUEST $ IPT - A UDP_IN -p udp -m udp --dport 53 -m -state --state NUOVO -j REJECT --reject-with icmp-port-unreachable $ IPT -A UDP_IN -p udp -m udp!  - sport 53!  -s $ IPEXTBLK!  -d $ IPBCAST -m state --state NEW -j ULOG --ulog-prefix IN_UDP $ IPT -A UDP_IN -p udp -m udp -m state --state ESTABLISHED, RELATED -j ACCEPT $ IPT -A UDP_IN -j RETURN $ IPT -N TCP_IN $ IPT -A INPUT!  -i lo -p tcp -j TCP_IN $ IPT -A TCP_IN!  -i lo!  -p tcp -f -j ULOG --ulog-prefix IN_TCP_FRAGMENTED $ IPT -A TCP_IN -p tcp -m tcp --sport 53 -m state --state ESTABLISHED, RELATED -m length!  --length 513: 1500 -j ULOG --ulog-prefix IN_TCP_DNS_INVALIDSIZE $ IPT -A TCP_IN -p tcp -m tcp --dport 53 -m state --state NEW -j ULOG --ulog-prefix IN_TCP_DNS $ IPT -A TCP_IN -p tcp -m tcp --dport 53 -m state --state NEW -j REJECT --reject-with icmp-port-unreachable $ IPT -A TCP_IN -p tcp -m tcp -m multiporta!  --dports 80,443 -m state --state NEW -j ULOG --ulog-prefix IN_TCP $ IPT -A TCP_IN -p tcp -m tcp -m multiporta --dports 80,443 -m state --state NEW -m hashlimit - hashlimit -fino a 4 / sec --hashlimit-burst 16 --hashlimit-mode srcip --hashlimit-name navreq -j ACCEPT $ IPT -A TCP_IN -p tcp -m tcp -m multiporta --dports 80,443 -m state - state ESTABLISHED -m connlimit!  --connlimit-above 16 -j ACCETTA $ IPT -A TCP_IN -p tcp -m tcp -m multiporta! 

Con la configurazione precedente, il nostro VPS dovrebbe essere ragionevolmente protetto, ma se lo desideriamo possiamo assicurarlo un po 'di più, per il quale possiamo utilizzare alcune regole più avanzate.

Non tutti i VPS consentono l'installazione di moduli aggiuntivi per netfilter, ma uno è molto utile PSD, che consente di evitare le scansioni delle porte. Sfortunatamente, questo modulo non è integrato in netfilter per impostazione predefinita, quindi è necessario installare alcuni pacchetti e quindi compilare il modulo:

aptitude -RvW installa iptables-dev xtables-addons-source module-assistant module-assistant --verbose - text-mode auto-install xtables-addons-source

Una volta fatto quanto sopra, possiamo aggiungere una regola come questa:

iptables -A INPUT -m psd --psd-weight-threshold 15 --psd-delay-threshold 2000 --psd-lo-port-weight 3 --psd-hi-ports-weight 1 -j ULOG --ulog- prefisso IN_PORTSCAN

La regola precedente significa fondamentalmente che creeremo un contatore che aumenterà di 3 ogni volta che viene effettuato un tentativo di accedere a una porta inferiore a 1024 e di 1 ogni volta che viene effettuato un tentativo di accesso a una porta superiore a 1023, e quando questo contatore raggiunge 15 in un periodo inferiore a 20 secondi, i pacchi verranno registrati da Ulog come tentativo di portscan. I pacchetti potrebbero comunque essere scartati subito, ma in questo caso intendiamo utilizzarli fail2ban, che configureremo in seguito.

Una volta create le regole, dobbiamo prendere alcune precauzioni per renderle persistenti, altrimenti le perderemo al riavvio del server. Esistono diversi modi per eseguire questa operazione; In questo tutorial useremo il pacchetto iptables-persistent che abbiamo installato all'inizio, che memorizza le regole in /etc/iptables/rules.v4 y /etc/iptables/rules.v6 per ipv6.

iptables-save> /etc/iptables/rules.v4

Infatti, sebbene l'uso di ipv6 a Cuba non sia ancora diffuso, potremmo benissimo creare alcune regole di base:

IPT = $ (che ip6tables) $ IPT -P INPUT DROP $ IPT -P FORWARD DROP $ IPT -P OUTPUT ACCEPT $ IPT -A INPUT -i lo -j ACCEPT $ IPT -A INPUT! -i lo -m state --state ESTABLISHED, RELATED -j ACCEPT unset IPT

Queste regole possono anche essere rese persistenti:

ip6tables-save> /etc/iptables/rules.v6

Infine, per una maggiore sicurezza, puliamo il registro del firewall e riavviamo i servizi:

echo -n> /var/log/firewall.log servizio logrotate riavvio servizio ulogd riavvio servizio iptables-persistent restart

Nginx

Useremo Nginx come server web, perché i VPS di solito hanno una quantità di RAM ridotta rispetto a un server reale, quindi è generalmente conveniente avere qualcosa di più leggero di Apache.

Prima di configurare Nginx, creeremo un certificato (senza password) da utilizzare su HTTPS:

cd / etc / nginx openssl genrsa -des3 -out cert.key 4096 cp -v cert.key cert.key.original openssl req -new -key cert.key -out cert.csr openssl rsa -in cert.key.original - out cert.key openssl x509 -req -days 365 -in cert.csr -signkey cert.key -out cert.crt

Fatto ciò, creeremo un file di password per l'utente "elusuario":

htpasswd -c .htpasswd l'utente

Successivamente, modificheremo il file / etc / nginx / sites-available / default per impostare le preferenze del sito predefinite. Potrebbe assomigliare a questo:

server {nome_server localhost; index index.html index.htm default.html default.htm; root / var / www; location / {# imposta l'ordine di verifica e la pagina da caricare, se l'URI non viene trovato try_files $ uri $ uri / /index.html; }} server {ascolta 127.0.0.1:443; nome_server localhost; index index.html index.htm default.html default.htm; root / var / www; ssl su; ssl_certificate cert.crt; ssl_certificate_key cert.key; ssl_session_timeout 5m; # Abilita HTTPS solo su TLS (più sicuro di SSL) ssl_protocols TLSv1 TLSv1.1 TLSv1.2; # dai la preferenza alle cifrature [HIGH] ad alta resistenza, # sposta le cifre [MEDIUM] di media intensità alla fine della lista, # disabilita le cifrature [LOW] a bassa intensità (40 e 56 bit) # disabilita le cifrature con algoritmi di esportazione [EXP] # disabilita cifrature null [eNULL], senza autenticazione [aNULL], SSL (versioni 2 e 3) e DSS (solo chiavi fino a 1024 bit) ssl_ciphers HIGH: + MEDIUM :! LOW :! EXP: ! aNULL :! eNULL :! SSLv3 :! SSLv2 :! DSS; # Preferisce i metodi di crittografia del server (per impostazione predefinita vengono utilizzati i client) ssl_prefer_server_ciphers on; location / {# enable authentication auth_basic "Login"; auth_basic_user_file /etc/nginx/.htpasswd; # imposta l'ordine di verifica e il codice della pagina da caricare, se l'URI try_files $ uri $ uri / = 404 non viene trovato; # consente la creazione di un indice per gli utenti autenticati autoindex su; autoindex_exact_size off; autoindex_localtime on; }}

Controlliamo che la configurazione sia corretta:

nginx -t

Infine, riavviamo il servizio:

riavviare il servizio nginx

Fail2Ban

Prima di iniziare a configurare Fail2Ban, per maggiore sicurezza arrestiamo il servizio e puliamo il registro:

fail2ban-client stop echo -n> /var/log/fail2ban.log

Successivamente, creiamo il file di configurazione /etc/fail2ban/jail.local con il seguente contenuto personalizzato:

# File di configurazione personalizzato /etc/fail2ban/jail.local # [DEFAULT] findtime = 43200; 12 ore bantime = 86400; 1 giorno maxretry = 3; il divieto avrà effetto dopo il quarto tentativo [ssh] enabled = false [nginx-auth] enabled = true filter = nginx-auth action = iptables-multiport [name = NoAuthFailures, port = "http, https"] logpath = / var / log / nginx * / * error * .log [nginx-badbots] enabled = true filter = apache-badbots action = iptables-multiport [name = BadBots, port = "http, https"] logpath = / var / log / nginx * /*access*.log bantime = 4; 604800 settimana maxretry = 1 [nginx-login] abilitato = true filter = nginx-login action = iptables-multiport [name = NoLoginFailures, port = "http, https"] logpath = / var / log / nginx * / * access *. log bantime = 0; 1800 minuti [nginx-noscript] enabled = true action = iptables-multiport [name = NoScript, port = "http, https"] filter = nginx-noscript logpath = /var/log/nginx*/*access*.log maxretry = 30 [nginx-proxy] abilitato = true action = iptables-multiport [name = NoProxy, port = "http, https"] filtro = nginx-proxy logpath = /var/log/nginx*/*access*.log bantime = 0 ; 604800 settimana maxretry = 1 [firewall] abilitato = vera azione = iptables-multiport [nome = Firewall] filtro = firewall logpath = /var/log/firewall.log maxretry = 0

Fatto ciò, creiamo nella directory /etc/fail2ban/filters.d/ i seguenti file:

# /etc/fail2ban/filter.d/nginx-auth.conf # Filtro di autenticazione # Blocca gli IP che non riescono ad autenticarsi utilizzando l'autenticazione di base # [Definizione] failregex = nessun utente / password è stato fornito per l'autenticazione di base. * client: user. * non è stato trovato in. * client: utente. * mancata corrispondenza della password. * client: ignoreregex =

# /etc/fail2ban/filter.d/nginx-login.conf # Filtro di accesso # Blocca gli IP che non riescono ad autenticarsi utilizzando la pagina di accesso dell'applicazione web # Scansione del registro di accesso per HTTP 200 + POST / sessioni => accesso non riuscito # [Definizione ] failregex = ^ -. * POST / sessioni HTTP / 1 \ .. "200 ignoreregex =

# /etc/fail2ban/filter.d/nginx-noscript.conf # Filtro Noscript # Blocca gli IP che tentano di eseguire script come .php, .pl, .exe e altri script divertenti. # Corrisponde ad es. # 192.168.1.1 - - "GET /qualcosa.php # [Definizione] failregex = ^ -. * GET. * (\. Php | \ .asp | \ .exe | \ .pl | \ .cgi | \ scgi) ignoreregex =

# /etc/fail2ban/filter.d/proxy.conf # Filtro proxy # Blocca gli IP che tentano di utilizzare il server come proxy. # Corrisponde ad es. # 192.168.1.1 - - "GET http://www.something.com/ # [Definition] failregex = ^ -. * OTTIENI http. * Ignoreregex =

# /etc/fail2ban/filter.d/firewall.conf # Filtro firewall # [Definizione] failregex = ^. * IN_ (INVALID | PORTSCAN | UDP | TCP |). * SRC = . * $ ignoreregex =

Infine, avviamo il servizio e carichiamo la configurazione:

fail2ban-service -b fail2ban-client ricaricare

Verifica

Come ultimo passaggio, possiamo visualizzare i record con coda -f o multicoda – segui tutto. Quest'ultima applicazione, infatti, offre il vantaggio di poter visualizzare più file contemporaneamente e di fornire un'evidenziazione della sintassi di base.

Nel caso in cui un account di posta elettronica non sia configurato nel VPS, è consigliabile disabilitare un messaggio di avviso che compare all'avvio di multitail, per il quale eseguiremo il seguente comando:

echo "check_mail: 0"> ~ / .multitailrc

In effetti, potremmo creare un alias (4) per visualizzare rapidamente i log con un breve comando, ad esempio "flog":

alias flog = 'multitail --follow-all /var/log/firewall.log /var/log/fail2ban.log'

1) Questi sono valori fittizi.
2) Abilitare altri servizi è facile una volta capito come funziona.
3) Per maggiori dettagli, esegui man sudoers.
4) Facoltativamente potrebbe essere aggiunto al file ~ / .bash_aliases