Networking per Svogliati

# Query base: A record
dig esempio.it
dig esempio.it A

# Query specifica per tipo
dig esempio.it MX
dig esempio.it TXT
dig esempio.it NS

# Chiedi a un resolver specifico (bypass della cache locale)
dig @8.8.8.8 esempio.it        # Google
dig @1.1.1.1 esempio.it        # Cloudflare
dig @9.9.9.9 esempio.it        # Quad9

# Reverse DNS (PTR)
dig -x 93.184.216.34

# Traccia l'intera risoluzione gerarchica
dig +trace esempio.it

# Solo la risposta, niente rumore
dig +short esempio.it
93.184.216.34

# Su Windows: nslookup (meno potente ma c'è)
nslookup esempio.it 8.8.8.8

#!/usr/sbin/nft -f

flush ruleset

table inet filter {
    chain input {
        type filter hook input priority 0; policy drop;

        # Loopback: sempre permesso
        iifname lo accept

        # Connessioni già stabilite: lasciale passare
        ct state established,related accept

        # ICMP: ping e path MTU (non bloccare tutto o ti rompi cose)
        icmp type echo-request accept
        icmpv6 type { echo-request, nd-neighbor-solicit, nd-router-advert } accept

        # SSH: solo da IP specifico (modifica con il tuo)
        ip saddr 10.0.0.0/8 tcp dport 22 accept

        # Web pubblico
        tcp dport { 80, 443 } accept

        # Log e drop di tutto il resto
        log prefix "[nft drop] " drop
    }

    chain forward {
        type filter hook forward priority 0; policy drop;
    }

    chain output {
        type filter hook output priority 0; policy accept;
    }
}

# Mostra tutte le regole
nft list ruleset

# Applica configurazione
nft -f /etc/nftables.conf

# Abilita al boot
systemctl enable nftables

# Aggiungi regola al volo (temporanea)
nft add rule inet filter input tcp dport 8080 accept

# Svuota tutto (attento: espone il server)
nft flush ruleset

# Abilita ufw (policy default: deny in, allow out)
ufw enable

# Permetti servizi
ufw allow ssh            # porta 22
ufw allow 80/tcp
ufw allow 443/tcp
ufw allow from 10.0.0.0/8 to any port 5432  # PostgreSQL solo da rete interna

# Blocca
ufw deny from 1.2.3.4

# Stato e regole
ufw status verbose
ufw status numbered

# Rimuovi regola per numero
ufw delete 3

# Reset completo (torna a tutto aperto)
ufw reset

# Lista regole
Get-NetFirewallRule | Where-Object Enabled -eq True | Select DisplayName,Direction,Action

# Aggiungi regola in ingresso
New-NetFirewallRule -DisplayName "Allow 8080" -Direction Inbound -Protocol TCP -LocalPort 8080 -Action Allow

# Via netsh (vecchio stile ma ovunque)
netsh advfirewall firewall add rule name="Allow 8080" dir=in action=allow protocol=TCP localport=8080

# Disabilita completamente (non farlo in produzione)
Set-NetFirewallProfile -Profile Domain,Public,Private -Enabled False

# Installa
apt install wireguard

# Genera coppia di chiavi (server)
wg genkey | tee /etc/wireguard/server_private.key | wg pubkey > /etc/wireguard/server_public.key
chmod 600 /etc/wireguard/server_private.key

# /etc/wireguard/wg0.conf — SERVER
[Interface]
PrivateKey = <contenuto di server_private.key>
Address = 10.10.0.1/24
ListenPort = 51820
PostUp   = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

[Peer]                        # un peer per ogni client
PublicKey = <public key del client>
AllowedIPs = 10.10.0.2/32

# Abilita IP forwarding
echo "net.ipv4.ip_forward=1" >> /etc/sysctl.conf && sysctl -p

# Avvia
systemctl enable --now wg-quick@wg0
wg show

[Interface]
PrivateKey = <client private key>
Address = 10.10.0.2/24
DNS = 10.10.0.1          # opzionale: usa il DNS del server

