use_heap (default)
//! | Enable features that require use of the heap, RSA in particular.
//!
@@ -131,3 +137,41 @@ mod sealed {
// ```
pub trait Sealed {}
}
+
+/// # Information about using *ring* in SGX
+///
+/// ## CPU feature detection
+/// On `x86_64-fortanix-unknown-sgx`, feature detection is done using the
+/// `std::is_x86_feature_detected` macro, which currently only supports
+/// features enabled at compile-time. You must enable at least the `aes` and
+/// `pclmul` features, otherwise *ring* will panic at runtime. See the [GitHub
+/// issue](https://github.com/fortanix/rust-sgx/issues/26) for more
+/// information.
+///
+/// To set compile-time features, you can either specify them as an environment
+/// variable:
+///
+/// ```text
+/// RUSTFLAGS="-C target-feature=+aes,+pclmul"
+/// ```
+///
+/// Or you may configure them per target in [`.cargo/config`].
+///
+/// [`.cargo/config`]: https://doc.rust-lang.org/cargo/reference/config.html#configuration-keys
+///
+/// ## Entropy source
+/// The entropy source used in SGX is the hardware random number generator
+/// provided by the RDRAND instruction.
+///
+/// ## Nightly only
+/// The `x86_64-fortanix-unknown-sgx` target is only available on nightly, and
+/// *ring* Continuous Builds only build it for nightly. See the [GitHub
+/// issue](https://github.com/briansmith/ring/issues/779) for more information.
+///
+/// ## Continuous Testing
+/// While the *ring* test suite works in SGX, and it is run manually from time
+/// to time, it doesn't run automatically as part of a Continuous Testing
+/// setup. See the [GitHub issue](https://github.com/briansmith/ring/issues/778)
+/// for more information.
+#[cfg(target_env = "sgx")]
+pub mod sgx {}
diff --git a/src/rand.rs b/src/rand.rs
index b6fb6bc4ca..f6a7c24dae 100644
--- a/src/rand.rs
+++ b/src/rand.rs
@@ -60,6 +60,8 @@ pub trait SecureRandom: sealed::Sealed {
/// On Windows, `fill` is implemented using the platform's API for secure
/// random number generation.
///
+/// On SGX, `fill()` is implemented using the `RDRAND` instruction.
+///
/// Otherwise, `fill()` is implemented by reading from `/dev/urandom`. (This is
/// something that should be improved for any platform that adds something
/// better.)
@@ -100,6 +102,7 @@ impl sealed::Sealed for SystemRandom {}
target_os = "macos",
target_os = "ios",
target_os = "fuchsia",
+ target_env = "sgx",
windows
))
))]
@@ -120,6 +123,9 @@ use self::darwin::fill as fill_impl;
#[cfg(any(target_os = "fuchsia"))]
use self::fuchsia::fill as fill_impl;
+#[cfg(target_env = "sgx")]
+use self::rdrandom::fill as fill_impl;
+
use crate::sealed;
#[cfg(target_os = "linux")]
@@ -312,6 +318,36 @@ mod fuchsia {
}
}
+#[cfg(all(target_env = "sgx", target_feature = "rdrand"))]
+mod rdrandom {
+ use crate::{bssl, error};
+
+ fn rdrand_loop() -> Result<[u8; 8], error::Unspecified> {
+ extern "C" {
+ fn CRYPTO_rdrand(out: &mut [u8; 8]) -> bssl::Result;
+ }
+
+ for _ in 0..10 {
+ let mut buf = [0u8; 8];
+ match Result::from(unsafe { CRYPTO_rdrand(&mut buf) }) {
+ Ok(()) => return Ok(buf),
+ Err(_) => continue
+ }
+ }
+ Err(error::Unspecified)
+ }
+
+ pub fn fill(dest: &mut [u8]) -> Result<(), error::Unspecified> {
+ for dst in dest.chunks_mut(8) {
+ let src = rdrand_loop()?;
+ let dst_len = dst.len();
+ dst.copy_from_slice(&src[..dst_len])
+ }
+
+ Ok(())
+ }
+}
+
#[cfg(test)]
mod tests {
use crate::rand::{self, SecureRandom};
|