#[allow(
clippy::duplicate_mod,
reason = "This is duplicated only when running clippy. The two features are mutually exclusive"
)]
#[path = "../openssl/ssl_data_31.rs"]
mod ssl_data;
#[cfg(target_arch = "wasm32")]
use super::sock_wait_stub::{SockWaitKind, timeout_error_msg};
#[cfg(not(target_arch = "wasm32"))]
use crate::socket::{SockWaitKind, timeout_error_msg};
use crate::vm::VirtualMachine;
use rustpython_host_env::ssl::{TlsConnection, TlsError};
use rustpython_vm::builtins::{PyBaseException, PyBaseExceptionRef};
use rustpython_vm::convert::IntoPyException;
use rustpython_vm::function::ArgBytesLike;
use rustpython_vm::{AsObject, Py, PyObjectRef, PyPayload, PyResult, TryFromObject};
use super::_ssl::{PySSLSocket, SSL3_RT_MAX_PACKET_SIZE};
use super::error::{
PySSLCertVerificationError, PySSLError, PySSLWantWriteError, create_ssl_eof_error,
create_ssl_syscall_error, create_ssl_want_read_error, create_ssl_want_write_error,
create_ssl_zero_return_error,
};
const ERR_LIB_SSL: i32 = 20;
const SSL_R_NO_SHARED_CIPHER: i32 = 193;
use rustpython_host_env::ssl::x509::rustls_cert_error_to_verify_info;
pub(super) fn create_ssl_cert_verification_error(
vm: &VirtualMachine,
cert_err: &rustls::CertificateError,
) -> PyResult<PyBaseExceptionRef> {
let (verify_code, verify_message) = rustls_cert_error_to_verify_info(cert_err);
let msg =
format!("[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: {verify_message}",);
let exc = vm.new_os_subtype_error(
PySSLCertVerificationError::class(&vm.ctx).to_owned(),
None,
msg,
);
exc.as_object().set_attr(
"verify_code",
vm.ctx.new_int(verify_code).as_object().to_owned(),
vm,
)?;
exc.as_object().set_attr(
"verify_message",
vm.ctx.new_str(verify_message).as_object().to_owned(),
vm,
)?;
exc.as_object()
.set_attr("library", vm.ctx.new_str("SSL").as_object().to_owned(), vm)?;
exc.as_object().set_attr(
"reason",
vm.ctx
.new_str("CERTIFICATE_VERIFY_FAILED")
.as_object()
.to_owned(),
vm,
)?;
Ok(exc.upcast())
}
#[derive(Debug)]
pub(super) enum SslError {
WantRead,
WantWrite,
Syscall(String),
Ssl(String),
ZeroReturn,
Eof,
PreauthData,
CertVerification(rustls::CertificateError),
Io(std::io::Error),
Timeout(String),
Py(PyBaseExceptionRef),
Rustls(rustls::Error),
AlertReceived { lib: i32, reason: i32 },
NoCipherSuites,
}
impl SslError {
pub(super) fn from_rustls(err: rustls::Error) -> Self {
Self::Rustls(err)
}
pub(super) fn is_eof(&self) -> bool {
match self {
Self::Rustls(error) => TlsError::from_rustls(error.clone()).is_eof(),
Self::Eof => true,
_ => false,
}
}
pub(super) fn is_zero_return(&self) -> bool {
match self {
Self::Rustls(error) => TlsError::from_rustls(error.clone()).is_zero_return(),
Self::ZeroReturn => true,
_ => false,
}
}
fn map_rustls(err: rustls::Error) -> Self {
TlsError::from_rustls(err).into()
}
pub(super) fn create_ssl_error_with_reason(
vm: &VirtualMachine,
library: Option<&str>,
reason: &str,
message: impl Into<String>,
) -> PyBaseExceptionRef {
let msg = message.into();
let exc = vm.new_os_subtype_error(PySSLError::class(&vm.ctx).to_owned(), Some(1), msg);
let library_obj = match library {
Some(lib) => vm.ctx.new_str(lib).as_object().to_owned(),
None => vm.ctx.none(),
};
let _ = exc.as_object().set_attr("library", library_obj, vm);
let _ =
exc.as_object()
.set_attr("reason", vm.ctx.new_str(reason).as_object().to_owned(), vm);
exc.upcast()
}
fn create_ssl_error_from_codes(
vm: &VirtualMachine,
lib: i32,
reason: i32,
) -> PyBaseExceptionRef {
let key = ssl_data::encode_error_key(lib, reason);
let reason_str = ssl_data::ERROR_CODES
.get(&key)
.copied()
.unwrap_or("unknown error");
let lib_str = ssl_data::LIBRARY_CODES
.get(&(lib as u32))
.copied()
.unwrap_or("UNKNOWN");
Self::create_ssl_error_with_reason(
vm,
Some(lib_str),
reason_str,
format!("[SSL] {reason_str}"),
)
}
pub(super) fn into_py_err(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
match self {
Self::Rustls(error) => Self::map_rustls(error).into_py_err(vm),
Self::WantRead => create_ssl_want_read_error(vm).upcast(),
Self::WantWrite => create_ssl_want_write_error(vm).upcast(),
Self::Timeout(msg) => timeout_error_msg(vm, msg).upcast(),
Self::Syscall(msg) => {
create_ssl_syscall_error(vm, msg).upcast()
}
Self::Ssl(msg) => vm
.new_os_subtype_error(
PySSLError::class(&vm.ctx).to_owned(),
None,
format!("SSL error: {msg}"),
)
.upcast(),
Self::ZeroReturn => create_ssl_zero_return_error(vm).upcast(),
Self::Eof => create_ssl_eof_error(vm).upcast(),
Self::PreauthData => {
Self::create_ssl_error_with_reason(
vm,
None,
"before TLS handshake with data",
"before TLS handshake with data",
)
}
Self::CertVerification(cert_err) => {
create_ssl_cert_verification_error(vm, &cert_err).expect("unlikely to happen")
}
Self::Io(err) if err.kind() == std::io::ErrorKind::UnexpectedEof => {
create_ssl_eof_error(vm).upcast()
}
Self::Io(err) if err.raw_os_error().is_none() => vm
.new_os_subtype_error(
PySSLError::class(&vm.ctx).to_owned(),
None,
format!("SSL error: {err}"),
)
.upcast(),
Self::Io(err) => err.into_pyexception(vm),
Self::Py(exc) => exc,
Self::AlertReceived { lib, reason } => {
Self::create_ssl_error_from_codes(vm, lib, reason)
}
Self::NoCipherSuites => {
Self::create_ssl_error_from_codes(vm, ERR_LIB_SSL, SSL_R_NO_SHARED_CIPHER)
}
}
}
}
impl From<TlsError> for SslError {
fn from(err: TlsError) -> Self {
match err {
TlsError::WantRead => Self::WantRead,
TlsError::WantWrite => Self::WantWrite,
TlsError::Syscall(msg) => Self::Syscall(msg),
TlsError::Ssl(msg) => Self::Ssl(msg),
TlsError::ZeroReturn => Self::ZeroReturn,
TlsError::Eof => Self::Eof,
TlsError::PreauthData => Self::PreauthData,
TlsError::CertVerification(cert_err) => Self::CertVerification(cert_err),
TlsError::Io(err) => Self::Io(err),
TlsError::Timeout(msg) => Self::Timeout(msg),
TlsError::AlertReceived { lib, reason } => Self::AlertReceived { lib, reason },
TlsError::NoCipherSuites => Self::NoCipherSuites,
}
}
}
pub(super) type SslResult<T> = Result<T, SslError>;
pub(super) use rustpython_host_env::ssl::config::{
ClientConfigOptions, MultiCertResolver, ProtocolSettings, ServerConfigOptions,
create_client_config, create_server_config, curve_name_to_kx_group,
};
pub(super) fn is_blocking_io_error(err: &Py<PyBaseException>, vm: &VirtualMachine) -> bool {
err.fast_isinstance(vm.ctx.exceptions.blocking_io_error)
}
fn with_conn_mut<R>(
socket: &Py<PySSLSocket>,
vm: &VirtualMachine,
f: impl FnOnce(&mut TlsConnection) -> SslResult<R>,
) -> SslResult<R> {
let mut guard = socket.connection().lock();
let conn = guard
.as_mut()
.ok_or_else(|| SslError::Py(vm.new_value_error("Connection not established")))?;
f(conn)
}
pub(super) fn send_all_bytes(
socket: &Py<PySSLSocket>,
buf: Vec<u8>,
vm: &VirtualMachine,
deadline: Option<std::time::Instant>,
) -> SslResult<()> {
socket.observe_tls(true, &buf, vm);
socket.pending_tls_output.lock().extend_from_slice(&buf);
socket
.flush_pending_tls_output(vm, deadline)
.map_err(|error| {
if error.fast_isinstance(PySSLWantWriteError::class(&vm.ctx)) {
SslError::WantWrite
} else if error.fast_isinstance(vm.ctx.exceptions.timeout_error) {
SslError::Timeout("The write operation timed out".to_owned())
} else {
SslError::Py(error)
}
})
}
fn handshake_write_loop(socket: &Py<PySSLSocket>, vm: &VirtualMachine) -> SslResult<bool> {
let mut made_progress = false;
socket
.flush_pending_tls_output(vm, None)
.map_err(SslError::Py)?;
loop {
let wants_write = with_conn_mut(socket, vm, |conn| Ok(conn.wants_write()))?;
if !wants_write {
break;
}
let buf = with_conn_mut(socket, vm, ssl_write_tls_records)?;
if buf.is_empty() {
break;
}
send_all_bytes(socket, buf, vm, None)?;
made_progress = true;
}
Ok(made_progress)
}
pub(super) fn recv_at_most_one_tls_record(
socket: &Py<PySSLSocket>,
vm: &VirtualMachine,
) -> SslResult<PyObjectRef> {
let bytes = socket.sock_recv_at_most_one_tls_record(vm).map_err(|e| {
if is_blocking_io_error(&e, vm) {
SslError::WantRead
} else {
SslError::Py(e)
}
})?;
socket.observe_tls(false, bytes.as_bytes(), vm);
if bytes.as_bytes().is_empty() {
Err(if socket.is_bio_mode() && !socket.transport_eof() {
SslError::WantRead
} else {
SslError::Eof
})
} else {
Ok(bytes.into())
}
}
fn recv_at_most_one_tls_record_for_data(
socket: &Py<PySSLSocket>,
vm: &VirtualMachine,
) -> SslResult<PyObjectRef> {
match recv_at_most_one_tls_record(socket, vm) {
Ok(data) => Ok(data),
Err(SslError::Eof) => {
with_conn_mut(socket, vm, |conn| {
conn.process_packets().map_err(SslError::from)?;
Ok(())
})?;
Ok(vm.ctx.new_bytes(vec![]).into())
}
Err(SslError::Py(e)) => {
with_conn_mut(socket, vm, |conn| {
conn.process_packets().map_err(SslError::from)?;
Ok(())
})?;
if is_connection_closed_error(&e, vm) {
return Err(SslError::Eof);
}
Err(SslError::Py(e))
}
Err(e) => Err(e),
}
}
fn handshake_read_data(socket: &Py<PySSLSocket>, vm: &VirtualMachine) -> SslResult<()> {
if socket
.sock_wait_for_io_impl(SockWaitKind::Read, vm)
.map_err(SslError::Py)?
{
return Err(SslError::Timeout(
"The handshake operation timed out".to_owned(),
));
}
let data = recv_at_most_one_tls_record(socket, vm)?;
with_conn_mut(socket, vm, |conn| {
ssl_read_tls_records(conn, data, socket.is_bio_mode(), vm)
})
}
fn try_read_plaintext(conn: &mut TlsConnection, buf: &mut [u8]) -> SslResult<Option<usize>> {
conn.read_plaintext(buf).map_err(SslError::from)
}
pub(super) fn ssl_do_handshake(socket: &Py<PySSLSocket>, vm: &VirtualMachine) -> SslResult<()> {
loop {
handshake_write_loop(socket, vm)?;
let keep_going = with_conn_mut(socket, vm, |conn| {
if !conn.is_handshaking() {
return Ok(false);
}
if !conn.wants_read() {
return Err(SslError::WantRead);
}
Ok(true)
})?;
if !keep_going {
return Ok(());
}
handshake_read_data(socket, vm)?;
with_conn_mut(socket, vm, |conn| {
if let Err(error) = conn.inner_mut().process_new_packets() {
return Err(if matches!(error, rustls::Error::InvalidMessage(_)) {
SslError::PreauthData
} else {
SslError::from_rustls(error)
});
}
Ok(())
})?;
}
}
pub(super) fn ssl_read(
socket: &Py<PySSLSocket>,
buf: &mut [u8],
vm: &VirtualMachine,
) -> SslResult<usize> {
let is_bio = socket.is_bio_mode();
let deadline = if !is_bio {
match socket.get_socket_timeout(vm).map_err(SslError::Py)? {
Some(timeout) if !timeout.is_zero() => Some(std::time::Instant::now() + timeout),
_ => None, }
} else {
None };
if !is_bio {
socket
.flush_pending_tls_output(vm, deadline)
.map_err(SslError::Py)?;
}
loop {
if let Some(deadline) = deadline
&& std::time::Instant::now() >= deadline
{
return Err(SslError::Timeout(
"The read operation timed out".to_string(),
));
}
let (needs_more_tls, plaintext) = with_conn_mut(socket, vm, |conn| {
Ok((conn.wants_read(), try_read_plaintext(conn, buf)?))
})?;
if let Some(n) = plaintext {
if n == 0 {
return Err(SslError::ZeroReturn);
}
return Ok(n);
}
if !needs_more_tls {
let wants_write = with_conn_mut(socket, vm, |conn| Ok(conn.wants_write()))?;
if wants_write && !is_bio {
if let Some(deadline) = deadline
&& std::time::Instant::now() >= deadline
{
return Err(SslError::Timeout(
"The read operation timed out".to_string(),
));
}
let tls_data = with_conn_mut(socket, vm, ssl_write_tls_records)?;
if !tls_data.is_empty() {
match send_all_bytes(socket, tls_data, vm, deadline) {
Ok(()) => {}
Err(SslError::WantWrite) => {
}
Err(SslError::Timeout(_)) => {
}
Err(e) => return Err(e),
}
}
if let Some(deadline) = deadline
&& std::time::Instant::now() >= deadline
{
return Err(SslError::Timeout(
"The read operation timed out".to_string(),
));
}
continue;
}
if is_bio && let Some(bio_obj) = socket.incoming_bio() {
let is_eof = bio_obj
.get_attr("eof", vm)
.and_then(|v| v.try_into_value::<bool>(vm))
.unwrap_or(false);
if is_eof {
return Err(SslError::Eof);
}
}
if !is_bio {
let timeout = socket.get_socket_timeout(vm).map_err(SslError::Py)?;
if let Some(t) = timeout
&& t.is_zero()
{
let peer_closed = with_conn_mut(socket, vm, |conn| {
conn.peer_has_closed().map_err(SslError::from)
})?;
if peer_closed {
return Err(SslError::ZeroReturn);
}
return Err(SslError::WantRead);
}
let data = recv_at_most_one_tls_record_for_data(socket, vm)?;
let bytes_read = data
.clone()
.try_into_value::<rustpython_vm::builtins::PyBytes>(vm)
.map_or(0, |b| b.as_bytes().len());
if bytes_read == 0 {
let peer_closed = with_conn_mut(socket, vm, |conn| {
conn.peer_has_closed().map_err(SslError::from)
})?;
if peer_closed {
return Err(SslError::ZeroReturn);
}
return Err(SslError::Eof);
}
with_conn_mut(socket, vm, |conn| {
ssl_read_tls_records(conn, data, false, vm)?;
conn.process_packets().map_err(SslError::from)?;
Ok(())
})?;
continue;
}
return Err(SslError::WantRead);
}
match ssl_ensure_data_available(socket, vm) {
Ok(_bytes_read) => {
}
Err(e) => {
match with_conn_mut(socket, vm, |conn| try_read_plaintext(conn, buf))? {
Some(n) if n > 0 => {
return Ok(n);
}
_ => {
return Err(e);
}
}
}
}
}
}
pub(super) fn ssl_write(
socket: &Py<PySSLSocket>,
data: &[u8],
vm: &VirtualMachine,
) -> SslResult<usize> {
if data.is_empty() {
return Ok(0);
}
let is_bio = socket.is_bio_mode();
let deadline = if !is_bio {
match socket.get_socket_timeout(vm).map_err(SslError::Py)? {
Some(timeout) if !timeout.is_zero() => Some(std::time::Instant::now() + timeout),
_ => None,
}
} else {
None
};
if !is_bio {
socket
.flush_pending_tls_output(vm, deadline)
.map_err(SslError::Py)?;
}
let already_buffered = socket.write_buffered_len();
let mut bytes_written_to_rustls = 0usize;
if already_buffered == 0 {
bytes_written_to_rustls = with_conn_mut(socket, vm, |conn| {
conn.write_plaintext(data, is_bio).map_err(SslError::from)
})?;
socket.set_write_buffered_len(bytes_written_to_rustls);
} else if already_buffered != data.len() {
socket.set_write_buffered_len(0);
return Err(SslError::Ssl("bad write retry".to_string()));
}
loop {
if let Some(dl) = deadline
&& std::time::Instant::now() >= dl
{
return Err(SslError::Timeout(
"The write operation timed out".to_string(),
));
}
let wants_write = with_conn_mut(socket, vm, |conn| Ok(conn.wants_write()))?;
if !wants_write {
break;
}
let tls_data = with_conn_mut(socket, vm, ssl_write_tls_records)?;
if tls_data.is_empty() {
break;
}
match send_all_bytes(socket, tls_data, vm, deadline) {
Ok(()) => {
}
Err(SslError::WantWrite) => {
if bytes_written_to_rustls > 0 && bytes_written_to_rustls < data.len() {
socket.set_write_buffered_len(0);
return Ok(bytes_written_to_rustls);
}
return Err(SslError::WantWrite);
}
Err(SslError::WantRead) => {
if is_bio {
if bytes_written_to_rustls > 0 && bytes_written_to_rustls < data.len() {
socket.set_write_buffered_len(0);
return Ok(bytes_written_to_rustls);
}
return Err(SslError::WantRead);
}
let recv_result = recv_at_most_one_tls_record_for_data(socket, vm)?;
with_conn_mut(socket, vm, |conn| {
ssl_read_tls_records(conn, recv_result, false, vm)?;
conn.process_packets().map_err(SslError::from)?;
Ok(())
})?;
}
Err(e @ SslError::Timeout(_)) => {
if bytes_written_to_rustls > 0 && bytes_written_to_rustls < data.len() {
socket.set_write_buffered_len(0);
return Ok(bytes_written_to_rustls);
}
return Err(e);
}
Err(e) => {
socket.set_write_buffered_len(0);
return Err(e);
}
}
}
if !is_bio {
socket
.flush_pending_tls_output(vm, deadline)
.map_err(SslError::Py)?;
}
let actual_written = if bytes_written_to_rustls > 0 {
bytes_written_to_rustls
} else if already_buffered > 0 {
already_buffered
} else {
data.len()
};
socket.set_write_buffered_len(0);
Ok(actual_written)
}
fn ssl_write_tls_records(conn: &mut TlsConnection) -> SslResult<Vec<u8>> {
conn.drain_tls().map_err(SslError::from)
}
pub(super) fn ssl_read_tls_records(
conn: &mut TlsConnection,
data: PyObjectRef,
is_bio: bool,
vm: &VirtualMachine,
) -> SslResult<()> {
let bytes = ArgBytesLike::try_from_object(vm, data)
.map_err(|_| SslError::Syscall("Expected bytes-like object".to_string()))?;
let bytes_data = bytes.borrow_buf();
if bytes_data.is_empty() && is_bio {
return Err(SslError::WantRead);
}
conn.feed_tls(bytes_data.as_ref()).map_err(SslError::from)
}
fn is_connection_closed_error(exc: &Py<PyBaseException>, vm: &VirtualMachine) -> bool {
use rustpython_vm::stdlib::errno::errors;
if exc.fast_isinstance(vm.ctx.exceptions.connection_aborted_error)
|| exc.fast_isinstance(vm.ctx.exceptions.connection_reset_error)
{
return true;
}
if exc.fast_isinstance(vm.ctx.exceptions.os_error)
&& let Ok(errno) = exc.as_object().get_attr("errno", vm)
&& let Ok(errno_int) = errno.try_int(vm)
&& let Ok(errno_val) = errno_int.try_to_primitive::<i32>(vm)
{
return errno_val == errors::ECONNABORTED || errno_val == errors::ECONNRESET;
}
false
}
fn ssl_ensure_data_available(socket: &Py<PySSLSocket>, vm: &VirtualMachine) -> SslResult<usize> {
if with_conn_mut(socket, vm, |conn| Ok(conn.wants_read()))? {
let is_bio = socket.is_bio_mode();
if !is_bio {
let timeout = socket.get_socket_timeout(vm).map_err(SslError::Py)?;
if let Some(t) = timeout
&& !t.is_zero()
{
let timed_out = socket
.sock_wait_for_io_impl(SockWaitKind::Read, vm)
.map_err(SslError::Py)?;
if timed_out {
return Err(SslError::Timeout(
"The read operation timed out".to_string(),
));
}
}
}
let data = if !is_bio {
recv_at_most_one_tls_record_for_data(socket, vm)?
} else {
match socket.sock_recv(SSL3_RT_MAX_PACKET_SIZE, vm) {
Ok(data) => data,
Err(e) => {
if is_blocking_io_error(&e, vm) {
return Err(SslError::WantRead);
}
with_conn_mut(socket, vm, |conn| {
conn.process_packets().map_err(SslError::from)?;
Ok(())
})?;
if is_connection_closed_error(&e, vm) {
return Err(SslError::Eof);
}
return Err(SslError::Py(e));
}
}
};
let bytes_read = data
.clone()
.try_into_value::<rustpython_vm::builtins::PyBytes>(vm)
.map_or(0, |b| b.as_bytes().len());
let is_eof = if is_bio {
if let Some(bio_obj) = socket.incoming_bio() {
bio_obj
.get_attr("eof", vm)
.and_then(|v| v.try_into_value::<bool>(vm))
.unwrap_or(false)
} else {
false
}
} else {
false
};
if is_eof && bytes_read == 0 {
return Err(SslError::Eof);
}
if is_bio {
let bytes = ArgBytesLike::try_from_object(vm, data.clone())
.map_err(|_| SslError::Syscall("Expected bytes-like object".to_string()))?;
socket.observe_tls(false, bytes.borrow_buf().as_ref(), vm);
}
with_conn_mut(socket, vm, |conn| {
ssl_read_tls_records(conn, data, is_bio, vm)?;
conn.process_packets().map_err(SslError::from)?;
Ok(())
})?;
Ok(bytes_read)
} else {
Ok(0)
}
}