Update nitrokey crate to 0.3.3

This change updates the nitrokey crate to version 0.3.3. Along with that
change we update rand to 0.6.4 because rand 0.6.1 does not yet contain a
publicly accessible rand_os. Note that we no longer require all
crates in rand's workspace, but only rand_os and rand_core, which is a
significant reduction in the number of lines of code compiled.

Import subrepo nitrokey/:nitrokey at 7cf747d56ddc0b7eeedc3caf36dcc909907a171c
Import subrepo rand/:rand at 4336232dda03323634b10ec72ddf27914aebc3a2

1 files changed, 175 insertions, 0 deletions

diff --git a/rand/rand_os/src/solaris.rs b/rand/rand_os/src/solaris.rs
new file mode 100644
index 0000000..e8965fd
--- /dev/null
+++ b/rand/rand_os/src/solaris.rs
@@ -0,0 +1,175 @@
+// 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.
+
+//! Implementation for the Solaris family
+//!
+//! Read from `/dev/random`, with chunks of limited size (1040 bytes).
+//! `/dev/random` uses the Hash_DRBG with SHA512 algorithm from NIST SP 800-90A.
+//! `/dev/urandom` uses the FIPS 186-2 algorithm, which is considered less
+//! secure. We choose to read from `/dev/random`.
+//!
+//! Since Solaris 11.3 the `getrandom` syscall is available. To make sure we can
+//! compile on both Solaris and on OpenSolaris derivatives, that do not have the
+//! function, we do a direct syscall instead of calling a library function.
+//!
+//! We have no way to differentiate between Solaris, illumos, SmartOS, etc.
+extern crate libc;
+
+use rand_core::{Error, ErrorKind};
+use super::random_device;
+use super::OsRngImpl;
+
+use std::io;
+use std::io::Read;
+use std::fs::{File, OpenOptions};
+use std::os::unix::fs::OpenOptionsExt;
+use std::sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering};
+use std::cmp;
+
+#[derive(Clone, Debug)]
+pub struct OsRng {
+    method: OsRngMethod,
+    initialized: bool,
+}
+
+#[derive(Clone, Debug)]
+enum OsRngMethod {
+    GetRandom,
+    RandomDevice,
+}
+
+impl OsRngImpl for OsRng {
+    fn new() -> Result<OsRng, Error> {
+        if is_getrandom_available() {
+            return Ok(OsRng { method: OsRngMethod::GetRandom,
+                              initialized: false });
+        }
+        let open = |p| OpenOptions::new()
+            .read(true)
+            .custom_flags(libc::O_NONBLOCK)
+            .open(p);
+        random_device::open("/dev/random", &open)?;
+        Ok(OsRng { method: OsRngMethod::RandomDevice, initialized: false })
+    }
+
+    fn fill_chunk(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+        match self.method {
+            OsRngMethod::GetRandom => getrandom_try_fill(dest, false),
+            OsRngMethod::RandomDevice => random_device::read(dest),
+        }
+    }
+
+    fn test_initialized(&mut self, dest: &mut [u8], blocking: bool)
+        -> Result<usize, Error>
+    {
+        static OS_RNG_INITIALIZED: AtomicBool = ATOMIC_BOOL_INIT;
+        if !self.initialized {
+            self.initialized = OS_RNG_INITIALIZED.load(Ordering::Relaxed);
+        }
+        if self.initialized { return Ok(0); }
+
+        let chunk_len = cmp::min(1024, dest.len());
+        let dest = &mut dest[..chunk_len];
+
+        match self.method {
+            OsRngMethod::GetRandom => getrandom_try_fill(dest, blocking)?,
+            OsRngMethod::RandomDevice => {
+                if blocking {
+                    info!("OsRng: testing random device /dev/random");
+                    // We already have a non-blocking handle, but now need a
+                    // blocking one. Not much choice except opening it twice
+                    let mut file = File::open("/dev/random")
+                        .map_err(random_device::map_err)?;
+                    file.read(dest).map_err(random_device::map_err)?;
+                } else {
+                    self.fill_chunk(dest)?;
+                }
+            }
+        };
+        OS_RNG_INITIALIZED.store(true, Ordering::Relaxed);
+        self.initialized = true;
+        Ok(chunk_len)
+    }
+
+    fn max_chunk_size(&self) -> usize {
+        // The documentation says 1024 is the maximum for getrandom, but
+        // 1040 for /dev/random.
+        1024
+    }
+
+    fn method_str(&self) -> &'static str {
+        match self.method {
+            OsRngMethod::GetRandom => "getrandom",
+            OsRngMethod::RandomDevice => "/dev/random",
+        }
+    }
+}
+
+fn getrandom(buf: &mut [u8], blocking: bool) -> libc::c_long {
+    extern "C" {
+        fn syscall(number: libc::c_long, ...) -> libc::c_long;
+    }
+
+    const SYS_GETRANDOM: libc::c_long = 143;
+    const GRND_NONBLOCK: libc::c_uint = 0x0001;
+    const GRND_RANDOM: libc::c_uint = 0x0002;
+
+    unsafe {
+        syscall(SYS_GETRANDOM, buf.as_mut_ptr(), buf.len(),
+                if blocking { 0 } else { GRND_NONBLOCK } | GRND_RANDOM)
+    }
+}
+
+fn getrandom_try_fill(dest: &mut [u8], blocking: bool) -> Result<(), Error> {
+    let result = getrandom(dest, blocking);
+    if result == -1 || result == 0 {
+        let err = io::Error::last_os_error();
+        let kind = err.kind();
+        if kind == io::ErrorKind::WouldBlock {
+            return Err(Error::with_cause(
+                ErrorKind::NotReady,
+                "getrandom not ready",
+                err,
+            ));
+        } else {
+            return Err(Error::with_cause(
+                ErrorKind::Unavailable,
+                "unexpected getrandom error",
+                err,
+            ));
+        }
+    } else if result != dest.len() as i64 {
+        return Err(Error::new(ErrorKind::Unavailable,
+                              "unexpected getrandom error"));
+    }
+    Ok(())
+}
+
+fn is_getrandom_available() -> bool {
+    use std::sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering};
+    use std::sync::{Once, ONCE_INIT};
+
+    static CHECKER: Once = ONCE_INIT;
+    static AVAILABLE: AtomicBool = ATOMIC_BOOL_INIT;
+
+    CHECKER.call_once(|| {
+        debug!("OsRng: testing getrandom");
+        let mut buf: [u8; 0] = [];
+        let result = getrandom(&mut buf, false);
+        let available = if result == -1 {
+            let err = io::Error::last_os_error().raw_os_error();
+            err != Some(libc::ENOSYS)
+        } else {
+            true
+        };
+        AVAILABLE.store(available, Ordering::Relaxed);
+        info!("OsRng: using {}", if available { "getrandom" } else { "/dev/random" });
+    });
+
+    AVAILABLE.load(Ordering::Relaxed)
+}