Я создаю библиотеку на основе Rust для Python, используя Pyo3 и maturin, которая реализует различные криптографические протоколы, и у меня возникли проблемы с работой со следующим ящиком pqc_kyber_edit, так как мне нужно получить как секретный, так и общий ключ, и я могу это сделать. Я не могу найти в документации способ обойти получение секрета, совместное использование этого значения и т. д. с другими операциями.
Мой код Python должен иметь возможность извлекать ранее упомянутые ключи и работайте с ними, моделируя общение с помощью двух серверов Flask. Чтобы добиться этого, я определил 3 операции:
#[pyfunction]
fn kyber_keygen() -> PyResult {
let mut rng = OsRng;
let keys = keypair(&mut rng)?;
Ok((keys.public.0.to_vec(), secret_key.0.to_vec()))
}
// Kyber Encapsulation
#[pyfunction]
fn kyber_encapsulate(public_key_bytes: Vec) -> PyResult { }
// Kyber Decapsulation
#[pyfunction]
fn kyber_decapsulate(ciphertext_bytes: Vec, secret_key_bytes: Vec) ->{ }
Это все часть следующего полного кода:
use pyo3::prelude::*;
use pyo3::wrap_pyfunction;
use x25519_dalek::{StaticSecret, PublicKey};
use rand::Rng;
use rand::rngs::OsRng;
use num_bigint::{BigUint, RandBigInt};
use pqc_kyber::*;
use rsa::{RsaPrivateKey, RsaPublicKey, Pkcs1v15Encrypt};
use rsa::pkcs1::{DecodeRsaPrivateKey, DecodeRsaPublicKey, EncodeRsaPrivateKey, EncodeRsaPublicKey};
use rsa::pkcs8::LineEnding;
// Diffie-Hellman
#[pyfunction]
fn generate_dh_key(p: &str, g: &str) -> PyResult {
let p = BigUint::parse_bytes(p.as_bytes(), 10).ok_or_else(|| pyo3::exceptions::PyValueError::new_err("Invalid p"))?;
let g = BigUint::parse_bytes(g.as_bytes(), 10).ok_or_else(|| pyo3::exceptions::PyValueError::new_err("Invalid g"))?;
let mut rng = OsRng;
let private_key = rng.gen_biguint_below(&p);
let public_key = g.modpow(&private_key, &p);
Ok((private_key.to_str_radix(10), public_key.to_str_radix(10)))
}
#[pyfunction]
fn derive_dh_shared_key(private_key: &str, server_public_key: &str, p: &str) -> PyResult {
let p = BigUint::parse_bytes(p.as_bytes(), 10).ok_or_else(|| pyo3::exceptions::PyValueError::new_err("Invalid p"))?;
let private_key = BigUint::parse_bytes(private_key.as_bytes(), 10).ok_or_else(|| pyo3::exceptions::PyValueError::new_err("Invalid private_key"))?;
let server_public_key = BigUint::parse_bytes(server_public_key.as_bytes(), 10).ok_or_else(|| pyo3::exceptions::PyValueError::new_err("Invalid server_public_key"))?;
let shared_secret = server_public_key.modpow(&private_key, &p);
Ok(shared_secret.to_str_radix(10))
}
// Elliptic Curve Diffie-Hellman
#[pyfunction]
fn generate_ecdh_key() -> PyResult {
let private_key = StaticSecret::random_from_rng(OsRng);
let public_key = PublicKey::from(&private_key);
Ok((private_key.to_bytes().to_vec(), public_key.as_bytes().to_vec()))
}
#[pyfunction]
fn derive_ecdh_shared_key(private_key_bytes: Vec, server_public_key_bytes: Vec) -> PyResult {
let private_key = StaticSecret::from(::try_from(private_key_bytes.as_slice()).unwrap());
let server_public_key = PublicKey::from(::try_from(server_public_key_bytes.as_slice()).unwrap());
let shared_secret = private_key.diffie_hellman(&server_public_key);
Ok(shared_secret.as_bytes().to_vec())
}
// RSA Functions
#[pyfunction]
fn generate_rsa_key() -> (String, String) {
let mut rng = OsRng;
let bits = 2048;
let private_key = RsaPrivateKey::new(&mut rng, bits).unwrap();
let public_key = RsaPublicKey::from(&private_key);
let private_pem = private_key.to_pkcs1_pem(LineEnding::LF).unwrap();
let public_pem = public_key.to_pkcs1_pem(LineEnding::LF).unwrap();
(private_pem.to_string(), public_pem)
}
#[pyfunction]
fn rsa_encrypt(public_key_pem: &str, message: &str) -> Vec {
let public_key = RsaPublicKey::from_pkcs1_pem(public_key_pem).unwrap();
let mut rng = OsRng;
public_key.encrypt(&mut rng, Pkcs1v15Encrypt, message.as_bytes()).unwrap()
}
#[pyfunction]
fn rsa_decrypt(private_key_pem: &str, encrypted_data: Vec) -> String {
let private_key = RsaPrivateKey::from_pkcs1_pem(private_key_pem).unwrap();
let decrypted_data = private_key.decrypt(Pkcs1v15Encrypt, &encrypted_data).unwrap();
String::from_utf8(decrypted_data).unwrap()
}
// Swoosh NIKE key generation and exchange
#[pyfunction]
fn swoosh_generate_keys(parameters: (usize, usize, usize)) -> PyResult {
let (q, _d, n) = parameters;
let mut rng = rand::thread_rng();
let a: Vec = (0..n * n).map(|_| rng.gen_range(0..q) as i8).collect();
let s: Vec = (0..n).map(|_| rng.gen_range(0..q) as i8).collect();
let e: Vec = (0..n).map(|_| rng.gen_range(0..q) as i8).collect();
let public_key: Vec = a.chunks(n).zip(&s).map(|(row, &s)| (row.iter().sum::() + e[s as usize % e.len()]) % q as i8).collect();
Ok((s, public_key))
}
#[pyfunction]
fn swoosh_derive_shared_key(private_key: Vec, public_key: Vec, q: usize) -> PyResult {
let shared_key: Vec = private_key.iter().zip(&public_key).map(|(&s, &p)| ((s as i16 * p as i16) % q as i16) as i8).collect();
Ok(shared_key)
}
// Crystal Kyber protocol
#[pyfunction]
fn kyber_keygen() -> PyResult {
let mut rng = OsRng;
let keys = keypair(&mut rng)?;
Ok((keys.public.0.to_vec(), secret_key.0.to_vec()))
}
// Kyber Encapsulation
#[pyfunction]
fn kyber_encapsulate(public_key_bytes: Vec) -> PyResult { }
// Kyber Decapsulation
#[pyfunction]
fn kyber_decapsulate(ciphertext_bytes: Vec, secret_key_bytes: Vec) ->{ }
#[pymodule]
fn shadow_crypt(m: &Bound
Подробнее здесь: https://stackoverflow.com/questions/787 ... -in-python
