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, 182 insertions, 0 deletions

diff --git a/rand/rand_os/src/linux_android.rs b/rand/rand_os/src/linux_android.rs
new file mode 100644
index 0000000..9622f93
--- /dev/null
+++ b/rand/rand_os/src/linux_android.rs
@@ -0,0 +1,182 @@
+// 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 Linux / Android
+
+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::sync::{Once, ONCE_INIT};
+
+#[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 });
+        }
+        random_device::open("/dev/urandom", &|p| File::open(p))?;
+        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 result = match self.method {
+            OsRngMethod::GetRandom => {
+                getrandom_try_fill(dest, blocking)?;
+                Ok(dest.len())
+            }
+            OsRngMethod::RandomDevice => {
+                info!("OsRng: testing random device /dev/random");
+                let mut file = OpenOptions::new()
+                    .read(true)
+                    .custom_flags(if blocking { 0 } else { libc::O_NONBLOCK })
+                    .open("/dev/random")
+                    .map_err(random_device::map_err)?;
+                file.read(&mut dest[..1]).map_err(random_device::map_err)?;
+                Ok(1)
+            }
+        };
+        OS_RNG_INITIALIZED.store(true, Ordering::Relaxed);
+        self.initialized = true;
+        result
+    }
+
+    fn method_str(&self) -> &'static str {
+        match self.method {
+            OsRngMethod::GetRandom => "getrandom",
+            OsRngMethod::RandomDevice => "/dev/urandom",
+        }
+    }
+}
+
+#[cfg(target_arch = "x86_64")]
+const NR_GETRANDOM: libc::c_long = 318;
+#[cfg(target_arch = "x86")]
+const NR_GETRANDOM: libc::c_long = 355;
+#[cfg(target_arch = "arm")]
+const NR_GETRANDOM: libc::c_long = 384;
+#[cfg(target_arch = "aarch64")]
+const NR_GETRANDOM: libc::c_long = 278;
+ #[cfg(target_arch = "s390x")]
+const NR_GETRANDOM: libc::c_long = 349;
+#[cfg(target_arch = "powerpc")]
+const NR_GETRANDOM: libc::c_long = 359;
+#[cfg(target_arch = "powerpc64")]
+const NR_GETRANDOM: libc::c_long = 359;
+#[cfg(target_arch = "mips")] // old ABI
+const NR_GETRANDOM: libc::c_long = 4353;
+#[cfg(target_arch = "mips64")]
+const NR_GETRANDOM: libc::c_long = 5313;
+#[cfg(target_arch = "sparc")]
+const NR_GETRANDOM: libc::c_long = 347;
+#[cfg(target_arch = "sparc64")]
+const NR_GETRANDOM: libc::c_long = 347;
+#[cfg(not(any(target_arch = "x86_64", target_arch = "x86",
+              target_arch = "arm", target_arch = "aarch64",
+              target_arch = "s390x", target_arch = "powerpc",
+              target_arch = "powerpc64", target_arch = "mips",
+              target_arch = "mips64", target_arch = "sparc",
+              target_arch = "sparc64")))]
+const NR_GETRANDOM: libc::c_long = 0;
+
+fn getrandom(buf: &mut [u8], blocking: bool) -> libc::c_long {
+    const GRND_NONBLOCK: libc::c_uint = 0x0001;
+
+    if NR_GETRANDOM == 0 { return -1 };
+
+    unsafe {
+        libc::syscall(NR_GETRANDOM, buf.as_mut_ptr(), buf.len(),
+                      if blocking { 0 } else { GRND_NONBLOCK })
+    }
+}
+
+fn getrandom_try_fill(dest: &mut [u8], blocking: bool) -> Result<(), Error> {
+    let mut read = 0;
+    while read < dest.len() {
+        let result = getrandom(&mut dest[read..], blocking);
+        if result == -1 {
+            let err = io::Error::last_os_error();
+            let kind = err.kind();
+            if kind == io::ErrorKind::Interrupted {
+                continue;
+            } else 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 {
+            read += result as usize;
+        }
+    }
+    Ok(())
+}
+
+fn is_getrandom_available() -> bool {
+    static CHECKER: Once = ONCE_INIT;
+    static AVAILABLE: AtomicBool = ATOMIC_BOOL_INIT;
+
+    if NR_GETRANDOM == 0 { return false };
+
+    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/urandom" });
+    });
+
+    AVAILABLE.load(Ordering::Relaxed)
+}