[Peer]
PublicKey = <server public key>
Endpoint = server.esempio.it:51820
AllowedIPs = 0.0.0.0/0   # tutto il traffico via VPN (full tunnel)
# AllowedIPs = 10.10.0.0/24  # solo traffico verso la VPN (split tunnel)
PersistentKeepalive = 25  # mantieni vivo attraverso NAT

server {
    listen 80;
    server_name app.esempio.it;
    # Redirect HTTP → HTTPS
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    server_name app.esempio.it;

    ssl_certificate     /etc/letsencrypt/live/app.esempio.it/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/app.esempio.it/privkey.pem;

    # Header di sicurezza (non saltare questi)
    add_header X-Frame-Options DENY;
    add_header X-Content-Type-Options nosniff;
    add_header Strict-Transport-Security "max-age=31536000" always;

    location / {
        proxy_pass         http://127.0.0.1:3000;
        proxy_http_version 1.1;
        proxy_set_header   Host $host;
        proxy_set_header   X-Real-IP $remote_addr;
        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header   X-Forwarded-Proto $scheme;
        proxy_set_header   Upgrade $http_upgrade;   # per WebSocket
        proxy_set_header   Connection "upgrade";
    }
}

app.esempio.it {
    reverse_proxy localhost:3000
}

# Sì, è tutto. Caddy prende il certificato da solo.
# Non ti serve nient'altro per HTTPS in produzione.
# La prima volta che lo vedi ti sembra troppo facile.

# Apri tunnel SOCKS5 sulla porta locale 1080
ssh -D 1080 -N -f user@server-remoto.it
# -D: SOCKS dynamic port forwarding
# -N: non eseguire comandi, solo il tunnel
# -f: vai in background

# Poi configura il browser per usare SOCKS5 127.0.0.1:1080
# Tutto il traffico del browser passa attraverso il server remoto

# Oppure usa curl con il proxy
curl --socks5 127.0.0.1:1080 https://ifconfig.me
1.2.3.4  # IP del server remoto, non tuo

# Linux: visualizza routing table
ip route show
default via 192.168.1.1 dev eth0 proto dhcp      # default gateway
192.168.1.0/24 dev eth0 proto kernel scope link   # rete locale
10.10.0.0/24 dev wg0 proto kernel scope link       # rete VPN

# Aggiungi route statica
ip route add 10.20.0.0/24 via 192.168.1.254
ip route add 10.20.0.0/24 via 192.168.1.254 dev eth0

# Rimuovi route
ip route del 10.20.0.0/24

# Cambia default gateway
ip route replace default via 192.168.1.2

# Windows
route print
route add 10.20.0.0 mask 255.255.255.0 192.168.1.254

# Traccia il percorso verso una destinazione
traceroute 8.8.8.8           # Linux/Mac
tracert 8.8.8.8              # Windows
mtr 8.8.8.8                  # Linux: traceroute continuo con statistiche

# Abilita IP forwarding
sysctl -w net.ipv4.ip_forward=1

# NAT masquerade con iptables (interfaccia pubblica = eth0)
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
iptables -A FORWARD -i eth1 -o eth0 -j ACCEPT
iptables -A FORWARD -i eth0 -o eth1 -m state --state RELATED,ESTABLISHED -j ACCEPT

# Port forwarding: porta 80 esterna → server interno 192.168.1.10:80
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j DNAT --to-destination 192.168.1.10:80

# Con nftables (più moderno)
nft add rule ip nat postrouting oifname "eth0" masquerade
nft add rule ip nat prerouting iifname "eth0" tcp dport 80 dnat to 192.168.1.10

# Installa certbot
apt install certbot python3-certbot-nginx

# Ottieni certificato e configura nginx automaticamente
certbot --nginx -d esempio.it -d www.esempio.it

# Solo certificato (configuri nginx a mano)
certbot certonly --nginx -d esempio.it

# Rinnovo manuale (di solito è automatico via timer systemd)
certbot renew --dry-run   # testa il rinnovo senza farlo
certbot renew

# I certificati finiscono in:
/etc/letsencrypt/live/esempio.it/fullchain.pem
/etc/letsencrypt/live/esempio.it/privkey.pem

# Scadenza: verifica
openssl x509 -in /etc/letsencrypt/live/esempio.it/fullchain.pem -noout -dates

