use core::hint::cold_path;

use super::bio;

// Import error types and helpers used in this module (others are exposed via pymodule(with(...)))

use super::ssl_error::{

PySSLCertVerificationError, PySSLError, create_ssl_eof_error, create_ssl_want_read_error,

create_ssl_want_write_error,

};

use crate::{

common::lock::{

LazyLock, PyDetachingRwLock, PyMappedRwLockReadGuard, PyMutex, PyRwLock,

PyRwLockReadGuard, PyRwLockWriteGuard,

},

socket::{self, PySocket, SockWaitKind, sock_wait},

vm::{

AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,

builtins::{

PyBaseException, PyBaseExceptionRef, PyBytesRef, PyListRef, PyModule, PyStrRef,

PyType, PyWeak,

},

class_or_notimplemented,

convert::ToPyException,

exceptions,

function::{

ArgBytesLike, ArgMemoryBuffer, ArgStrOrBytesLike, Either, FsPath, OptionalArg,

PyComparisonValue,

},

stdlib::_warnings,

types::{Comparable, Constructor, PyComparisonOp},

utils::ToCString,

},

};

use crossbeam_utils::atomic::AtomicCell;

use foreign_types_shared::{ForeignType, ForeignTypeRef};

use memchr::memchr;

use openssl::{

asn1::{Asn1Object, Asn1ObjectRef},

error::ErrorStack,

nid::Nid,

ssl::{self, SslContextBuilder, SslOptions, SslVerifyMode},

x509::X509,

};

use openssl_sys as sys;

use rustpython_vm::ospath::OsPath;

use core::{ffi::CStr, fmt};

use std::{

io::{Read, Write},

path::PathBuf,

time::Instant,

};

// Import certificate types from parent module

use super::cert::{self, cert_to_certificate, cert_to_py};

pub(crate) fn module_exec(vm: &VirtualMachine, module: &Py<PyModule>) -> PyResult<()> {

__module_exec(vm, module);

Ok(())

}

// Re-export PySSLCertificate to make it available in the _ssl module

// It will be automatically exposed to Python via #[pyclass]

#[allow(unused_imports)]

use super::cert::PySSLCertificate;

// Constants

#[pyattr]

use sys::{

// SSL Alert Descriptions that are exported by openssl_sys

SSL_AD_DECODE_ERROR,

SSL_AD_ILLEGAL_PARAMETER,

SSL_AD_UNRECOGNIZED_NAME,

// SSL_ERROR_INVALID_ERROR_CODE,

SSL_ERROR_SSL,

// SSL_ERROR_WANT_X509_LOOKUP,

SSL_ERROR_SYSCALL,

SSL_ERROR_WANT_CONNECT,

SSL_ERROR_WANT_READ,

SSL_ERROR_WANT_WRITE,

SSL_ERROR_ZERO_RETURN,

SSL_OP_CIPHER_SERVER_PREFERENCE as OP_CIPHER_SERVER_PREFERENCE,

SSL_OP_ENABLE_MIDDLEBOX_COMPAT as OP_ENABLE_MIDDLEBOX_COMPAT,

SSL_OP_LEGACY_SERVER_CONNECT as OP_LEGACY_SERVER_CONNECT,

SSL_OP_NO_SSLv2 as OP_NO_SSLv2,

SSL_OP_NO_SSLv3 as OP_NO_SSLv3,

SSL_OP_NO_TICKET as OP_NO_TICKET,

SSL_OP_NO_TLSv1 as OP_NO_TLSv1,

SSL_OP_SINGLE_DH_USE as OP_SINGLE_DH_USE,

SSL_OP_SINGLE_ECDH_USE as OP_SINGLE_ECDH_USE,

X509_V_FLAG_ALLOW_PROXY_CERTS as VERIFY_ALLOW_PROXY_CERTS,

X509_V_FLAG_CRL_CHECK as VERIFY_CRL_CHECK_LEAF,

X509_V_FLAG_PARTIAL_CHAIN as VERIFY_X509_PARTIAL_CHAIN,

X509_V_FLAG_TRUSTED_FIRST as VERIFY_X509_TRUSTED_FIRST,

X509_V_FLAG_X509_STRICT as VERIFY_X509_STRICT,

};

#[pyattr]

