Update the OPTEE shim to use CrngProvider (#504)

The OPTEE shim should use the new provider to generate random bytes--I
missed this in my previous PR. As part of this, fix the shim's handling
of large RNG requests to match OPTEE OS (failing above 4096 bytes).

Also, add the fake RNG implementation to the LVBS kernel, to be replaced
later.

Author: jstarks

dev_tests/src/ratchet.rs

@@ -29,7 +29,7 @@ fn ratchet_globals() -> Result<()> {
             ("litebox/", 7),
             ("litebox_platform_linux_kernel/", 5),
             ("litebox_platform_linux_userland/", 6),
-            ("litebox_platform_lvbs/", 18),
+            ("litebox_platform_lvbs/", 19),
             ("litebox_platform_multiplex/", 1),
             ("litebox_platform_windows_userland/", 8),
             ("litebox_runner_linux_userland/", 1),

litebox_platform_lvbs/src/host/lvbs_impl.rs

@@ -80,6 +80,20 @@ unsafe impl litebox::platform::ThreadLocalStorageProvider for LvbsLinuxKernel {
     }
 }
 
+impl litebox::platform::CrngProvider for LvbsLinuxKernel {
+    fn fill_bytes_crng(&self, buf: &mut [u8]) {
+        // FIXME: generate real random data.
+        static RANDOM: spin::mutex::SpinMutex<litebox::utils::rng::FastRng> =
+            spin::mutex::SpinMutex::new(litebox::utils::rng::FastRng::new_from_seed(
+                core::num::NonZeroU64::new(0x4d595df4d0f33173).unwrap(),
+            ));
+        let mut random = RANDOM.lock();
+        for b in buf.chunks_mut(8) {
+            b.copy_from_slice(&random.next_u64().to_ne_bytes()[..b.len()]);
+        }
+    }
+}
+
 pub struct HostLvbsInterface;
 
 impl HostLvbsInterface {}

litebox_shim_optee/src/lib.rs

@@ -287,11 +287,18 @@ fn handle_syscall_request(ctx: &mut litebox_common_linux::PtRegs) -> ContinueOpe
             syscalls::cryp::sys_cryp_obj_copy(dst_obj, src_obj)
         }
         SyscallRequest::CrypRandomNumberGenerate { buf, blen } => {
-            let mut kernel_buf = vec![0u8; blen.min(MAX_KERNEL_BUF_SIZE)];
-            syscalls::cryp::sys_cryp_random_number_generate(&mut kernel_buf).and_then(|()| {
-                buf.copy_from_slice(0, &kernel_buf)
-                    .ok_or(TeeResult::ShortBuffer)
-            })
+            // This could take a long time for large sizes. But OP-TEE OS limits
+            // the maximum size of random data generation to 4096 bytes, so
+            // let's do the same rather than something more complicated.
+            if blen > 4096 {
+                Err(TeeResult::OutOfMemory)
+            } else {
+                let mut kernel_buf = vec![0u8; blen];
+                syscalls::cryp::sys_cryp_random_number_generate(&mut kernel_buf).and_then(|()| {
+                    buf.copy_from_slice(0, &kernel_buf)
+                        .ok_or(TeeResult::AccessDenied)
+                })
+            }
         }
         _ => todo!(),
     };

litebox_shim_optee/src/syscalls/cryp.rs

@@ -6,7 +6,7 @@ use aes::{
     cipher::{NewCipher, StreamCipher, generic_array::GenericArray},
 };
 use ctr::Ctr128BE;
-use litebox::{platform::RawMutPointer, utils::rng::FastRng};
+use litebox::platform::RawMutPointer;
 use litebox_common_optee::{
     TeeAlgorithm, TeeAlgorithmClass, TeeCrypStateHandle, TeeObjHandle, TeeObjectInfo,
     TeeObjectType, TeeOperationMode, TeeResult, UteeAttribute,
@@ -312,24 +312,12 @@ pub(crate) fn sys_cryp_obj_copy(dst: TeeObjHandle, src: TeeObjHandle) -> Result<
 }
 
 pub(crate) fn sys_cryp_random_number_generate(buf: &mut [u8]) -> Result<(), TeeResult> {
-    // FIXME: before we have secure randomness source (see #41), use a fast and insecure one.
-    let mut rng = FastRng::new_from_seed(core::num::NonZeroU64::new(0x4d595df4d0f33173).unwrap());
     if buf.is_empty() {
         return Err(TeeResult::BadParameters);
     }
-
-    let blen8 = buf.len() >> 3;
-
-    for i in 0..blen8 {
-        let val = rng.next_u64();
-        buf[i * 8..(i + 1) * 8].copy_from_slice(&val.to_be_bytes());
-    }
-
-    let remainder = buf.len() % 8;
-    if remainder != 0 {
-        let val = rng.next_u64();
-        buf[blen8 * 8..blen8 * 8 + remainder].copy_from_slice(&val.to_be_bytes()[..remainder]);
-    }
-
+    <crate::Platform as litebox::platform::CrngProvider>::fill_bytes_crng(
+        litebox_platform_multiplex::platform(),
+        buf,
+    );
     Ok(())
 }