# Controlla certificato di un sito live
openssl s_client -connect esempio.it:443 -servername esempio.it < /dev/null
echo | openssl s_client -connect esempio.it:443 2>/dev/null | openssl x509 -noout -dates -subject

# Genera chiave privata e CSR (Certificate Signing Request)
openssl genrsa -out server.key 4096
openssl req -new -key server.key -out server.csr

# Genera certificato self-signed (test locale)
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes

# Verifica che chiave e certificato combacino
openssl x509 -noout -modulus -in cert.pem | md5sum
openssl rsa  -noout -modulus -in key.pem  | md5sum
# Se i md5 coincidono: fanno coppia

# Controlla chain completa
openssl verify -CAfile chain.pem cert.pem

# Scan base: host attivi in una subnet
nmap -sn 192.168.1.0/24

# Porte TCP più comuni su un host
nmap 192.168.1.100

# Scan completo tutte le porte TCP
nmap -p- 192.168.1.100

# Con rilevamento versione servizi e OS
nmap -sV -O 192.168.1.100

# Script NSE per vulnerabilità comuni
nmap --script vuln 192.168.1.100

# Scan veloce (-T4) con output verboso
nmap -T4 -v 192.168.1.0/24

# UDP scan (lento ma necessario per DNS/SNMP/etc)
nmap -sU -p 53,123,161 192.168.1.100

# Output su file (tutti i formati)
nmap -oA scan_result 192.168.1.0/24

# Tutto il traffico su eth0
tcpdump -i eth0

# Filtra per host
tcpdump -i eth0 host 8.8.8.8

# Filtra per porta
tcpdump -i eth0 port 443

# HTTP su qualsiasi porta con payload leggibile
tcpdump -i eth0 -A port 80

# Cattura su file, poi analizza con Wireshark
tcpdump -i eth0 -w cattura.pcap
tcpdump -r cattura.pcap

# Filtro composito: TCP dalla 192.168.1.10 verso porta 443
tcpdump -i eth0 'src 192.168.1.10 and tcp dst port 443'

# Wireshark: interfaccia grafica, apri il .pcap
# oppure cattura live: File → Capture → interfaccia

# Porte in ascolto (il comando che usi ogni 5 minuti)
ss -tlnp
# -t: TCP  -l: listening  -n: numerici  -p: processo

# Tutte le connessioni stabilite
ss -tnp

# UDP in ascolto
ss -ulnp

# Filtra per porta
ss -tlnp sport = :443

# Chi usa la porta 3000?
ss -tlnp | grep :3000
lsof -i :3000          # alternativa, mostra anche il processo
fuser 3000/tcp         # solo il PID

# Equivalente Windows
netstat -ano | findstr :3000
Get-NetTCPConnection -LocalPort 3000

# Ping base
ping -c 4 8.8.8.8          # layer 3: IP raggiungibile?
ping -c 4 google.com       # anche DNS funziona?

# MTR: traceroute continuo con statistiche latenza/loss
mtr 8.8.8.8
mtr --report 8.8.8.8      # output non interattivo

# curl: testa HTTP/HTTPS
curl -I https://esempio.it             # solo headers
curl -v https://esempio.it             # verbose: mostra TLS handshake
curl -o /dev/null -w "%{http_code}\n" https://esempio.it   # solo status code
curl -L https://esempio.it             # segui redirect
curl --resolve esempio.it:443:1.2.3.4 https://esempio.it   # forza IP specifico

# Test connettività TCP a una porta (senza curl)
nc -zv 192.168.1.10 5432   # PostgreSQL raggiungibile?
nc -zv -w 3 1.2.3.4 22    # SSH raggiungibile con timeout 3s?

[DEFAULT]
bantime  = 1h
findtime = 10m
maxretry = 5
banaction = nftables-multiport   # o iptables-multiport

[sshd]
enabled = true
port    = ssh
logpath = %(sshd_log)s

[nginx-http-auth]
enabled = true
port    = http,https
logpath = %(nginx_error_log)s

[nginx-botsearch]
enabled  = true
port     = http,https
logpath  = %(nginx_access_log)s
maxretry = 2

fail2ban-client status
fail2ban-client status sshd
fail2ban-client set sshd unbanip 1.2.3.4   # sblocca (te stesso)