use rustpython_host_env::ssl::{

ALERT_DESCRIPTION_ACCESS_DENIED, ALERT_DESCRIPTION_BAD_CERTIFICATE,

ALERT_DESCRIPTION_BAD_CERTIFICATE_HASH_VALUE,

ALERT_DESCRIPTION_BAD_CERTIFICATE_STATUS_RESPONSE, ALERT_DESCRIPTION_BAD_RECORD_MAC,

ALERT_DESCRIPTION_CERTIFICATE_EXPIRED, ALERT_DESCRIPTION_CERTIFICATE_REQUIRED,

ALERT_DESCRIPTION_CERTIFICATE_REVOKED, ALERT_DESCRIPTION_CERTIFICATE_UNKNOWN,

ALERT_DESCRIPTION_CERTIFICATE_UNOBTAINABLE, ALERT_DESCRIPTION_CLOSE_NOTIFY,

ALERT_DESCRIPTION_DECODE_ERROR, ALERT_DESCRIPTION_DECOMPRESSION_FAILURE,

ALERT_DESCRIPTION_DECRYPT_ERROR, ALERT_DESCRIPTION_DECRYPTION_FAILED,

ALERT_DESCRIPTION_EXPORT_RESTRICTION, ALERT_DESCRIPTION_HANDSHAKE_FAILURE,

ALERT_DESCRIPTION_ILLEGAL_PARAMETER, ALERT_DESCRIPTION_INAPPROPRIATE_FALLBACK,

ALERT_DESCRIPTION_INSUFFICIENT_SECURITY, ALERT_DESCRIPTION_INTERNAL_ERROR,

ALERT_DESCRIPTION_MISSING_EXTENSION, ALERT_DESCRIPTION_NO_APPLICATION_PROTOCOL,

ALERT_DESCRIPTION_NO_CERTIFICATE, ALERT_DESCRIPTION_NO_RENEGOTIATION,

ALERT_DESCRIPTION_PROTOCOL_VERSION, ALERT_DESCRIPTION_RECORD_OVERFLOW,

ALERT_DESCRIPTION_UNEXPECTED_MESSAGE, ALERT_DESCRIPTION_UNKNOWN_CA,

ALERT_DESCRIPTION_UNKNOWN_PSK_IDENTITY, ALERT_DESCRIPTION_UNRECOGNIZED_NAME,

ALERT_DESCRIPTION_UNSUPPORTED_CERTIFICATE, ALERT_DESCRIPTION_UNSUPPORTED_EXTENSION,

ALERT_DESCRIPTION_USER_CANCELLED,

};

// CRL verification constants

#[pyattr]

const VERIFY_CRL_CHECK_CHAIN: core::ffi::c_ulong =

sys::X509_V_FLAG_CRL_CHECK | sys::X509_V_FLAG_CRL_CHECK_ALL;

// taken from CPython, should probably be kept up to date with their version if it ever changes

#[pyattr]

const _DEFAULT_CIPHERS: &str =

"DEFAULT:!aNULL:!eNULL:!MD5:!3DES:!DES:!RC4:!IDEA:!SEED:!aDSS:!SRP:!PSK";

// #[pyattr] PROTOCOL_SSLv2: u32 = SslVersion::Ssl2 as u32; // unsupported

// #[pyattr] PROTOCOL_SSLv3: u32 = SslVersion::Ssl3 as u32;

#[pyattr]

const PROTOCOL_SSLv23: u32 = SslVersion::Tls as u32;

#[pyattr]

const PROTOCOL_TLS: u32 = SslVersion::Tls as u32;

#[pyattr]

const PROTOCOL_TLS_CLIENT: u32 = SslVersion::TlsClient as u32;

#[pyattr]

const PROTOCOL_TLS_SERVER: u32 = SslVersion::TlsServer as u32;

#[pyattr]

const PROTOCOL_TLSv1: u32 = SslVersion::Tls1 as u32;

#[pyattr]

const PROTOCOL_TLSv1_1: u32 = SslVersion::Tls1_1 as u32;

#[pyattr]

const PROTOCOL_TLSv1_2: u32 = SslVersion::Tls1_2 as u32;

#[pyattr]

const PROTO_MINIMUM_SUPPORTED: i32 = ProtoVersion::MinSupported as i32;

#[pyattr]

const PROTO_SSLv3: i32 = ProtoVersion::Ssl3 as i32;

#[pyattr]

const PROTO_TLSv1: i32 = ProtoVersion::Tls1 as i32;

