Centro di Conoscenza DevOps
Centro di Conoscenza DevOps

Proteggere le connessioni PostgreSQL con la configurazione SSL/TLS: Una guida completa

Scopri come proteggere le connessioni PostgreSQL con la crittografia SSL/TLS. Questa guida completa copre la configurazione lato server e client, inclusa la generazione di certificati, la modifica di `postgresql.conf` e `pg_hba.conf` e l'impostazione dei client per una comunicazione sicura e crittografata. Proteggi i tuoi dati sensibili in transito e assicurati la conformità con i moderni standard di sicurezza.

98 visualizzazioni

Proteggere le Connessioni PostgreSQL con la Configurazione SSL/TLS: Una Guida Completa

Nel panorama digitale interconnesso odierno, la sicurezza dei dati in transito è di primaria importanza. PostgreSQL, un potente database relazionale open source, offre robusti meccanismi per crittografare le connessioni utilizzando SSL/TLS. Questa guida fornisce una panoramica completa della configurazione di server e client PostgreSQL per imporre la crittografia SSL/TLS, proteggendo le informazioni sensibili da intercettazioni e attacchi man-in-the-middle su reti non attendibili. L'implementazione di queste misure di sicurezza è fondamentale per mantenere l'integrità dei dati, garantire la conformità con rigorosi standard di sicurezza e costruire fiducia con i tuoi utenti.

Questo articolo coprirà i passaggi essenziali, dalla generazione o l'ottenimento dei certificati SSL alla configurazione di PostgreSQL per utilizzarli, e infine, l'impostazione dei client per connessioni sicure. Approfondiremo i parametri di configurazione necessari e forniremo esempi pratici per aiutarti a implementare questi miglioramenti di sicurezza in modo efficace.

Comprendere SSL/TLS in PostgreSQL

SSL/TLS (Secure Sockets Layer/Transport Layer Security) è un protocollo crittografico progettato per fornire sicurezza nelle comunicazioni su una rete di computer. Quando applicato a PostgreSQL, crittografa i dati scambiati tra il server di database e i suoi client. Ciò impedisce a parti non autorizzate di intercettare e leggere informazioni sensibili come credenziali, dati finanziari o dettagli personali.

PostgreSQL supporta le seguenti modalità per SSL/TLS:

  • ssl=on: Consente connessioni SSL ma non le richiede. I client possono connettersi utilizzando connessioni SSL o non-SSL.
  • ssl=prefer: Tenta di stabilire una connessione SSL ma ricade su una connessione non-SSL se fallisce.
  • ssl=require: Richiede connessioni SSL. Se una connessione SSL non può essere stabilita, la connessione client verrà rifiutata.

Imporre ssl=require è l'opzione più sicura per proteggere i dati in transito.

Prerequisiti per la Configurazione SSL/TLS

Prima di iniziare a configurare PostgreSQL per SSL/TLS, assicurati di avere quanto segue:

  1. OpenSSL Installato: Il toolkit OpenSSL è essenziale per generare e gestire i certificati SSL. Di solito è preinstallato sui sistemi Linux e macOS. Per Windows, potrebbe essere necessario scaricarlo e installarlo separatamente.
  2. Accesso ai File di Configurazione di PostgreSQL: Avrai bisogno dei privilegi amministrativi per modificare i file postgresql.conf e pg_hba.conf.
  3. Comprensione delle Autorità di Certificazione (CA): Sebbene tu possa creare certificati autofirmati per i test, gli ambienti di produzione dovrebbero idealmente utilizzare certificati firmati da un'Autorità di Certificazione (CA) fidata o da una CA aziendale interna.

Configurazione SSL/TLS Lato Server

La configurazione lato server prevede l'abilitazione di SSL, la specificazione della posizione dei certificati e delle chiavi SSL e la configurazione dell'autenticazione client.

1. Generare o Ottenere Certificati e Chiavi SSL

