Usa la connessione SSL PostgreSQL in ruggine con certificati autofirmati

Questo post sul blog riguarda l'uso del linguaggio ruggine per creare una connessione a PostgreSQL e YugabyteDB, che è compatibile con Postgres, quindi si applica anche. Questo è in realtà estremamente semplice:

connessione Postgres semplice non crittografata

Aggiungi la cassa necessaria a Cargo.toml:

postgres = "0.19.2"

Ed eseguire la connessione in main.rs:

use postgres::{Client, NoTls};

fn main() {
    // no SSL/TLS
    let mut connection = Client::connect("host=192.168.66.201 port=5432 user=postgres password=postgres", NoTls).expect("failed to create notls postgres connection");
    let result = connection.query_one("select 10", &[]).expect("failed to execute select 10 to postgres");
    let value: i32 = result.get(0);
    println!("result of query_one call: {}", value);
}

Spostare la cassa postgres nell'ambito dei metodi Client e NoTls, creare una connessione ed eseguire una query. Ho usato query_one(), che esegue una query che dovrebbe restituire una singola riga.

connessione postgres semplice crittografata/TLS

Tuttavia, diventa più interessante con SSL. Se vuoi usare una connessione TLS con postgres in rust, ci sono due opzioni:openssl e native_tls. Il motivo per cui ho incluso "certificati autofirmati" nel titolo è:finora, sembra che la cassa native_tls non consenta certificati autofirmati. Ciò sembra indurre alcune persone a dichiarare che non è possibile utilizzare connessioni ruggine, postgres e TLS con certificati autofirmati. Questo non è vero.

Usando openssl puoi. Ciò rende openssl meno sicuro? No:openssl, inoltre, non consente l'utilizzo di certificati autofirmati per impostazione predefinita. Tuttavia, consente di disabilitare la verifica per le autorità di certificazione, quindi è possibile utilizzare certificati di autorità di certificazione non ufficiali (autofirmati). Ovviamente ciò non dovrebbe essere fatto in un'implementazione ufficiale che dovrebbe essere sicura. Ma va benissimo farlo per un test o una configurazione proof-of-concept in modo da poter funzionare con connessioni SSL/TLS senza dover ottenere certificati firmati ufficialmente.

Ecco come si fa:
Cargo.toml:

postgres = "0.19.2"
openssl = "0.10.38"
postgres-openssl = "0.5.0"

principale.rs:

fn main() {
    let mut builder = SslConnector::builder(SslMethod::tls()).expect("unable to create sslconnector builder");
    builder.set_ca_file("/tmp/ca.cert").expect("unable to load ca.cert");
    builder.set_verify(SslVerifyMode::NONE);
    let connector = MakeTlsConnector::new(builder.build());

    let mut connection = Client::connect("host=192.168.66.201 port=5432 sslmode=require user=postgres password=postgres", connector).expect("failed to create tls postgres connection");
    let result = connection.query_one("select 10", &[]).expect("failed to execute select 10 to postgres");
    let value: i32 = result.get(0);
    println!("result of query_one call: {}", value);
}

La prima parte crea un connettore SSL TLS basato su un certificato dell'autorità di certificazione personalizzato e disattiva in modo esplicito la verifica del certificato dell'autorità di certificazione. Questo è ciò che consente di utilizzare il certificato autofirmato.

La seconda parte è identica al primo esempio, con l'eccezione che la specifica TLS della connessione viene modificata da NoTls al connettore TLS.