#[pyattr]

const PROTO_TLSv1_1: i32 = ProtoVersion::Tls1_1 as i32;

#[pyattr]

const PROTO_TLSv1_2: i32 = ProtoVersion::Tls1_2 as i32;

#[pyattr]

const PROTO_TLSv1_3: i32 = ProtoVersion::Tls1_3 as i32;

#[pyattr]

const PROTO_MAXIMUM_SUPPORTED: i32 = ProtoVersion::MaxSupported as i32;

#[pyattr]

const OP_ALL: core::ffi::c_ulong =

(sys::SSL_OP_ALL & !sys::SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS) as _;

#[pyattr]

const HAS_TLS_UNIQUE: bool = true;

#[pyattr]

const CERT_NONE: u32 = CertRequirements::None as u32;

#[pyattr]

const CERT_OPTIONAL: u32 = CertRequirements::Optional as u32;

#[pyattr]

const CERT_REQUIRED: u32 = CertRequirements::Required as u32;

#[pyattr]

const VERIFY_DEFAULT: u32 = 0;

#[pyattr]

const HAS_SNI: bool = true;

#[pyattr]

const HAS_ECDH: bool = true;

#[pyattr]

const HAS_NPN: bool = false;

#[pyattr]

const HAS_ALPN: bool = true;

#[pyattr]

const HAS_SSLv2: bool = false;

#[pyattr]

const HAS_SSLv3: bool = false;

#[pyattr]

const HAS_TLSv1: bool = true;

#[pyattr]

const HAS_TLSv1_1: bool = true;

#[pyattr]

const HAS_TLSv1_2: bool = true;

#[pyattr]

const HAS_TLSv1_3: bool = cfg!(ossl111);

#[pyattr]

const HAS_PSK: bool = true;

#[pyattr]

const HAS_PHA: bool = cfg!(ossl111);

// Encoding constants for Certificate.public_bytes()

#[pyattr]

pub(crate) const ENCODING_PEM: i32 = sys::X509_FILETYPE_PEM;

#[pyattr]

pub(crate) const ENCODING_DER: i32 = sys::X509_FILETYPE_ASN1;

#[pyattr]

const ENCODING_PEM_AUX: i32 = sys::X509_FILETYPE_PEM + 0x100;

// OpenSSL error codes for unexpected EOF detection

const ERR_LIB_SSL: i32 = 20;

const SSL_R_UNEXPECTED_EOF_WHILE_READING: i32 = 294;

// SSL_VERIFY constants for post-handshake authentication

#[cfg(ossl111)]

const SSL_VERIFY_POST_HANDSHAKE: core::ffi::c_int = 0x20;

// the openssl version from the API headers

#[pyattr(name = "OPENSSL_VERSION")]

fn openssl_version(_vm: &VirtualMachine) -> &str {

openssl::version::version()

}

#[pyattr(name = "OPENSSL_VERSION_NUMBER")]

fn openssl_version_number(_vm: &VirtualMachine) -> i64 {

openssl::version::number()

}

#[pyattr(name = "OPENSSL_VERSION_INFO")]

fn openssl_version_info(_vm: &VirtualMachine) -> OpensslVersionInfo {

parse_version_info(openssl::version::number())

}

#[pyattr(name = "_OPENSSL_API_VERSION")]

fn _openssl_api_version(_vm: &VirtualMachine) -> OpensslVersionInfo {

let openssl_api_version = i64::from_str_radix(env!("OPENSSL_API_VERSION"), 16)

.expect("OPENSSL_API_VERSION is malformed");

parse_version_info(openssl_api_version)

}

type OpensslVersionInfo = (u8, u8, u8, u8, u8);

const fn parse_version_info(mut n: i64) -> OpensslVersionInfo {

let status = (n & 0xF) as u8;

n >>= 4;

let patch = (n & 0xFF) as u8;

n >>= 8;

let fix = (n & 0xFF) as u8;

n >>= 8;

let minor = (n & 0xFF) as u8;

n >>= 8;

let major = (n & 0xFF) as u8;

(major, minor, fix, patch, status)

}

#[derive(Copy, Clone, num_enum::IntoPrimitive, num_enum::TryFromPrimitive, PartialEq)]

#[repr(i32)]

enum SslVersion {

Ssl2,

Ssl3 = 1,

Tls,

Tls1,

Tls1_1,

Tls1_2,

TlsClient = 0x10,

TlsServer,

}

