canic-host 0.100.86

Host-side App build, Fleet install, deployment, and release-set library for Canic workspaces
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

//! Module: entropy
//!
//! Responsibility: read exact cryptographic identity bytes from the operating system.
//! Does not own: identity derivation, durable publication, collision handling, or retry policy.
//! Boundary: callers assign meaning only after the returned bytes are durably recorded.

use std::io;

///
/// EntropyError
///

#[derive(Debug)]
pub enum EntropyError {
    Io(io::Error),
    ShortRead { actual: usize },
}

/// Read one exact 32-byte cryptographic value from the operating system.
pub fn random_bytes_32() -> Result<[u8; 32], EntropyError> {
    #[cfg(unix)]
    {
        use std::{fs::File, io::Read};

        let mut source = File::open("/dev/urandom").map_err(EntropyError::Io)?;
        let mut bytes = [0; 32];
        let mut filled = 0;
        while filled < bytes.len() {
            let current = match source.read(&mut bytes[filled..]) {
                Ok(current) => current,
                Err(source) if source.kind() == io::ErrorKind::Interrupted => continue,
                Err(source) => return Err(EntropyError::Io(source)),
            };
            if current == 0 {
                return Err(EntropyError::ShortRead { actual: filled });
            }
            filled += current;
        }
        Ok(bytes)
    }

    #[cfg(not(unix))]
    {
        Err(EntropyError::Io(io::Error::new(
            io::ErrorKind::Unsupported,
            "cryptographic identity generation requires a Unix entropy source",
        )))
    }
}