Ci sono due modi principali per ottenere certificati SSL per il tuo server PostgreSQL:

  • Certificati Autofirmati (per test/sviluppo): Questi vengono creati usando OpenSSL e non sono fidati per impostazione predefinita dai client esterni. Sono utili per la configurazione iniziale e i test interni.
  • Certificati da un'Autorità di Certificazione (CA) (per la produzione): Ottieni certificati da una CA pubblica fidata (ad esempio, Let's Encrypt, DigiCert) o da una CA aziendale interna. Questo assicura che i client possano verificare l'identità del server.

Creazione di Certificati Autofirmati usando OpenSSL:

Questo è un approccio comune per ambienti di sviluppo e interni. Esegui i seguenti comandi sul tuo server PostgreSQL o su una macchina con OpenSSL:

  1. Crea una directory per i certificati: È buona pratica mantenere i certificati organizzati.
    bash sudo mkdir -p /etc/postgresql/ssl sudo chown postgres:postgres /etc/postgresql/ssl cd /etc/postgresql/ssl

  2. Genera la Chiave Privata del Server: Questa chiave dovrebbe essere mantenuta segreta.
    bash sudo openssl genrsa -des3 -out server.key 2048
    Ti verrà chiesto di inserire una passphrase. Ricorda questa passphrase, poiché ti servirà all'avvio di PostgreSQL.

  3. Rimuovi la Passphrase (opzionale ma consigliato per riavvii automatici): Per un avvio automatizzato senza immissione manuale della passphrase, rimuovi la passphrase. Sii estremamente cauto, poiché chiunque abbia accesso a questo file può impersonare il tuo server.
    bash sudo openssl rsa -in server.key -out server.key

  4. Crea una Richiesta di Firma del Certificato Server (CSR): Questa contiene informazioni sul tuo server.
    bash sudo openssl req -new -key server.key -out server.csr
    Ti verranno richieste informazioni come Nome Nazione, Stato, Nome Località, Nome Organizzazione, Nome Comune (questo dovrebbe essere il nome host o l'indirizzo IP del tuo server) e un indirizzo email.

  5. Firma il Certificato con la Tua CA (per uso interno):

    • Crea una chiave privata e un certificato CA root (se non ne hai uno):
      bash # Genera la chiave privata della CA sudo openssl genrsa -des3 -out root.key 2048 # Crea il certificato della CA (valido per 3650 giorni) sudo openssl req -new -x509 -days 3650 -key root.key -out root.crt
    • Firma il CSR del server con la CA: Questo crea il certificato server fidato.
      bash sudo openssl x509 -req -days 365 -in server.csr -CA root.crt -CAkey root.key -set_serial 01 -out server.crt

  6. Imposta i Permessi: Assicurati che l'utente PostgreSQL possa leggere questi file.
    bash sudo chown postgres:postgres server.key server.crt root.crt sudo chmod 600 server.key sudo chmod 644 server.crt root.crt

Utilizzo di Certificati da una CA Pubblica/Aziendale:

Se ottieni certificati da una CA, riceverai tipicamente:

  • server.crt: Il certificato pubblico del tuo server.
  • server.key: La chiave privata del tuo server.
  • root.crt (o simile): Il certificato root della CA (e potenzialmente certificati intermedi).

Posiziona questi file in una directory sicura (ad esempio, /etc/postgresql/ssl/) e assicurati che l'utente PostgreSQL abbia i permessi di lettura.

2. Configurazione di postgresql.conf

Modifica il file postgresql.conf (solitamente situato nella directory dei dati di PostgreSQL) per abilitare SSL e specificare i file dei certificati.

#------------------------------------------------------------------------------
# SSL
#------------------------------------------------------------------------------

ssl = on

# Questi sono tutti in formato PEM e vengono ignorati se la chiave/certificato del server
# non sono configurati. Per impostazione predefinita, i file dovrebbero trovarsi nella
# directory dei dati del server. In alternativa, possono essere specificati come percorsi completi.
ssl_cert_file = '/etc/postgresql/ssl/server.crt'     # (cambia nome file se necessario)
ssl_key_file = '/etc/postgresql/ssl/server.key'      # (cambia nome file se necessario)
ssl_ca_file = '/etc/postgresql/ssl/root.crt'         # (opzionale, per la verifica del certificato client)

# Opzionale: specifica l'elenco dei cifrari se necessario
#ssl_ciphers = 'HIGH:MEDIUM:+3DES:!aNULL'

# Opzionale: abilita la verifica del certificato client
#ssl_ca_file deve essere impostato su un file contenente i certificati CA da fidare
#ssl_crl_file = ''
#ssl_crl_dir = ''
  • ssl = on: Abilita il supporto SSL sul server.
  • ssl_cert_file: Percorso al certificato pubblico del server.
  • ssl_key_file: Percorso alla chiave privata del server.
  • ssl_ca_file: Percorso al certificato CA (se desideri verificare i certificati client o se il tuo certificato server è firmato da una CA personalizzata).

3. Configurazione di pg_hba.conf per l'Applicazione SSL

Il file pg_hba.conf controlla l'autenticazione client. Devi modificare le voci per imporre le connessioni SSL.

Per impostazione predefinita, le voci in pg_hba.conf appaiono così:

# TIPO  DATABASE        UTENTE            INDIRIZZO                 METODO
local   all             all                                     peer
# Connessioni locali IPv4:
host    all             all             127.0.0.1/32            scram-sha-256
# Connessioni locali IPv6:
host    all             all             ::1/128                 scram-sha-256

Per imporre SSL, cambia le voci host in hostssl:

# TIPO  DATABASE        UTENTE            INDIRIZZO                 METODO
local   all             all                                     peer
# Connessioni locali IPv4:
hostssl all             all             127.0.0.1/32            scram-sha-256
# Connessioni locali IPv6:
hostssl all             all             ::1/128                 scram-sha-256

# Esempio per l'accesso alla rete esterna - richiede SSL
hostssl all             all             0.0.0.0/0               scram-sha-256
hostssl all             all             ::/0                    scram-sha-256
  • hostssl: Questo tipo di record richiede connessioni SSL. Qualsiasi tentativo di connessione senza SSL verrà rifiutato.
  • hostnossl: Questo tipo di record proibisce esplicitamente le connessioni SSL.
  • host: Consente sia connessioni SSL che non-SSL (questo è il predefinito e meno sicuro).

4. Riavvio del Server PostgreSQL

Dopo aver modificato postgresql.conf e pg_hba.conf, devi riavviare il servizio PostgreSQL affinché le modifiche abbiano effetto.

# Per sistemi che usano systemd (la maggior parte delle distribuzioni Linux moderne)
sudo systemctl restart postgresql

# Per sistemi che usano init.d
sudo service postgresql restart

Configurazione SSL/TLS Lato Client

Anche i client devono essere configurati per connettersi in modo sicuro. Ciò comporta la specificazione dei parametri di connessione, la potenziale fornitura di certificati client e la verifica del certificato del server.

1. Parametri della Stringa di Connessione

Quando ti connetti tramite psql o qualsiasi libreria client PostgreSQL, puoi specificare i parametri SSL nella stringa di connessione o come opzioni individuali.

Connessione SSL Base (Solo Autenticazione Server):

psql "sslmode=require host=your_server_hostname dbname=your_db user=your_user"
  • sslmode: Controlla il comportamento SSL del client.
    • disable: Consente solo connessioni non-SSL.
    • allow: Consente non-SSL, ma preferisce SSL se il server lo supporta.
    • prefer (predefinito): Preferisce SSL, ma consente non-SSL se SSL fallisce.
    • require: Consente solo connessioni SSL. Se il server non supporta SSL, la connessione fallisce.
    • verify-ca: Consente solo connessioni SSL e verifica che il certificato del server sia firmato da una CA fidata. Il parametro sslrootcert deve essere impostato.
    • verify-full: Consente solo connessioni SSL, verifica il certificato del server rispetto a una CA fidata e verifica che il nome host del server corrisponda al nome comune (CN) o al nome alternativo del soggetto (SAN) del certificato.

Verifica del Certificato Server (verify-ca o verify-full):

Per una sicurezza avanzata, i client dovrebbero verificare l'identità del server. Ciò richiede che il client si fidi della CA che ha firmato il certificato del server.

  1. Ottieni il Certificato CA: Ottieni il file root.crt (o il certificato CA appropriato) che è stato utilizzato per firmare il certificato del server.
  2. Specifica sslrootcert: Indica al client dove trovare questo certificato CA.
psql "sslmode=verify-full host=your_server_hostname dbname=your_db user=your_user sslrootcert=/path/to/your/root.crt"

2. Certificati Client (Autenticazione Mutua)

Per un livello di sicurezza ancora più elevato, puoi implementare l'autenticazione mutua, dove il server verifica anche l'identità del client utilizzando i certificati client.

Generazione di Certificati Client:

Similmente ai certificati server, avrai bisogno di una chiave privata client e di un certificato client firmato da una CA fidata dal server (spesso la stessa CA del certificato server).

  1. Genera Chiave Privata Client:
    bash openssl genrsa -des3 -out client.key 2048

  2. Crea CSR Client:
    bash openssl req -new -key client.key -out client.csr
    Fornisci i dettagli, assicurandoti che il Common Name sia univoco per il client.

  3. Firma CSR Client con CA:
    bash sudo openssl x509 -req -days 365 -in client.csr -CA root.crt -CAkey root.key -set_serial <unique_serial> -out client.crt

  4. Imposta i Permessi:
    bash chmod 600 client.key chmod 644 client.crt

Configurazione di pg_hba.conf per l'Autenticazione con Certificato Client:

Sul server, devi configurare pg_hba.conf per accettare l'autenticazione con certificato client. Questo spesso utilizza il metodo di autenticazione cert.

# TIPO  DATABASE        UTENTE            INDIRIZZO                 METODO
# Richiede SSL e autenticazione con certificato client per utente/db specifici
hostssl all             your_user       your_client_ip/32       cert map=your_cert_map

Potresti anche dover definire un file di mappa dei certificati (opzione cert_map) se desideri mappare dettagli specifici del certificato client (come Subject o SubjectAltName) agli utenti PostgreSQL. Consulta la documentazione di PostgreSQL per una configurazione dettagliata dell'autenticazione cert e della mappatura dei certificati.

Configurazione del Client per Usare i Certificati:

Aggiorna la stringa di connessione del client per includere i percorsi al suo certificato e alla sua chiave:

psql "sslmode=verify-full host=your_server_hostname dbname=your_db user=your_user \nsslrootcert=/path/to/your/root.crt sslcert=/path/to/your/client.crt sslkey=/path/to/your/client.key"

Best Practices e Suggerimenti

  • Usa sslmode verify-full: Punta sempre a usare verify-full lato client per prevenire attacchi Man-in-the-Middle.
  • Proteggi le Chiavi Private: Assicurati che le chiavi private (file .key) abbiano permessi di file rigorosi (ad esempio, chmod 600) e siano leggibili solo dall'utente PostgreSQL sul server e dall'utente che si connette sul client.
  • Rinnova Regolarmente i Certificati: I certificati hanno date di scadenza. Implementa un processo per rinnovarli prima che scadano per evitare interruzioni delle connessioni.
  • Gestione Centralizzata dei Certificati: Per distribuzioni più grandi, considera l'utilizzo di un sistema di gestione dei certificati o l'automazione dell'emissione e del rinnovo dei certificati.
  • Monitora i Log: Controlla i log di PostgreSQL per eventuali errori relativi a SSL durante l'avvio o i tentativi di connessione.
  • Documentazione: Fai riferimento alla documentazione ufficiale di PostgreSQL per i parametri più aggiornati e le opzioni di configurazione avanzate specifiche della tua versione di PostgreSQL.

Conclusione

Configurare SSL/TLS per le connessioni PostgreSQL è un passo fondamentale per mettere in sicurezza la tua infrastruttura di database. Abilitando SSL sul server, imponendo ssl=require o hostssl in pg_hba.conf, e configurando i client con le impostazioni sslmode appropriate (idealmente verify-full), si migliora significativamente la sicurezza dei dati trasmessi sulla rete. L'implementazione dell'autenticazione mutua con certificati client aggiunge un ulteriore robusto strato di sicurezza. Anche se la configurazione iniziale potrebbe sembrare complessa, i benefici a lungo termine di protezione dei dati e conformità la rendono una pratica indispensabile per qualsiasi distribuzione PostgreSQL.