#[derive(Copy, Clone, num_enum::IntoPrimitive, num_enum::TryFromPrimitive)]

#[repr(i32)]

enum ProtoVersion {

MinSupported = -2,

Ssl3 = sys::SSL3_VERSION,

Tls1 = sys::TLS1_VERSION,

Tls1_1 = sys::TLS1_1_VERSION,

Tls1_2 = sys::TLS1_2_VERSION,

#[cfg(ossl111)]

Tls1_3 = sys::TLS1_3_VERSION,

#[cfg(not(ossl111))]

Tls1_3 = 0x304,

MaxSupported = -1,

}

#[derive(num_enum::IntoPrimitive, num_enum::TryFromPrimitive)]

#[repr(i32)]

enum CertRequirements {

None,

Optional,

Required,

}

#[derive(Debug, PartialEq)]

enum SslServerOrClient {

Client,

Server,

}

unsafe fn ptr2obj(ptr: *mut sys::ASN1_OBJECT) -> Option<Asn1Object> {

if ptr.is_null() {

None

} else {

Some(unsafe { Asn1Object::from_ptr(ptr) })

}

}

fn _txt2obj(s: &CStr, no_name: bool) -> Option<Asn1Object> {

unsafe { ptr2obj(sys::OBJ_txt2obj(s.as_ptr(), i32::from(no_name))) }

}

fn _nid2obj(nid: Nid) -> Option<Asn1Object> {

unsafe { ptr2obj(sys::OBJ_nid2obj(nid.as_raw())) }

}

type PyNid = (core::ffi::c_int, String, String, Option<String>);

fn obj2py(obj: &Asn1ObjectRef, vm: &VirtualMachine) -> PyResult<PyNid> {

let nid = obj.nid();

let short_name = nid

.short_name()

.map_err(|_| vm.new_value_error("NID has no short name"))?

.to_owned();

let long_name = nid

.long_name()

.map_err(|_| vm.new_value_error("NID has no long name"))?

.to_owned();

Ok((

nid.as_raw(),

short_name,

long_name,

cert::obj2txt(obj, true),

))

}

#[derive(FromArgs)]

struct Txt2ObjArgs {

txt: PyStrRef,

#[pyarg(any, default)]

name: bool,

}

#[pyfunction]

fn txt2obj(args: Txt2ObjArgs, vm: &VirtualMachine) -> PyResult<PyNid> {

_txt2obj(&args.txt.to_cstring(vm)?, !args.name)

.as_deref()

.ok_or_else(|| vm.new_value_error(format!("unknown object '{}'", args.txt)))

.and_then(|obj| obj2py(obj, vm))

}

#[pyfunction]

fn nid2obj(nid: core::ffi::c_int, vm: &VirtualMachine) -> PyResult<PyNid> {

_nid2obj(Nid::from_raw(nid))

.as_deref()

.ok_or_else(|| vm.new_value_error(format!("unknown NID {nid}")))

.and_then(|obj| obj2py(obj, vm))

}

fn path_from_cstr(c: &CStr) -> PathBuf {

#[cfg(unix)]

{

use std::os::unix::ffi::OsStrExt;

std::ffi::OsStr::from_bytes(c.to_bytes()).into()

}

#[cfg(windows)]

{

PathBuf::from(c.to_string_lossy().as_ref())

}

}

fn openssl_default_cert_paths() -> (PathBuf, PathBuf) {

(

path_from_cstr(unsafe { CStr::from_ptr(sys::X509_get_default_cert_file()) }),

path_from_cstr(unsafe { CStr::from_ptr(sys::X509_get_default_cert_dir()) }),

)

}

fn get_cert_file_dir() -> (PathBuf, PathBuf) {

cfg_select! {

all(openssl_vendored, not(target_arch = "wasm32")) => {

let (cert_file, cert_dir) =

rustpython_host_env::native_certs::default_verify_paths();

(PathBuf::from(cert_file), PathBuf::from(cert_dir))

}

_ => openssl_default_cert_paths(),

}

}

// Lazily compute and cache cert environment variable names

