use std::io;
use std::path::PathBuf;
use std::pin::Pin;
use std::sync::Arc;
use std::task::{Context, Poll};
use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
use tokio::net::TcpStream;
use tokio_rustls::client::TlsStream;
use tracing::{debug, info, warn};
#[derive(Debug)]
pub enum FtpControlStream {
Plain(TcpStream),
Tls(TlsStream<TcpStream>),
}
impl FtpControlStream {
pub fn is_tls(&self) -> bool {
matches!(self, FtpControlStream::Tls(_))
}
pub fn into_plain(self) -> Option<TcpStream> {
match self {
FtpControlStream::Plain(s) => Some(s),
FtpControlStream::Tls(_) => None,
}
}
}
impl AsyncRead for FtpControlStream {
fn poll_read(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>,
) -> Poll<io::Result<()>> {
match self.get_mut() {
FtpControlStream::Plain(s) => Pin::new(s).poll_read(cx, buf),
FtpControlStream::Tls(s) => Pin::new(s).poll_read(cx, buf),
}
}
}
impl AsyncWrite for FtpControlStream {
fn poll_write(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8],
) -> Poll<io::Result<usize>> {
match self.get_mut() {
FtpControlStream::Plain(s) => Pin::new(s).poll_write(cx, buf),
FtpControlStream::Tls(s) => Pin::new(s).poll_write(cx, buf),
}
}
fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
match self.get_mut() {
FtpControlStream::Plain(s) => Pin::new(s).poll_flush(cx),
FtpControlStream::Tls(s) => Pin::new(s).poll_flush(cx),
}
}
fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
match self.get_mut() {
FtpControlStream::Plain(s) => Pin::new(s).poll_shutdown(cx),
FtpControlStream::Tls(s) => Pin::new(s).poll_shutdown(cx),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum TlsVersion {
#[default]
Tls12,
Tls13,
}
#[derive(Debug, Clone)]
pub struct FtpsConfig {
pub enabled: bool,
pub check_certificate: bool,
pub ca_certificate: Option<PathBuf>,
pub min_tls_version: TlsVersion,
}
impl Default for FtpsConfig {
fn default() -> Self {
Self {
enabled: false,
check_certificate: true,
ca_certificate: None,
min_tls_version: TlsVersion::Tls12,
}
}
}
pub fn build_tls_connector(config: &FtpsConfig) -> Result<tokio_rustls::TlsConnector, String> {
use rustls::crypto::ring::default_provider;
use rustls::ClientConfig;
let _ = default_provider().install_default();
let mut root_store = rustls::RootCertStore::empty();
if config.check_certificate {
if let Some(ref ca_path) = config.ca_certificate {
let certs = load_pem_certs(ca_path)?;
let (added, rejected) = root_store.add_parsable_certificates(certs);
if added == 0 {
return Err(format!(
"No valid CA certificates found in: {} ({} rejected)",
ca_path.display(),
rejected
));
}
info!(
"Loaded {} CA certificate(s) from {} ({} rejected)",
added,
ca_path.display(),
rejected
);
} else {
root_store.roots = webpki_roots::TLS_SERVER_ROOTS.to_vec();
if root_store.is_empty() {
return Err("No bundled root certificates available".to_string());
}
debug!("Using {} bundled Mozilla root certificates", root_store.len());
}
} else {
warn!("Certificate verification DISABLED — FTPS connection is insecure");
}
let mut client_config = match config.min_tls_version {
TlsVersion::Tls12 => ClientConfig::builder()
.with_root_certificates(root_store)
.with_no_client_auth(),
TlsVersion::Tls13 => {
ClientConfig::builder_with_provider(Arc::new(default_provider()))
.with_protocol_versions(&[&rustls::version::TLS13])
.map_err(|e| format!("Failed to set TLS 1.3 only: {}", e))?
.with_root_certificates(root_store)
.with_no_client_auth()
}
};
if !config.check_certificate {
client_config
.dangerous()
.set_certificate_verifier(Arc::new(NoCertificateVerification));
}
Ok(tokio_rustls::TlsConnector::from(Arc::new(client_config)))
}
fn load_pem_certs(
path: &std::path::Path,
) -> Result<Vec<rustls::pki_types::CertificateDer<'static>>, String> {
use std::io::BufReader as SyncBufReader;
let file = std::fs::File::open(path).map_err(|e| {
format!(
"Failed to open CA certificate file {}: {}",
path.display(),
e
)
})?;
let mut reader = SyncBufReader::new(file);
let certs: Vec<rustls::pki_types::CertificateDer<'static>> = rustls_pemfile::certs(&mut reader)
.collect::<Result<Vec<_>, _>>()
.map_err(|e| {
format!(
"Failed to parse CA certificates from {}: {}",
path.display(),
e
)
})?;
if certs.is_empty() {
return Err(format!(
"No PEM certificates found in {}",
path.display()
));
}
Ok(certs)
}
use rustls::client::danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier};
use rustls::pki_types::{CertificateDer, ServerName, UnixTime};
use rustls::DigitallySignedStruct;
#[derive(Debug)]
struct NoCertificateVerification;
impl ServerCertVerifier for NoCertificateVerification {
fn verify_server_cert(
&self,
_end_entity: &CertificateDer<'_>,
_intermediates: &[CertificateDer<'_>],
_server_name: &ServerName<'_>,
_ocsp_response: &[u8],
_now: UnixTime,
) -> Result<ServerCertVerified, rustls::Error> {
Ok(ServerCertVerified::assertion())
}
fn verify_tls12_signature(
&self,
_message: &[u8],
_cert: &CertificateDer<'_>,
_dss: &DigitallySignedStruct,
) -> Result<HandshakeSignatureValid, rustls::Error> {
Ok(HandshakeSignatureValid::assertion())
}
fn verify_tls13_signature(
&self,
_message: &[u8],
_cert: &CertificateDer<'_>,
_dss: &DigitallySignedStruct,
) -> Result<HandshakeSignatureValid, rustls::Error> {
Ok(HandshakeSignatureValid::assertion())
}
fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
rustls::crypto::ring::default_provider()
.signature_verification_algorithms
.supported_schemes()
}
}
pub async fn upgrade_stream(
stream: TcpStream,
host: &str,
config: &FtpsConfig,
) -> Result<TlsStream<TcpStream>, String> {
let connector = build_tls_connector(config)?;
let server_name: ServerName<'static> = ServerName::try_from(host.to_string())
.map_err(|e| format!("Invalid FTPS server name '{}': {:?}", host, e))?;
debug!("Starting TLS handshake with {}", host);
let tls_stream = connector
.connect(server_name, stream)
.await
.map_err(|e| format!("FTPS TLS handshake failed for {}: {}", host, e))?;
info!("TLS handshake completed successfully with {}", host);
Ok(tls_stream)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_ftps_config_default() {
let config = FtpsConfig::default();
assert!(!config.enabled);
assert!(config.check_certificate);
assert!(config.ca_certificate.is_none());
assert_eq!(config.min_tls_version, TlsVersion::Tls12);
}
#[test]
fn test_tls_version_default() {
assert_eq!(TlsVersion::default(), TlsVersion::Tls12);
}
#[test]
fn test_ftp_control_stream_plain_is_not_tls() {
let config = FtpsConfig::default();
assert!(!config.enabled);
}
#[test]
fn test_build_tls_connector_with_check_enabled() {
let config = FtpsConfig {
enabled: true,
check_certificate: true,
ca_certificate: None,
min_tls_version: TlsVersion::Tls12,
};
let result = build_tls_connector(&config);
assert!(result.is_ok(), "Connector should build with bundled roots");
}
#[test]
fn test_build_tls_connector_with_check_disabled() {
let config = FtpsConfig {
enabled: true,
check_certificate: false,
ca_certificate: None,
min_tls_version: TlsVersion::Tls12,
};
let result = build_tls_connector(&config);
assert!(
result.is_ok(),
"Connector should build even without cert verification"
);
}
#[test]
fn test_build_tls_connector_with_nonexistent_ca_file() {
let config = FtpsConfig {
enabled: true,
check_certificate: true,
ca_certificate: Some(PathBuf::from("/nonexistent/ca.pem")),
min_tls_version: TlsVersion::Tls12,
};
let result = build_tls_connector(&config);
assert!(result.is_err(), "Should fail with nonexistent CA file");
}
#[test]
fn test_build_tls_connector_tls13() {
let config = FtpsConfig {
enabled: true,
check_certificate: true,
ca_certificate: None,
min_tls_version: TlsVersion::Tls13,
};
let result = build_tls_connector(&config);
assert!(result.is_ok(), "Connector should build with TLS 1.3 only");
}
}