making a message encrypter and decrypter and I am running into some lifetime problems when using speedy to decode the object here is my current code
use flate2::read::ZlibDecoder;
use flate2::write::ZlibEncoder;
use flate2::Compression;
use rsa::{pkcs1::DecodeRsaPublicKey, pkcs8::DecodePrivateKey, Pkcs1v15Encrypt};
use speedy::{LittleEndian, Readable, Writable};
use std::io::Read;
pub struct Communication {
client_priv_key: rsa::RsaPrivateKey,
server_pub_key: rsa::RsaPublicKey,
rng: rand::rngs::ThreadRng,
}
impl Communication {
pub fn new(priv_key: &str, pub_key: &str) -> Self {
let client_priv_key = rsa::RsaPrivateKey::from_pkcs8_pem(priv_key).unwrap();
let server_pub_key = rsa::RsaPublicKey::from_pkcs1_pem(pub_key).unwrap();
let rng = rand::thread_rng();
Self {
client_priv_key,
server_pub_key,
rng,
}
}
pub fn encrypt_object<T>(&mut self, obj: &T) -> Vec<u8>
where
T: Writable<LittleEndian>,
{
let mut buffer = Vec::new();
obj.write_to_stream(&mut buffer).unwrap();
let encoder = ZlibEncoder::new(buffer, Compression::default());
let buffer = encoder.finish().unwrap();
self.server_pub_key
.encrypt(&mut self.rng, Pkcs1v15Encrypt, &buffer)
.unwrap()
}
pub fn decrypt_object<'a, T>(&self, buffer: &'a [u8]) -> Result<T, speedy::Error>
where
T: Readable<'a, LittleEndian>,
{
let decrypted_buffer = self
.client_priv_key
.decrypt(Pkcs1v15Encrypt, buffer)
.map_err(|_| speedy::Error::custom("Decryption failed"))?;
let mut decoder = ZlibDecoder::new(decrypted_buffer.as_slice());
let mut decompressed_buffer: Vec<u8> = Vec::new();
decoder
.read_to_end(&mut decompressed_buffer)
.map_err(|_| speedy::Error::custom("Decompression failed"))?;
T::read_from_buffer(decompressed_buffer.as_slice())
}
}
cargo check output
Checking client v0.1.0 (/workspaces/codespaces-blank)
error[E0597]: `decompressed_buffer` does not live long enough
--> src/lib.rs:54:29
|
39 | pub fn decrypt_object<'a, T>(&self, buffer: &'a [u8]) -> Result<T, speedy::Er...
| -- lifetime `'a` defined here
...
49 | let mut decompressed_buffer: Vec<u8> = Vec::new();
| ----------------------- binding `decompressed_buffer` declared here
...
54 | T::read_from_buffer(decompressed_buffer.as_slice())
| --------------------^^^^^^^^^^^^^^^^^^^------------
| | |
| | borrowed value does not live long enough
| argument requires that `decompressed_buffer` is borrowed for `'a`
55 | }
| - `decompressed_buffer` dropped here while still borrowed
For more information about this error, try `rustc --explain E0597`.
error: could not compile `client` (lib) due to 1 previous error
I tried multiple different lifetime configurations and none of them work and I expect the code to decode the supplied buffer but it just runs into a lifetime error
The issue is that the lifetime 'a is bound to buffer, but you aren't deserializing from buffer but from decompressed_buffer which is a local variable and thus can't satisfy the lifetime that T: Readable<'a, _> expects.
To fix this, you can use a higher-ranked trait bound to require that T is Readable for any lifetime:
pub fn decrypt_object<T>(&self, buffer: &[u8]) -> Result<T, speedy::Error>
where
T: for<'a> Readable<'a, LittleEndian>,