static CERT_ENV_NAMES: LazyLock<(String, String)> = LazyLock::new(|| {

let cert_file_env = unsafe { CStr::from_ptr(sys::X509_get_default_cert_file_env()) }

.to_string_lossy()

.into_owned();

let cert_dir_env = unsafe { CStr::from_ptr(sys::X509_get_default_cert_dir_env()) }

.to_string_lossy()

.into_owned();

(cert_file_env, cert_dir_env)

});

#[pyfunction]

fn get_default_verify_paths(

vm: &VirtualMachine,

) -> PyResult<(&'static str, PyObjectRef, &'static str, PyObjectRef)> {

let (cert_file_env, cert_dir_env) = &*CERT_ENV_NAMES;

let (cert_file, cert_dir) = get_cert_file_dir();

let cert_file = OsPath::new_str(cert_file.as_path()).filename(vm);

let cert_dir = OsPath::new_str(cert_dir.as_path()).filename(vm);

Ok((

cert_file_env.as_str(),

cert_file,

cert_dir_env.as_str(),

cert_dir,

))

}

#[pyfunction(name = "RAND_status")]

fn rand_status() -> i32 {

unsafe { sys::RAND_status() }

}

#[pyfunction(name = "RAND_add")]

fn rand_add(string: ArgStrOrBytesLike, entropy: f64) {

let f = |b: &[u8]| {

for buf in b.chunks(core::ffi::c_int::MAX as usize) {

unsafe { sys::RAND_add(buf.as_ptr() as *const _, buf.len() as _, entropy) }

}

};

f(&string.borrow_bytes())

}

#[pyfunction(name = "RAND_bytes")]

fn rand_bytes(n: i32, vm: &VirtualMachine) -> PyResult<Vec<u8>> {

if n < 0 {

return Err(vm.new_value_error("num must be positive"));

}

let mut buf = vm.new_zeroed_bytes(n as usize)?;

openssl::rand::rand_bytes(&mut buf).map_err(|e| convert_openssl_error(vm, e))?;

Ok(buf)

}

// Callback data stored in SSL ex_data for SNI/msg callbacks

struct SniCallbackData {

ssl_context: PyRef<PySslContext>,

// Use weak reference to avoid reference cycle:

// PySslSocket -> SslStream -> SSL -> ex_data -> SniCallbackData -> PySslSocket

ssl_socket_weak: PyRef<PyWeak>,

}

// Thread-local storage for VirtualMachine pointer during handshake

// SNI callback is only called during handshake which is synchronous

thread_local! {

static HANDSHAKE_VM: core::cell::Cell<Option<*const VirtualMachine>> = const { core::cell::Cell::new(None) };

// SSL pointer during handshake - needed because connection lock is held during handshake

// and callbacks may need to access SSL without acquiring the lock

static HANDSHAKE_SSL_PTR: core::cell::Cell<Option<*mut sys::SSL>> = const { core::cell::Cell::new(None) };

}

// RAII guard to set/clear thread-local handshake context

struct HandshakeVmGuard {

_ssl_ptr: *mut sys::SSL,

}

impl HandshakeVmGuard {

fn new(vm: &VirtualMachine, ssl_ptr: *mut sys::SSL) -> Self {

HANDSHAKE_VM.with(|cell| cell.set(Some(vm as *const _)));

HANDSHAKE_SSL_PTR.with(|cell| cell.set(Some(ssl_ptr)));

HandshakeVmGuard { _ssl_ptr: ssl_ptr }

}

}

impl Drop for HandshakeVmGuard {

fn drop(&mut self) {

HANDSHAKE_VM.with(|cell| cell.set(None));

HANDSHAKE_SSL_PTR.with(|cell| cell.set(None));

}

}

// Get SSL pointer - either from thread-local (during handshake) or from connection

fn get_ssl_ptr_for_context_change(

connection: &PyDetachingRwLock<SslConnection>,

) -> *mut sys::SSL {

// First check if we're in a handshake callback (lock already held)

if let Some(ptr) = HANDSHAKE_SSL_PTR.with(|cell| cell.get()) {

return ptr;

}

// Otherwise, acquire the lock normally

connection.read().ssl().as_ptr()

}

// Get or create an ex_data index for SNI callback data

fn get_sni_ex_data_index() -> core::ffi::c_int {

use rustpython_common::lock::LazyLock;

static SNI_EX_DATA_IDX: LazyLock<core::ffi::c_int> = LazyLock::new(|| unsafe {

sys::SSL_get_ex_new_index(

0,

core::ptr::null_mut(),

None,

None,

Some(sni_callback_data_free),

)

});

*SNI_EX_DATA_IDX

}

