pithos 0.8.0

CLI for the Pithos container file format
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::PithosCliError;
use pithos_lib::crypto::{PrivateKey, PublicKey};
use rustix::fs::{Mode, OFlags, open};
use std::fs::File;
use std::io::Read;
use std::path::Path;
use zeroize::Zeroizing;

/// PEM key files are small; this bounds memory use and rejects appended data.
const MAX_PEM_FILE_BYTES: usize = 1024 * 1024;

pub fn load_private_key_from_pem(filepath: &Path) -> Result<PrivateKey, PithosCliError> {
    let mut file_content = Zeroizing::new(Vec::new());
    read_bounded_pem_file(
        filepath,
        "load private key",
        "inspect private key",
        "read private key",
        "private",
        &mut file_content,
    )?;

    pithos_lib::crypto::parse_private_pem(&file_content).map_err(|source| {
        PithosCliError::KeyParse {
            operation: "parse private key",
            path: filepath.to_path_buf(),
            source,
        }
    })
}

pub fn load_public_key_from_pem(filepath: &Path) -> Result<PublicKey, PithosCliError> {
    let mut file_content = Vec::new();
    read_bounded_pem_file(
        filepath,
        "load public key",
        "inspect public key",
        "read public key",
        "public",
        &mut file_content,
    )?;

    pithos_lib::crypto::parse_public_pem(&file_content).map_err(|source| PithosCliError::KeyParse {
        operation: "parse public key",
        path: filepath.to_path_buf(),
        source,
    })
}

fn read_bounded_pem_file(
    filepath: &Path,
    load_operation: &'static str,
    inspect_operation: &'static str,
    read_operation: &'static str,
    key_kind: &'static str,
    file_content: &mut Vec<u8>,
) -> Result<(), PithosCliError> {
    // Keep metadata and reads bound to the same no-follow descriptor.
    let mut file = File::from(
        open(
            filepath,
            OFlags::RDONLY | OFlags::NOFOLLOW | OFlags::CLOEXEC,
            Mode::empty(),
        )
        .map_err(|source| PithosCliError::KeyFile {
            operation: load_operation,
            path: filepath.to_path_buf(),
            source: source.into(),
        })?,
    );

    let declared_len = file
        .metadata()
        .map_err(|source| PithosCliError::KeyFile {
            operation: inspect_operation,
            path: filepath.to_path_buf(),
            source,
        })?
        .len();
    if declared_len > MAX_PEM_FILE_BYTES as u64 {
        return Err(PithosCliError::KeyFile {
            operation: read_operation,
            path: filepath.to_path_buf(),
            source: std::io::Error::new(
                std::io::ErrorKind::InvalidData,
                format!("{key_kind} key file exceeds {MAX_PEM_FILE_BYTES}-byte limit"),
            ),
        });
    }

    let content_len = usize::try_from(declared_len).map_err(|_| PithosCliError::KeyFile {
        operation: read_operation,
        path: filepath.to_path_buf(),
        source: std::io::Error::new(
            std::io::ErrorKind::InvalidData,
            format!("{key_kind} key file exceeds {MAX_PEM_FILE_BYTES}-byte limit"),
        ),
    })?;
    file_content.resize(content_len, 0);
    file.read_exact(file_content)
        .map_err(|source| PithosCliError::KeyFile {
            operation: read_operation,
            path: filepath.to_path_buf(),
            source,
        })?;
    let mut trailing_byte = [0u8; 1];
    if file
        .read(&mut trailing_byte)
        .map_err(|source| PithosCliError::KeyFile {
            operation: read_operation,
            path: filepath.to_path_buf(),
            source,
        })?
        != 0
    {
        return Err(PithosCliError::KeyFile {
            operation: read_operation,
            path: filepath.to_path_buf(),
            source: std::io::Error::new(
                std::io::ErrorKind::InvalidData,
                format!("{key_kind} key file has trailing content"),
            ),
        });
    }

    Ok(())
}