具有快速可读特性的 Rust 生命周期错误

Question

制作消息加密器和解密器，当使用快速解码对象时，我遇到了一些终身问题，这是我当前的代码

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())
    }
}

货物检查输出

    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

我尝试了多种不同的生命周期配置，但它们都不起作用，我希望代码能够解码提供的缓冲区，但它只是遇到了生命周期错误

Answer 1

问题是生命周期

'a

绑定到

buffer

，但您不是从

buffer

反序列化，而是从

decompressed_buffer

反序列化，这是一个局部变量，因此无法满足

T: Readable<'a, _>

期望的生命周期.

要解决此问题，您可以使用更高排名的特征，要求

T

在

any

生命周期内为 Readable：

pub fn decrypt_object<T>(&self, buffer: &[u8]) -> Result<T, speedy::Error>
where
    T: for<'a> Readable<'a, LittleEndian>,