// Free function for callback data

// NOTE: We don't free the data here because it's managed manually in do_handshake

// to avoid use-after-free when the SSL object is dropped after timeout

unsafe extern "C" fn sni_callback_data_free(

_parent: *mut core::ffi::c_void,

_ptr: *mut core::ffi::c_void,

_ad: *mut sys::CRYPTO_EX_DATA,

_idx: core::ffi::c_int,

_argl: core::ffi::c_long,

_argp: *mut core::ffi::c_void,

) {

// Intentionally empty - data is freed in cleanup_sni_ex_data()

}

// Clean up SNI callback data from SSL ex_data

// Called after handshake to free the data and release references

unsafe fn cleanup_sni_ex_data(ssl_ptr: *mut sys::SSL) {

unsafe {

let idx = get_sni_ex_data_index();

let data_ptr = sys::SSL_get_ex_data(ssl_ptr, idx);

if !data_ptr.is_null() {

// Free the Box<SniCallbackData> - this releases references to context and socket

let _ = Box::from_raw(data_ptr as *mut SniCallbackData);

// Clear the ex_data to prevent double-free

sys::SSL_set_ex_data(ssl_ptr, idx, core::ptr::null_mut());

}

}

}

// Get or create an ex_data index for msg_callback data

fn get_msg_callback_ex_data_index() -> core::ffi::c_int {

use rustpython_common::lock::LazyLock;

static MSG_CB_EX_DATA_IDX: LazyLock<core::ffi::c_int> = LazyLock::new(|| unsafe {

sys::SSL_get_ex_new_index(

0,

core::ptr::null_mut(),

None,

None,

Some(msg_callback_data_free),

)

});

*MSG_CB_EX_DATA_IDX

}

// Free function for msg_callback data - called by OpenSSL when SSL is freed

unsafe extern "C" fn msg_callback_data_free(

_parent: *mut core::ffi::c_void,

ptr: *mut core::ffi::c_void,

_ad: *mut sys::CRYPTO_EX_DATA,

_idx: core::ffi::c_int,

_argl: core::ffi::c_long,

_argp: *mut core::ffi::c_void,

) {

if !ptr.is_null() {

unsafe {

// Reconstruct PyObjectRef and drop to decrement reference count

let raw = core::ptr::NonNull::new_unchecked(ptr as *mut PyObject);

let _ = PyObjectRef::from_raw(raw);

}

}

}

// SNI callback function called by OpenSSL

