Início / coding / Perguntas / 79194535
Accepted
David Martínez Gil
Asked: 2024-11-16 12:43:59 +0800 CST

Como fazer uma conexão TLS entre dois pares usando Rust

  • 772

Estou trabalhando em um sistema de transferência de arquivos que tem uma biblioteca de conectividade p2p usando Rust. Ele funciona usando apenas tcp, mas agora quero melhorá-lo usando TLS, mas não entendo duas coisas. Como dois pares podem compartilhar a CA das Autoridades de Certificação para que possam verificar se a conexão é confiável. Na conexão ponto a ponto que descrevo, há apenas dois pares tentando transferir alguns arquivos. Como eles não têm um domínio, apenas IP, não funcionaria. Estou bem perdido, se alguém puder me ajudar com isso, algumas diretrizes de como abordar, por favor, seria legal, obrigado.

ssl

1 respostas

  1. Best Answer

    native-tls

    A documentação da connectfunção síncrona diz que:

    O domínio será ignorado se a verificação de SNI e de nome de host estiverem desabilitadas.

    Levando isso em consideração, mudando para as asyncAPIs e gerando um certificado autoassinado, chegamos ao seguinte código funcional:

    [package]
name = "tls"
version = "0.1.0"
edition = "2021"

[dependencies]
rcgen = "0.13.1"
tokio = { version = "1.41.1", features = ["full"] }
tokio-native-tls = "0.3.1"

    use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};
use tokio_native_tls::native_tls::Identity;
use tokio_native_tls::{native_tls, TlsAcceptor, TlsConnector};

#[tokio::main]
async fn main() {
    let cert = rcgen::generate_simple_self_signed([]).unwrap();
    let listener = TcpListener::bind("127.0.0.1:8001").await.unwrap();

    let trusted = native_tls::Certificate::from_pem(cert.cert.pem().as_bytes()).unwrap();
    tokio::spawn(async move {
        let connector = TlsConnector::from(
            native_tls::TlsConnector::builder()
                .disable_built_in_roots(true)
                .add_root_certificate(trusted)
                .danger_accept_invalid_hostnames(true)
                .use_sni(false)
                .build()
                .unwrap(),
        );
        let tcp = TcpStream::connect("0.0.0.0:8001").await.unwrap();
        let mut tls = connector.connect("N/A", tcp).await.unwrap();
        tls.write_all(b"hello!").await.unwrap();
        tls.shutdown().await.unwrap();
    });

    let acceptor = TlsAcceptor::from(
        native_tls::TlsAcceptor::new(
            Identity::from_pkcs8(
                cert.cert.pem().as_bytes(),
                cert.key_pair.serialize_pem().as_bytes(),
            )
            .unwrap(),
        )
        .unwrap(),
    );

    let (tcp, _) = listener.accept().await.unwrap();
    let mut tls = acceptor.accept(tcp).await.unwrap();
    let mut buf = String::new();
    tls.read_to_string(&mut buf).await.unwrap();
    println!("read: {buf}");
}

    rustls

    Aqui está um código similar usando rustls. As diferenças incluem:

    • Você pode e deve passar o IP do servidor em vez de "N/A" para o nome do servidor.
    • O verificador de certificado padrão exige que o IP esteja entre os nomes do assunto.
    [package]
name = "tls"
version = "0.1.0"
edition = "2021"

[dependencies]
rcgen = "0.13.1"
tokio = { version = "1.41.1", features = ["full"] }
tokio-rustls = "0.26.0"

    use std::net::Ipv4Addr;
use std::sync::Arc;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};
use tokio_rustls::rustls::pki_types::pem::PemObject;
use tokio_rustls::rustls::pki_types::{PrivateKeyDer, PrivatePkcs8KeyDer, ServerName};
use tokio_rustls::rustls::{ClientConfig, RootCertStore};
use tokio_rustls::{rustls, TlsAcceptor, TlsConnector};

#[tokio::main]
async fn main() {
    let cert = rcgen::generate_simple_self_signed(["127.0.0.1".to_owned()]).unwrap();
    let listener = TcpListener::bind("127.0.0.1:8001").await.unwrap();

    let mut trusted = RootCertStore::empty();
    trusted.add(cert.cert.der().clone()).unwrap();
    tokio::spawn(async move {
        let connector: TlsConnector = TlsConnector::from(Arc::new(
            ClientConfig::builder()
                .with_root_certificates(trusted)
                .with_no_client_auth(),
        ));
        let tcp = TcpStream::connect("127.0.0.1:8001").await.unwrap();
        let mut tls = connector
            .connect(
                ServerName::IpAddress(Ipv4Addr::new(127, 0, 0, 1).into()),
                tcp,
            )
            .await
            .unwrap();
        tls.write_all(b"hello!").await.unwrap();
        tls.shutdown().await.unwrap();
    });

    let acceptor = TlsAcceptor::from(Arc::new(
        rustls::ServerConfig::builder()
            .with_no_client_auth()
            .with_single_cert(
                vec![cert.cert.der().clone()],
                PrivateKeyDer::Pkcs8(
                    PrivatePkcs8KeyDer::from_pem_slice(cert.key_pair.serialize_pem().as_bytes())
                        .unwrap(),
                ),
            )
            .unwrap(),
    ));

    let (tcp, _) = listener.accept().await.unwrap();
    let mut tls = acceptor.accept(tcp).await.unwrap();
    let mut buf = String::new();
    tls.read_to_string(&mut buf).await.unwrap();
    println!("read: {buf}");
}

    Se você quisesse usar um certificado assinado por uma CA, você adicionaria o certificado da CA como uma raiz confiável.

    • 2

relate perguntas