cryptr 0.10.0

simple encrypted (streaming) values
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use crate::stream::{EncStreamWriter, LastStreamElement, StreamChunk};
use crate::CryptrError;
use async_trait::async_trait;
use flume::Receiver;
use std::fmt::Formatter;
use tracing::debug;

/// Streaming FileWriter
///
/// Available with feature `streaming` only
#[derive(Debug)]
pub struct FileWriter<'a> {
    pub path: &'a str,
    pub overwrite_target: bool,
}

#[async_trait]
impl EncStreamWriter for FileWriter<'_> {
    fn debug_writer(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "FileWriter({}, overwrite_target: {})",
            self.path, self.overwrite_target
        )
    }

    async fn write(
        &mut self,
        rx: Receiver<Result<(LastStreamElement, StreamChunk), CryptrError>>,
    ) -> Result<(), CryptrError> {
        use tokio::fs;
        use tokio::fs::{File, OpenOptions};
        use tokio::io::AsyncWriteExt;

        // check if the target exists already
        let mut should_remove = false;
        if let Ok(f) = File::open(&self.path).await {
            let meta = f.metadata().await?;
            if meta.is_dir() {
                return Err(CryptrError::File("Target file is a directory"));
            }

            if self.overwrite_target {
                should_remove = true;
            } else {
                return Err(CryptrError::File("Target file exists already"));
            }
        }
        if should_remove {
            fs::remove_file(&self.path).await?;
        }

        // open the file again with correct options
        let mut opts = OpenOptions::new();
        opts.append(true);
        opts.create(true);
        let mut file = opts.open(&self.path).await?;

        let mut total = 0;

        loop {
            match rx.recv_async().await {
                Ok(Ok((is_last, data))) => {
                    let payload = data.as_ref();
                    let length = file.write(payload).await?;
                    total += length;

                    if is_last == LastStreamElement::Yes {
                        debug!("Last payload received. Total bytes written: {}", total);
                        break;
                    }
                }
                Ok(Err(err)) => {
                    return Err(err);
                }
                Err(_) => {
                    return Err(CryptrError::Generic(
                        "Decryption task closed the channel".to_string(),
                    ));
                }
            }
        }

        debug!("Writer exiting: {} bytes written", total);

        Ok(())
    }
}