unsafe extern "C" fn _servername_callback(

ssl_ptr: *mut sys::SSL,

al: *mut core::ffi::c_int,

arg: *mut core::ffi::c_void,

) -> core::ffi::c_int {

const SSL_TLSEXT_ERR_OK: core::ffi::c_int = 0;

const SSL_TLSEXT_ERR_ALERT_FATAL: core::ffi::c_int = 2;

const SSL_AD_INTERNAL_ERROR: core::ffi::c_int = 80;

const TLSEXT_NAMETYPE_host_name: core::ffi::c_int = 0;

if arg.is_null() {

return SSL_TLSEXT_ERR_OK;

}

unsafe {

let ctx = &*(arg as *const PySslContext);

// Nothing to call: leave without reaching the interpreter at all.

if ctx.sni_callback.lock().is_none() {

return SSL_TLSEXT_ERR_OK;

}

// Get callback data from SSL ex_data

let idx = get_sni_ex_data_index();

let data_ptr = sys::SSL_get_ex_data(ssl_ptr, idx);

if data_ptr.is_null() {

return SSL_TLSEXT_ERR_ALERT_FATAL;

}

let callback_data = &*(data_ptr as *const SniCallbackData);

// Get VM from thread-local storage (set by HandshakeVmGuard in do_handshake)

let Some(vm_ptr) = HANDSHAKE_VM.with(|cell| cell.get()) else {

// VM not available - this shouldn't happen during handshake

*al = SSL_AD_INTERNAL_ERROR;

return SSL_TLSEXT_ERR_ALERT_FATAL;

};

let vm = &*vm_ptr;

// The handshake this runs inside has left the interpreter, so

// everything below rejoins it first — taking a reference to the

// callback already counts — and gives the thread back after.

vm.attach_for_callback(|| {

// Get the callback

let callback_opt = ctx.sni_callback.lock().clone();

let Some(callback) = callback_opt else {

return SSL_TLSEXT_ERR_OK;

};

// Get server name

let servername = sys::SSL_get_servername(ssl_ptr, TLSEXT_NAMETYPE_host_name);

let server_name_arg = if servername.is_null() {

vm.ctx.none()

} else {

let name_cstr = core::ffi::CStr::from_ptr(servername);

match name_cstr.to_str() {

Ok(name_str) => vm.ctx.new_str(name_str).into(),

Err(_) => vm.ctx.none(),

}

};

// Get SSL socket from callback data via weak reference

let ssl_socket_obj = callback_data

.ssl_socket_weak

.upgrade()

.unwrap_or_else(|| vm.ctx.none());

// Call the Python callback

match callback.call(

(

ssl_socket_obj,

server_name_arg,

callback_data.ssl_context.to_owned(),

),

vm,

) {

Ok(result) => {

// Check return value type (must be None or integer)

if vm.is_none(&result) {

// None is OK

SSL_TLSEXT_ERR_OK

} else {

// Try to convert to integer

match result.try_to_value::<i32>(vm) {

Ok(alert_code) => {

// Valid integer - use as alert code

*al = alert_code;

SSL_TLSEXT_ERR_ALERT_FATAL

}

Err(_) => {

// Type conversion failed - raise TypeError

let type_error = vm.new_type_error(format!(

"servername callback must return None or an integer, not '{}'",

result.class().name()

));

vm.run_unraisable(type_error, None, result);

*al = SSL_AD_INTERNAL_ERROR;

SSL_TLSEXT_ERR_ALERT_FATAL

}

}

}

}

Err(exc) => {

// Log the exception but don't propagate it

vm.run_unraisable(exc, None, vm.ctx.none());

*al = SSL_AD_INTERNAL_ERROR;

SSL_TLSEXT_ERR_ALERT_FATAL

}

}

})

}

}

// OpenSSL record type constants for msg_callback

const SSL3_RT_CHANGE_CIPHER_SPEC: i32 = 20;

const SSL3_RT_ALERT: i32 = 21;

const SSL3_RT_HANDSHAKE: i32 = 22;

const SSL3_RT_HEADER: i32 = 256;

const SSL3_RT_INNER_CONTENT_TYPE: i32 = 257;

// Special value for change cipher spec (CPython compatibility)

const SSL3_MT_CHANGE_CIPHER_SPEC: i32 = 0x0101;

// Message callback function called by OpenSSL

// Called during SSL operations to report protocol messages.

// debughelpers.c:_PySSL_msg_callback

