Använd PostgreSQL SSL-anslutning i rost med självsignerade certifikat

Det här blogginlägget handlar om att använda rustspråket för att skapa en koppling till PostgreSQL och YugabyteDB, som är trådkompatibelt med postgres så därför gäller det också. Detta är faktiskt extremt enkelt:

okrypterad enkel postgres-anslutning

Lägg till den nödvändiga lådan till Cargo.toml:

postgres = "0.19.2"

Och utför anslutningen i 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);
}

Flytta postgres-lådan till räckvidden för klient- och NoTls-metoderna, skapa en anslutning och kör en fråga. Jag använde query_one(), som kör en fråga som ska returnera en enda rad.

krypterad/TLS enkel postgres-anslutning

Det blir dock mer intressant med SSL. Om du vill använda en TLS-koppling med postgres i rost finns det två alternativ:openssl och native_tls. Anledningen till att jag inkluderade "självsignerade certifikat" i titeln är:än så länge verkar det som om native_tls-lådan inte tillåter självsignerade certifikat. Detta verkar få vissa att säga att du inte kan använda rost, postgres och TLS-anslutningar med självsignerade certifikat. Detta är inte sant.

Med openssl kan du. Gör det openssl mindre säkert? Nej:openssl tillåter inte heller att självsignerade certifikat används som standard. Det låter dig dock inaktivera verifieringen för certifikatutfärdare, så inofficiella (självsignerade) certifikat från certifikatutfärdare kan användas. Naturligtvis ska det inte göras i en officiell implementering som ska vara säker. Men det är helt okej att göra det för ett test eller proof-of-concept-installation så att du kan köra med SSL/TLS-anslutningar utan att behöva skaffa officiellt signerade certifikat.

Så här görs det:
Cargo.toml:

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

main.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);
}

Den första delen bygger en SSL TLS-anslutning baserad på ett anpassat skapat certifikat från certifikatutfärdaren och stänger uttryckligen av verifieringen av certifikatutfärdarens certifikat. Det är detta som gör att det självsignerade certifikatet kan användas.

Den andra delen är identisk med det första exemplet, med undantaget att TLS-specifikationen för anslutningen ändras från NoTls till TLS-kontakten.