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

// Copyright 2018 Developers of the Rand project.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

//! Helper functions to read from a random device such as `/dev/urandom`.
//!
//! All instances use a single internal file handle, to prevent possible
//! exhaustion of file descriptors.
use rand_core::{Error, ErrorKind};
use std::fs::File;
use std::io;
use std::io::Read;
use std::sync::{Once, Mutex, ONCE_INIT};

// TODO: remove outer Option when `Mutex::new(None)` is a constant expression
static mut READ_RNG_FILE: Option<Mutex<Option<File>>> = None;
static READ_RNG_ONCE: Once = ONCE_INIT;

#[allow(unused)]
pub fn open<F>(path: &'static str, open_fn: F) -> Result<(), Error>
    where F: Fn(&'static str) -> Result<File, io::Error>
{
    READ_RNG_ONCE.call_once(|| {
        unsafe { READ_RNG_FILE = Some(Mutex::new(None)) }
    });

    // We try opening the file outside the `call_once` fn because we cannot
    // clone the error, thus we must retry on failure.

    let mutex = unsafe { READ_RNG_FILE.as_ref().unwrap() };
    let mut guard = mutex.lock().unwrap();
    if (*guard).is_none() {
        info!("OsRng: opening random device {}", path);
        let file = open_fn(path).map_err(map_err)?;
        *guard = Some(file);
    };
    Ok(())
}

pub fn read(dest: &mut [u8]) -> Result<(), Error> {
    // We expect this function only to be used after `random_device::open`
    // was succesful. Therefore we can assume that our memory was set with a
    // valid object.
    let mutex = unsafe { READ_RNG_FILE.as_ref().unwrap() };
    let mut guard = mutex.lock().unwrap();
    let file = (*guard).as_mut().unwrap();

    // Use `std::io::read_exact`, which retries on `ErrorKind::Interrupted`.
    file.read_exact(dest).map_err(|err| {
        Error::with_cause(ErrorKind::Unavailable,
                          "error reading random device", err)
    })

}

pub fn map_err(err: io::Error) -> Error {
    match err.kind() {
        io::ErrorKind::Interrupted =>
                Error::new(ErrorKind::Transient, "interrupted"),
        io::ErrorKind::WouldBlock =>
                Error::with_cause(ErrorKind::NotReady,
                "OS RNG not yet seeded", err),
        _ => Error::with_cause(ErrorKind::Unavailable,
                "error while opening random device", err)
    }
}