unsafe extern "C" fn _msg_callback(

write_p: core::ffi::c_int,

mut version: core::ffi::c_int,

content_type: core::ffi::c_int,

buf: *const core::ffi::c_void,

len: usize,

ssl_ptr: *mut sys::SSL,

_arg: *mut core::ffi::c_void,

) {

if ssl_ptr.is_null() {

return;

}

unsafe {

// Get SSL socket from ex_data using the dedicated index

let idx = get_msg_callback_ex_data_index();

let ssl_socket_ptr = sys::SSL_get_ex_data(ssl_ptr, idx);

if ssl_socket_ptr.is_null() {

return;

}

// ssl_socket_ptr is a pointer to Box<Py<PySslSocket>>, set in _wrap_socket/_wrap_bio

let ssl_socket: &Py<PySslSocket> = &*(ssl_socket_ptr as *const Py<PySslSocket>);

// Nothing to call: leave without reaching the interpreter at all.

if ssl_socket.ctx.read().msg_callback.lock().is_none() {

return;

}

// Get VM from thread-local storage (set by HandshakeVmGuard in do_handshake)

let Some(vm_ptr) = HANDSHAKE_VM.with(|cell| cell.get()) else {

// VM not available - this shouldn't happen during handshake

return;

};

let vm = &*vm_ptr;

// The SSL call this reports from has left the interpreter; rejoin

// it for the duration of the callback, as `_servername_callback`

// does above.

vm.attach_for_callback(|| {

// Get the callback from the context

let callback_opt = ssl_socket.ctx.read().msg_callback.lock().clone();

let Some(callback) = callback_opt else {

return;

};

// Get SSL socket owner object

let ssl_socket_obj = ssl_socket

.owner

.read()

.as_ref()

.and_then(|weak| weak.upgrade())

.unwrap_or_else(|| vm.ctx.none());

// Create the message bytes

let buf_slice = core::slice::from_raw_parts(buf as *const u8, len);

let msg_bytes = vm.ctx.new_bytes(buf_slice.to_vec());

// Determine direction string

let direction_str = if write_p != 0 { "write" } else { "read" };

// Calculate msg_type based on content_type (debughelpers.c behavior)

let msg_type = match content_type {

SSL3_RT_CHANGE_CIPHER_SPEC => SSL3_MT_CHANGE_CIPHER_SPEC,

SSL3_RT_ALERT if len >= 2 => {

// byte 1 is alert type

buf_slice[1] as i32

}

SSL3_RT_HANDSHAKE if !buf_slice.is_empty() => {

// byte 0 is handshake type

buf_slice[0] as i32

}

SSL3_RT_HEADER if len >= 3 => {

// Frame header: version in bytes 1..2, type in byte 0

version = ((buf_slice[1] as i32) << 8) | (buf_slice[2] as i32);

buf_slice[0] as i32

}

SSL3_RT_INNER_CONTENT_TYPE if !buf_slice.is_empty() => {

// Inner content type in byte 0

buf_slice[0] as i32

}

_ => -1,

};

// Call the Python callback

// Signature: callback(conn, direction, version, content_type, msg_type, data)

match callback.call(

(

ssl_socket_obj,

vm.ctx.new_str(direction_str),

vm.ctx.new_int(version),

vm.ctx.new_int(content_type),

vm.ctx.new_int(msg_type),

msg_bytes,

),

vm,

) {

Ok(_) => {}

Err(exc) => {

// Log the exception but don't propagate it

vm.run_unraisable(exc, None, vm.ctx.none());

}

}

})

}

}

#[pyfunction(name = "RAND_pseudo_bytes")]

fn rand_pseudo_bytes(n: i32, vm: &VirtualMachine) -> PyResult<(Vec<u8>, bool)> {

if n < 0 {

return Err(vm.new_value_error("num must be positive"));

}

let mut buf = vm.new_zeroed_bytes(n as usize)?;

let ret = unsafe { sys::RAND_bytes(buf.as_mut_ptr(), n) };

match ret {

0 | 1 => Ok((buf, ret == 1)),

_ => Err(convert_openssl_error(vm, ErrorStack::get())),

}

}

#[pyattr]

#[pyclass(module = "_ssl", name = "_SSLContext")]

#[derive(PyPayload)]

struct PySslContext {

ctx: PyRwLock<SslContextBuilder>,

check_hostname: AtomicCell<bool>,

protocol: SslVersion,

post_handshake_auth: PyMutex<bool>,

sni_callback: PyMutex<Option<PyObjectRef>>,

msg_callback: PyMutex<Option<PyObjectRef>>,

psk_client_callback: PyMutex<Option<PyObjectRef>>,

psk_server_callback: PyMutex<Option<PyObjectRef>>,

psk_identity_hint: PyMutex<Option<String>>,

}

impl fmt::Debug for PySslContext {

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

f.pad("_SSLContext")

}

}

fn builder_as_ctx(x: &SslContextBuilder) -> &ssl::SslContextRef {

unsafe { ssl::SslContextRef::from_ptr(x.as_ptr()) }

}

impl Constructor for PySslContext {

type Args = i32;

fn py_new(

_cls: &Py<PyType>,

proto_version: Self::Args,

vm: &VirtualMachine,

) -> PyResult<Self> {

let proto = SslVersion::try_from(proto_version)

.map_err(|_| vm.new_value_error("invalid protocol version"))?;

let (method, deprecated_protocol) = match proto {

// SslVersion::Ssl3 => unsafe { ssl::SslMethod::from_ptr(sys::SSLv3_method()) },

SslVersion::Tls => (ssl::SslMethod::tls(), Some("PROTOCOL_TLS")),

SslVersion::Tls1 => (ssl::SslMethod::tls(), Some("PROTOCOL_TLSv1")),

SslVersion::Tls1_1 => (ssl::SslMethod::tls(), Some("PROTOCOL_TLSv1_1")),

SslVersion::Tls1_2 => (ssl::SslMethod::tls(), Some("PROTOCOL_TLSv1_2")),

SslVersion::TlsClient => (ssl::SslMethod::tls_client(), None),