Rust结构体无to_bytes方法问题：Maturin/Pyo3对接Python序列化困境

我正在开发一款协议仿真与研究工具，采用Rust编写核心逻辑，通过Maturin和Pyo3封装为Python库。我依赖多个安全实现协议的crate，但每次使用crate中的结构体时都会遇到相同问题：尝试将变量数据转为字节或从字节还原，以在Python中使用这些类型时，出现如下错误：

no method named to_bytes found for struct sidh::sidh::SIDHSecretKeyBob in the current scope
method not found in SIDHSecretKeyBob

相关代码如下：

#[pyfunction]
pub fn sidh_keygen(py: Python) -> PyResult<(Py<PyBytes>, Py<PyBytes>, Py<PyBytes>, Py<PyBytes>)> {
    let mut rng = thread_rng();

    // Generate key pairs for Alice and Bob
    let (alice_public, alice_secret) = generate_alice_keypair(&mut rng);
    let (bob_public, bob_secret) = generate_bob_keypair(&mut rng);

    // Convert keys to bytes for Python compatibility
    let alice_pub_bytes = PyBytes::new_bound(py, &alice_public.to_bytes());
    let bob_pub_bytes = PyBytes::new_bound(py, &bob_public.to_bytes());
    let alice_sec_bytes = PyBytes::new_bound(py, &alice_secret.to_bytes()); // Serializing Alice's secret
    let bob_sec_bytes = PyBytes::new_bound(py, &bob_secret.to_bytes());     // Serializing Bob's secret

    // Returning both public keys and secret keys for encapsulation/decapsulation
    Ok((alice_pub_bytes.into(), alice_sec_bytes.into(), bob_pub_bytes.into(), bob_sec_bytes.into()))
}

我对Rust尚不熟悉，原以为所有类型都能便捷实现to_bytes或from_bytes转换，请问是否存在更优的Maturin/Pyo3跨语言数据类型处理方案？

1. 先确认crate的序列化支持 #

Rust没有全局默认的to_bytes方法，密码学crate的序列化实现各不相同：

• 检查sidh crate的文档，确认是否提供了序列化方法（比如serialize、as_bytes，或者需要启用特定feature）
• 在Cargo.toml中开启对应feature，例如：

  [dependencies]
  sidh = { version = "x.x.x", features = ["serde", "serialize"] }
  

2. 手动实现结构体转字节（当crate无现成方法时） #

如果目标结构体是固定大小的简单类型（密码学密钥通常满足），可以用bytemuck crate直接转换：

• 添加依赖：

  bytemuck = "1.14.0"
  

• 修改代码（需要unsafe标记，确保结构体无padding字节）：

  use bytemuck::{Pod, Zeroable, cast_slice};
  
  // 手动标记结构体符合Pod/Zeroable trait（密码学结构体一般满足要求）
  unsafe impl Zeroable for sidh::sidh::SIDHSecretKeyBob {}
  unsafe impl Pod for sidh::sidh::SIDHSecretKeyBob {}
  
  // 转换为字节数组
  let alice_sec_bytes = PyBytes::new_bound(py, cast_slice(&[alice_secret]));
  let bob_sec_bytes = PyBytes::new_bound(py, cast_slice(&[bob_secret]));
  

3. Pyo3跨类型处理的更优方案 #

（1）直接导出Rust结构体为Python类 #

无需手动转字节，用#[pyclass]包装Rust结构体，让Python直接调用方法：

use pyo3::prelude::*;

#[pyclass]
struct AliceSecretKey(sidh::sidh::SIDHSecretKeyAlice);

#[pymethods]
impl AliceSecretKey {
    // 暴露业务方法，比如计算共享密钥
    fn compute_shared(&self, bob_pub: &BobPublicKey) -> PyResult<Py<PyBytes>> {
        let shared = sidh::compute_shared_secret(&self.0, &bob_pub.0);
        // 假设共享密钥有to_bytes方法
        Ok(PyBytes::new_bound(py, &shared.to_bytes()).into())
    }
}

#[pyclass]
struct BobPublicKey(sidh::sidh::SIDHPublicKeyBob);

// 直接返回包装后的类实例给Python
#[pyfunction]
pub fn sidh_keygen(py: Python) -> PyResult<(Py<BobPublicKey>, Py<AliceSecretKey>)> {
    let mut rng = thread_rng();
    let (_, alice_secret) = generate_alice_keypair(&mut rng);
    let (bob_public, _) = generate_bob_keypair(&mut rng);
    
    Ok((
        Py::new(py, BobPublicKey(bob_public))?,
        Py::new(py, AliceSecretKey(alice_secret))?
    ))
}

这种方式避免了手动序列化的错误，Python端调用更直观。

（2）用serde统一序列化 #

如果需要在Python和Rust间传递字节数据，用serde+bincode做通用序列化：

• 添加依赖：

  serde = { version = "1.0", features = ["derive"] }
  bincode = "1.3"
  

• 包装结构体并实现序列化：

  use serde::{Serialize, Deserialize};
  
  #[derive(Serialize, Deserialize)]
  struct WrappedBobSecretKey(sidh::sidh::SIDHSecretKeyBob);
  
  // 序列化到字节
  let bob_sec_bytes = bincode::serialize(&WrappedBobSecretKey(bob_secret)).unwrap();
  let bob_sec_pybytes = PyBytes::new_bound(py, &bob_sec_bytes);
  
  // 从Python字节反序列化回Rust类型
  let py_bytes: &PyBytes = ...; // 从Python传入的字节
  let bytes = py_bytes.extract::<Vec<u8>>()?;
  let wrapped_key = bincode::deserialize::<WrappedBobSecretKey>(&bytes)?;
  let bob_secret = wrapped_key.0;
  

内容的提问来源于stack exchange，提问作者AthraelBB