|
| 1 | +//! Implementation for UEFI using EFI_RNG_PROTOCOL |
| 2 | +use crate::Error; |
| 3 | +use core::{ |
| 4 | + mem::MaybeUninit, |
| 5 | + ptr::{self, null_mut, NonNull}, |
| 6 | + sync::atomic::{AtomicPtr, Ordering::Relaxed}, |
| 7 | +}; |
| 8 | +use r_efi::{ |
| 9 | + efi::{BootServices, Handle}, |
| 10 | + protocols::rng, |
| 11 | +}; |
| 12 | + |
| 13 | +extern crate std; |
| 14 | + |
| 15 | +pub use crate::util::{inner_u32, inner_u64}; |
| 16 | + |
| 17 | +#[cfg(not(target_os = "uefi"))] |
| 18 | +compile_error!("`efi_rng` backend can be enabled only for UEFI targets!"); |
| 19 | + |
| 20 | +static RNG_PROTOCOL: AtomicPtr<rng::Protocol> = AtomicPtr::new(null_mut()); |
| 21 | + |
| 22 | +fn init() -> Result<NonNull<rng::Protocol>, Error> { |
| 23 | + const HANDLE_SIZE: usize = size_of::<Handle>(); |
| 24 | + |
| 25 | + let boot_services = std::os::uefi::env::boot_services() |
| 26 | + .ok_or(Error::BOOT_SERVICES_UNAVAILABLE)? |
| 27 | + .cast::<BootServices>(); |
| 28 | + |
| 29 | + let mut handles = [ptr::null_mut(); 16]; |
| 30 | + // `locate_handle` operates with length in bytes |
| 31 | + let mut buf_size = handles.len() * HANDLE_SIZE; |
| 32 | + let mut guid = rng::PROTOCOL_GUID; |
| 33 | + let ret = unsafe { |
| 34 | + ((*boot_services.as_ptr()).locate_handle)( |
| 35 | + r_efi::efi::BY_PROTOCOL, |
| 36 | + &mut guid, |
| 37 | + null_mut(), |
| 38 | + &mut buf_size, |
| 39 | + handles.as_mut_ptr(), |
| 40 | + ) |
| 41 | + }; |
| 42 | + |
| 43 | + if ret.is_error() { |
| 44 | + return Err(Error::TEMP_EFI_ERROR); |
| 45 | + } |
| 46 | + |
| 47 | + let handles_len = buf_size / HANDLE_SIZE; |
| 48 | + let handles = handles.get(..handles_len).ok_or(Error::UNEXPECTED)?; |
| 49 | + |
| 50 | + let system_handle = std::os::uefi::env::image_handle(); |
| 51 | + for &handle in handles { |
| 52 | + let mut protocol: MaybeUninit<*mut rng::Protocol> = MaybeUninit::uninit(); |
| 53 | + |
| 54 | + let mut protocol_guid = rng::PROTOCOL_GUID; |
| 55 | + let ret = unsafe { |
| 56 | + ((*boot_services.as_ptr()).open_protocol)( |
| 57 | + handle, |
| 58 | + &mut protocol_guid, |
| 59 | + protocol.as_mut_ptr().cast(), |
| 60 | + system_handle.as_ptr(), |
| 61 | + ptr::null_mut(), |
| 62 | + r_efi::system::OPEN_PROTOCOL_GET_PROTOCOL, |
| 63 | + ) |
| 64 | + }; |
| 65 | + |
| 66 | + let protocol = if ret.is_error() { |
| 67 | + continue; |
| 68 | + } else { |
| 69 | + let protocol = unsafe { protocol.assume_init() }; |
| 70 | + NonNull::new(protocol).ok_or(Error::UNEXPECTED)? |
| 71 | + }; |
| 72 | + |
| 73 | + // Try to use the acquired protocol handle |
| 74 | + let mut buf = [0u8; 8]; |
| 75 | + let mut alg_guid = rng::ALGORITHM_RAW; |
| 76 | + let ret = unsafe { |
| 77 | + ((*protocol.as_ptr()).get_rng)( |
| 78 | + protocol.as_ptr(), |
| 79 | + &mut alg_guid, |
| 80 | + buf.len(), |
| 81 | + buf.as_mut_ptr(), |
| 82 | + ) |
| 83 | + }; |
| 84 | + |
| 85 | + if ret.is_error() { |
| 86 | + continue; |
| 87 | + } |
| 88 | + |
| 89 | + RNG_PROTOCOL.store(protocol.as_ptr(), Relaxed); |
| 90 | + return Ok(protocol); |
| 91 | + } |
| 92 | + Err(Error::NO_RNG_HANDLE) |
| 93 | +} |
| 94 | + |
| 95 | +pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { |
| 96 | + let protocol = match NonNull::new(RNG_PROTOCOL.load(Relaxed)) { |
| 97 | + Some(p) => p, |
| 98 | + None => init()?, |
| 99 | + }; |
| 100 | + |
| 101 | + let mut alg_guid = rng::ALGORITHM_RAW; |
| 102 | + let ret = unsafe { |
| 103 | + ((*protocol.as_ptr()).get_rng)( |
| 104 | + protocol.as_ptr(), |
| 105 | + &mut alg_guid, |
| 106 | + dest.len(), |
| 107 | + dest.as_mut_ptr().cast::<u8>(), |
| 108 | + ) |
| 109 | + }; |
| 110 | + |
| 111 | + if ret.is_error() { |
| 112 | + Err(Error::TEMP_EFI_ERROR) |
| 113 | + } else { |
| 114 | + Ok(()) |
| 115 | + } |
| 116 | +} |
| 117 | + |
| 118 | +impl Error { |
| 119 | + pub(crate) const BOOT_SERVICES_UNAVAILABLE: Error = Self::new_internal(10); |
| 120 | + pub(crate) const NO_RNG_HANDLE: Error = Self::new_internal(11); |
| 121 | + pub(crate) const TEMP_EFI_ERROR: Error = Self::new_internal(12); |
| 122 | +} |
0 commit comments