rust T^#rustc 1.98.1 (48a229cea 2026-09-01)RL.SAwjL-df1bddb45adbe94bcfg_ifr9GA-d05893e10c9c8e83<%Z>64V`-2d2ab9fb0fe1def5m6GÂn62-64f5f36fb09276941 Xr*-1ad4f876c768bda9G g{(3iF-06449a08aaab5e30rustc_std_workspace_core{`"Ei%G-cb0d4d77988d81b5")pE͗E-3ec41d3a5a80a4a4 miniz_oxide8bž LƨJ-e44eaef1807e5fc0adler29lyA6P/D$UB-dca52f01a59c33e7 hashbrownX {e-143c77bb957d9940rustc_std_workspace_alloc _z%-145a318e0772276c std_detectK(0*8D?-f99feda5ce9e492arustc_demangle%jerV-cfd0ab54bb33760e_}λ՞Co-360da4ba13154744 addr2linecY\G--09755979c57b7e64gimliQ`Dy-9a1fede77fbbf2f0objectF λv.z-7ff85ea729a864ffmemchr]1<=UO-0e3477fb2664a277 jlToKG-549498e8b2e4d924 rand_core5%#8W-fdf6ee58f4954f56&Ӭi\v2-9cd8a66bfd45f04eimplementationt getrandom_backend extern_impl !D inner_u32Landroidlinux,1D inner_u64L = 6413D$  ,1_backendserror  UNSUPPORTED ERRNO_NOT_POSITIVE  UNEXPECTED INTERNAL_START  CUSTOM_START  from_errno from_neg_error_code  raw_os_error  new_custom  new_internal  internal_descutilslice_assume_init_mut uninit_slice_fill_zeroslice_as_uninit#slice_as_uninit_mut%  truncateerror_std_impls****.sys_rng000005Error5 try_next_u325 try_next_u645try_fill_bytes0fill fill_uninituse_fileDDDDDDDDDDutilsNNN get_errnoQN sanitizerSSunpoisonNNsys_fill_exactW0impl Fn(&mut [MaybeUninit]) -> libc::ssize_tW D FILE_PATHD FD_UNINITDFD_ONGOING_INITDFDD fill_inner^ D open_readonlyD open_or_waitDopen_fdDcccccccwaitcwakecwait_until_rng_readylinux_android_with_fallbackmmmmmmmmmm m m m m m GetRandomFnm NOT_AVAILABLEminitmuse_file_fallbackmlazyLazyPtr   cold_init&impl FnOnce() -> Result, E>try_unsync_init unsync_initimpl FnOnce() -> NonNull  GETRANDOM_FN Q RawOsErrorNonZeroRawOsError  0SysRng 00000>U8W8W8^8`88888888888888888 8"8#8%8888878889898@8A8  hՙgg777 6wQ?m!؆ n@2 g.75: qgg tD w MaybeUninituninitW췜zT{4    Dl 2 #  O8A  <   $        \L R| ! )L3< _"TryFromIntError q:{ aY!#U #  j4  %ÜĜŜƜǜȜ_w"   v{  4 m" x*̷k [ÜĜŜƜǜȜ_w^f{ %ÜĜŜƜǜȜ_w &6, X!!P  l7  %ÜĜŜƜǜȜ_w(uz 7m( ! ! U !m[&  '+/<  \4$ Đ  ,!   #C W(pw ~ '!<!D !! !!! !!m[}OD^&"$1ÜĜŜƜǜȜ_w"#!&"f!%!m[}OD^&(4)řǙșəʙ˙G*R{9 (!!&( $,rK buf7sys_fillDres:11  p d  errno  74$  ! ! " "#$&L'(*)*',!> !D   Y## S  ΆΆ]φinner4+]1Rc"/dev/urandom"$-1$-2̧Tħ" 555 __variant155 __variant2>X'1   7+ d} 3f*ہ7|7Zħ"_d   !7\ 7 ~o$9 $l  8 88G>)0 $ l4 7$D4 7"!X   !!U ; u W<<<$ o5 '!$8$91::;d7<<<destXfptr` getrandom_fnO}89k: ;;<-GP}8]l:8}8| l -; Bt a?Rc % ? P !?$``Va`68Rt ?A 4$ #  +38v %ÜĜŜƜǜȜ_w 3f*ہ?<mC4 Ad 4  ?  D w[ÜĜŜƜǜȜ_w'Cr %BE<  #,  a?   < <  CC  U-4; B A,B$m[}OD^ECB%!EC4 ; A0A#GFݱ}L  BBDEF,     4 A<   $  a?C5 l | d  ?  &+ L$     L  ?CB$  J  |  C<  CC      +:J  M   B G, B$ AHHřǙșəʙ˙G*R{9 C!L CTB ;KKYLBuB{l ?$ ÜĜŜƜǜȜ_wC'UP#| ?'?P$PQ$, CWCTG,P$PQV!*.mQ$P4 #P / &.T C'PQ*CPPOTd<T wd$ 7J4L3Y# ;- ! < !;7 ".< 1:= <U=V w;_ref__getrandom_fn(F F $)5 ?HRG G  X$.H       >WTpY$FZY^ ZZsxH HH  XX Z[5 BLZ     05 ,%_  \ \ .< ,%_  \ \ .4 ,%_<$;) ;9  $I$f+$r$+ $T;2_<$;) ;9  $I$f+$r$)$T;2_4$Zd$$  $.,$L- -$ $. ř$-.\. $.l./# $ řǙșəʙ˙G*R{9 $#$#$$$ZG#code+bfc$11 1$ 11'1$  $>$V11$21&  1   $8, 218  2 2201z,0\ 0$G$G\G$(Z$=ctO$Z$$44 4$ 44)4 $   $>$V41$44&  4 f2& 448  4 5524|,3\ 3$A$A\AgZ$:cqF $Q $l  W췜?,c  ?L  lD k,lg k [k l  l, $ -mL  % m m, m^l  Sm    ;  T  ;+d  $  ;H4    ; 9̵  v H,   A z  %ÜĜŜƜǜȜ_w  w|     mr \ ; *  l{ [&   %ÜĜŜƜǜȜ_w;&    ;   '    ~Ws W췜;< !W  ;@ u\"m[}OD^&rq!&rR;uL1dst  D   o`o2p ppqqyss ԩ T x+d$ xH4 x9p @$q|q8  ,  ?Ħ mr \ x *  l} [& %ÜĜŜƜǜȜ_wx&  #  x   (~U|W췜x<!HW  x }"v&qS!&rx}1svz  K 7 xywyRy*p qq{a{O(O !+(Q   g05=QVÜĜŜƜǜȜ_w ĤĤŤ :Mǀ ggg cg1cثq1ȡ$-7EP[R8RdT B7Ms L /id T  C 8 M| ԄL  -g \  @$   9 d' ԄL r$ <C̗ %$$7\q* ~8 q;!-@8mr4   [&'*C@PV\'r$vq=!p!&r<9 qqu'{ $|D%T%Բ $!؀  %'B"'3F[&h  %q&4  !  $ $ 0 r  Aܲ q!$.m[}OD^& '!P&Xr< x FŌt"" '#B"@s"Q%% (%C$@|%ѐQ ?*A5A<C  '2Z9@*0@ABC_4\L;4<<,>T?9$9,) [`Error::UNEXPECTED`]: Error::UNEXPECTEDf  [`fill_uninit`]: fill_uninit&# getrandom: system's random number generator [![Build Status]][GitHub Actions] [![Crate]][crates.io] [![Documentation]][docs.rs] [![Dependency Status]][deps.rs] [![Downloads]][crates.io] [![License]][LICENSE-MIT] `getrandom` is a Rust library for retrieving random data from (operating) system sources. It is assumed that the system always provides high-quality, cryptographically secure random data, ideally backed by hardware entropy sources. This crate derives its name from the Linux `getrandom` syscall but is cross-platform, roughly supporting the same set of platforms as Rust's `std` library. This is a low-level API. Most users should prefer using a higher-level random-number library like [`rand`]. [`rand`]: https://crates.io/crates/rand ## Examples ```rust fn get_random_u128() -> Result { let mut buf = [0u8; 16]; getrandom::fill(&mut buf)?; Ok(u128::from_ne_bytes(buf)) } ``` ## Supported targets | Target | Target Triple | Implementation | ------------------ | ------------------ | -------------- | Linux, Android | `*‑linux‑*` | [`getrandom`][1] system call if available, otherwise [`/dev/urandom`][2] after successfully polling `/dev/random` | Windows 10+ | `*‑windows‑*` | [`ProcessPrng`] | Windows 7, 8 | `*-win7‑windows‑*` | [`RtlGenRandom`] | macOS | `*‑apple‑darwin` | [`getentropy`][3] | iOS, tvOS, watchOS | `*‑apple‑{ios,tvos,watchos}` | [`CCRandomGenerateBytes`] | FreeBSD | `*‑freebsd` | [`getrandom`][5] | OpenBSD | `*‑openbsd` | [`getentropy`][7] | NetBSD | `*‑netbsd` | [`getrandom`][16] if available, otherwise [`kern.arandom`][8] | Dragonfly BSD | `*‑dragonfly` | [`getrandom`][9] | Solaris | `*‑solaris` | [`getrandom`][11] with `GRND_RANDOM` | illumos | `*‑illumos` | [`getrandom`][12] | Fuchsia OS | `*‑fuchsia` | [`cprng_draw`] | Redox | `*‑redox` | `/dev/urandom` | Haiku | `*‑haiku` | `/dev/urandom` (identical to `/dev/random`) | Hermit | `*-hermit` | [`sys_read_entropy`] | Hurd | `*-hurd-*` | [`getrandom`][17] | SGX | `x86_64‑*‑sgx` | [`RDRAND`] | VxWorks | `*‑wrs‑vxworks‑*` | `randABytes` after checking entropy pool initialization with `randSecure` | Emscripten | `*‑emscripten` | [`getentropy`][13] | WASI 0.1 | `wasm32‑wasip1` | [`random_get`] | WASI 0.2 | `wasm32‑wasip2` | [`get-random-u64`] | SOLID | `*-kmc-solid_*` | `SOLID_RNG_SampleRandomBytes` | Nintendo 3DS | `*-nintendo-3ds` | [`getrandom`][18] | ESP-IDF | `*‑espidf` | [`esp_fill_random`] WARNING: see "Early Boot" section below | PS Vita | `*-vita-*` | [`getentropy`][19] | QNX Neutrino | `*‑nto-qnx*` | [`/dev/urandom`][14] (identical to `/dev/random`) | AIX | `*-ibm-aix` | [`/dev/urandom`][15] | Cygwin | `*-cygwin` | [`getrandom`][20] (based on [`RtlGenRandom`]) | Motor OS | `x86_64-unknown-motor` | [`RDRAND`] Pull Requests that add support for new targets to `getrandom` are always welcome. ### WebAssembly support This crate fully supports the [WASI] and [Emscripten] targets. However, the `wasm32-unknown-unknown` and `wasm64-unknown-unknown` targets (i.e. the target used by `wasm-pack`) are not automatically supported since, from the target name alone, we cannot deduce which JavaScript interface should be used (or if JavaScript is available at all). We do not include support for these targets in the default configuration because our JS backend (supporting web browsers, web workers and Node.js v19 or later) requires [`wasm-bindgen`], **bloating `Cargo.lock`** and **potentially breaking builds** on non-web WASM platforms. To enable `getrandom`'s functionality on `wasm32/64-unknown-unknown` using [`Crypto.getRandomValues`] via [`wasm-bindgen`], enable the `wasm_js` crate feature. WARNING: We strongly recommend against enabling this feature in libraries (except for tests) since it is known to break non-Web WASM builds and further since the usage of `wasm-bindgen` causes significant bloat to `Cargo.lock` (on all targets). The only exception to this rule: if your crate already unconditionally depends on `wasm-bindgen` or `js-sys` on "unknown" WASM targets then it's acceptable to enable this feature unconditionally. ### Opt-in backends `getrandom` also provides optional (opt-in) backends, which allow users to customize the source of randomness based on their specific needs: | Backend name | Target | Target Triple | Implementation | ------------------- | -------------------- | ------------------------ | -------------- | `linux_getrandom` | Linux, Android | `*‑linux‑*` | [`getrandom`][1] system call (without `/dev/urandom` fallback). Bumps minimum supported Linux kernel version to 3.17 and Android API level to 23 (Marshmallow). | `linux_raw` | Linux, Android | `*‑linux‑*` | Same as `linux_getrandom`, but uses raw `asm!`-based syscalls instead of `libc`. | `rdrand` | x86, x86-64 | `x86_64-*`, `i686-*` | [`RDRAND`] instruction | `rndr` | AArch64 | `aarch64-*` | [`RNDR`] register | `efi_rng` | UEFI | `*-unknown‑uefi` | [`EFI_RNG_PROTOCOL`] with `EFI_RNG_ALGORITHM_RAW` (requires `std` and Nightly compiler) | `windows_legacy` | Windows | `*-windows-*` | [`RtlGenRandom`] | `custom` | All targets | `*` | User-provided custom implementation (see [custom backend]) | `unsupported` | All targets | `*` | Always returns `Err(Error::UNSUPPORTED)` (see [unsupported backend]) | `extern_impl` | All targets | `*` | Externally-provided custom implementation (see [externally implemented interface]) Opt-in backends can be enabled using the `getrandom_backend` configuration flag. The flag can be set either by specifying the `rustflags` field in [`.cargo/config.toml`]: ```toml # It's recommended to set the flag on a per-target basis: [target.'cfg(target_os = "linux")'] rustflags = ['--cfg', 'getrandom_backend="linux_getrandom"'] ``` Or by using the `RUSTFLAGS` environment variable: ```sh RUSTFLAGS='--cfg getrandom_backend="linux_getrandom"' cargo build ``` Enabling an opt-in backend will replace the backend used by default. Doing this for an incorrect target (e.g. using `linux_getrandom` while compiling for a Windows target) will result in a compilation error. Be extremely careful while using opt-in backends, as incorrect configuration may result in vulnerable applications or applications that always panic. Note that using an opt-in backend in a library (e.g. for tests or benchmarks) WILL NOT have any effect on its downstream users. [`.cargo/config.toml`]: https://doc.rust-lang.org/cargo/reference/config.html ### Raw Linux syscall support Currently the `linux_raw` backend supports only targets with stabilized `asm!` macro, i.e. `arm`, `aarch64`, `loongarch64`, `riscv32`, `riscv64`, `s390x`, `x86`, and `x86_64`. Note that the raw syscall backend may be slower than backends based on `libc::getrandom`, e.g. it does not implement vDSO optimizations and on `x86` it uses the infamously slow `int 0x80` instruction to perform syscall. ### Custom backend If this crate does not support your target out of the box or you have to use a non-default entropy source, then you can provide a custom implementation. You need to enable the custom backend as described in the [opt-in backends][opt-in] section. Next, you need to define an `extern` function with the following signature: ```rust use getrandom::Error; #[unsafe(no_mangle)] unsafe extern "Rust" fn __getrandom_v03_custom( dest: *mut u8, len: usize, ) -> Result<(), Error> { todo!() } ``` This function should, ideally, be defined in the root crate of your project, e.g. in your `main.rs`. This function MUST be defined only once for your project, i.e. upstream library crates SHOULD NOT define it outside of tests and benchmarks. Improper configuration of this backend may result in linking errors. The function accepts a pointer to a buffer that should be filled with random data and its length in bytes. Note that the buffer MAY be uninitialized. On success, the function should return `Ok(())` and fully fill the input buffer; otherwise, it should return an error value. While wrapping functions which work with byte slices you should fully initialize the buffer before passing it to the function: ```rust use getrandom::Error; fn my_entropy_source(buf: &mut [u8]) -> Result<(), getrandom::Error> { // ... Ok(()) } #[unsafe(no_mangle)] unsafe extern "Rust" fn __getrandom_v03_custom( dest: *mut u8, len: usize, ) -> Result<(), Error> { let buf = unsafe { // fill the buffer with zeros core::ptr::write_bytes(dest, 0, len); // create mutable byte slice core::slice::from_raw_parts_mut(dest, len) }; my_entropy_source(buf) } ``` ### Externally Implemented Interface Using the nightly-only feature [`extern_item_impls`] it is possible to provide a custom backend for `getrandom`, even to override an existing first-party implementation. First, enable the `extern_impl` opt-in backend to allow usage of this nightly feature. Then, you may provide implementations for `fill_uninit`, `u32`, and/or `u64` with an attribute macro from the `implementation` module. [`extern_item_impls`]: https://github.com/rust-lang/rust/issues/125418 ```rust use core::mem::MaybeUninit; #[cfg(getrandom_backend = "extern_impl")] #[getrandom::implementation::fill_uninit] fn my_fill_uninit_implementation( dest: &mut [MaybeUninit] ) -> Result<(), getrandom::Error> { // ... Ok(()) } ``` For further details on what a suitable implementation for `fill_uninit` may look like, see [custom backend]. `getrandom` will provide a default implementation for `u32` and `u64`, but does not currently provide a default for `fill_uninit`, even if one is normally available for the current target. If no implementation is available, a compilation error will be raised with instructions for how to provide an implementation. ### Unsupported backend In some rare scenarios, you might be compiling this crate for an unsupported target (e.g. `wasm32-unknown-unknown`), but this crate's functionality is not actually used by your code. If you are confident that `getrandom` is not used in your project, but it gets pulled nevertheless by one of your dependencies, then you can enable the `unsupported` backend, which always returns `Err(Error::UNSUPPORTED)`. ### Platform Support This crate generally supports the same operating system and platform versions that the Rust standard library does. Additional targets may be supported using the opt-in custom backend. This means that as Rust drops support for old versions of operating systems (such as old Linux kernel versions, Android API levels, etc.) in stable releases, `getrandom` may create new patch releases that remove support for outdated platform versions. ### `/dev/urandom` fallback on Linux and Android On Linux targets, the `/dev/urandom` fallback is present only if either `target_env` is `musl`, or `target_arch` is one of the following: `aarch64`, `arm`, `powerpc`, `powerpc64`, `s390x`, `x86`, `x86_64`. Other supported targets [require][platform-support] kernel versions that support the `getrandom` system call, so the fallback is not needed. On Android targets the fallback is present only for the following `target_arch`es: `aarch64`, `arm`, `x86`, `x86_64`. Other `target_arch`es (e.g. RISC-V) require sufficiently high API levels. The fallback can be disabled by enabling the `linux_getrandom` opt-in backend. Note that doing so will bump minimum supported Linux kernel version to 3.17 and Android API level to 23 (Marshmallow). ### Early boot Sometimes, early in the boot process, the OS has not collected enough entropy to securely seed its RNG. This is especially common on virtual machines, where standard "random" events are hard to come by. Some operating system interfaces always block until the RNG is securely seeded. This can take anywhere from a few seconds to more than a minute. A few (Linux, NetBSD and Solaris) offer a choice between blocking and getting an error; in these cases, we always choose to block. On Linux (when the `getrandom` system call is not available), reading from `/dev/urandom` never blocks, even when the OS hasn't collected enough entropy yet. To avoid returning low-entropy bytes, we first poll `/dev/random` and only switch to `/dev/urandom` once this has succeeded. On OpenBSD, this kind of entropy accounting isn't available, and on NetBSD, blocking on it is discouraged. On these platforms, nonblocking interfaces are used, even when reliable entropy may not be available. On the platforms where it is used, the reliability of entropy accounting itself isn't free from controversy. This library provides randomness sourced according to the platform's best practices, but each platform has its own limits on the grade of randomness it can promise in environments with few sources of entropy. On ESP-IDF, if `esp_fill_random` is used before enabling WiFi, BT, or the voltage noise entropy source (SAR ADC), the Hardware RNG will only be seeded via RC_FAST_CLK. This can occur during early boot unless `bootloader_random_enable()` is called. For more information see the [ESP-IDF RNG Docs][esp-idf-rng] or the [RNG section of the ESP32 Technical Reference Manual][esp-trng-docs]. ## Error handling We always prioritize failure over returning known insecure "random" bytes. Generally, on supported platforms, failure is highly unlikely, though not impossible. If an error does occur, it is likely that it will occur on every call to `getrandom`. Therefore, after the first successful call, one can be reasonably confident that no errors will occur. ## Panic handling We strive to eliminate all potential panics from our backend implementations. In other words, when compiled with optimizations enabled, the generated binary code for `getrandom` functions should not contain any panic branches. Even if the platform misbehaves and returns an unexpected result, our code should correctly handle it and return an error, e.g. [`Error::UNEXPECTED`]. ## Sanitizer support If your code uses [`fill_uninit`] and you enable [MemorySanitizer](https://doc.rust-lang.org/beta/unstable-book/compiler-flags/sanitizer.html#memorysanitizer) (i.e. `-Zsanitizer=memory`), we will automatically handle unpoisoning of the destination buffer filled by `fill_uninit`. You can run sanitizer tests for your crate dependent on `getrandom` like this: ```sh RUSTFLAGS="-Zsanitizer=memory" cargo test -Zbuild-std --target=x86_64-unknown-linux-gnu ``` ## Minimum Supported Rust Version This crate requires Rust 1.85 or later. The most reliable way to get an MSRV-respecting behavior is to set `CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS=fallback` when doing `cargo update -p getrandom`, like so: ```sh CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS=fallback cargo update -p getrandom ``` ## License The `getrandom` library is distributed under either of * [Apache License, Version 2.0][LICENSE-APACHE] * [MIT license][LICENSE-MIT] at your option. ### Contribution Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions. [//]: # (badges) [GitHub Actions]: https://github.com/rust-random/getrandom/actions?query=branch:master [Build Status]: https://github.com/rust-random/getrandom/actions/workflows/tests.yml/badge.svg?branch=master [crates.io]: https://crates.io/crates/getrandom [Crate]: https://img.shields.io/crates/v/getrandom [docs.rs]: https://docs.rs/getrandom [Documentation]: https://docs.rs/getrandom/badge.svg [deps.rs]: https://deps.rs/repo/github/rust-random/getrandom [Dependency Status]: https://deps.rs/repo/github/rust-random/getrandom/status.svg [Downloads]: https://img.shields.io/crates/d/getrandom [License]: https://img.shields.io/crates/l/getrandom [//]: # (supported targets) [1]: https://manned.org/getrandom.2 [2]: https://manned.org/urandom.4 [3]: https://www.unix.com/man-page/mojave/2/getentropy/ [4]: https://www.unix.com/man-page/mojave/4/urandom/ [5]: https://www.freebsd.org/cgi/man.cgi?query=getrandom&manpath=FreeBSD+12.0-stable [7]: https://man.openbsd.org/getentropy.2 [8]: https://man.netbsd.org/sysctl.7 [9]: https://leaf.dragonflybsd.org/cgi/web-man?command=getrandom [11]: https://docs.oracle.com/cd/E88353_01/html/E37841/getrandom-2.html [12]: https://illumos.org/man/2/getrandom [13]: https://github.com/emscripten-core/emscripten/pull/12240 [14]: https://www.qnx.com/developers/docs/7.1/index.html#com.qnx.doc.neutrino.utilities/topic/r/random.html [15]: https://www.ibm.com/docs/en/aix/7.3?topic=files-random-urandom-devices [16]: https://man.netbsd.org/getrandom.2 [17]: https://www.gnu.org/software/libc/manual/html_mono/libc.html#index-getrandom [18]: https://github.com/rust3ds/shim-3ds/commit/b01d2568836dea2a65d05d662f8e5f805c64389d [19]: https://github.com/vitasdk/newlib/blob/2d869fe47aaf02b8e52d04e9a2b79d5b210fd016/newlib/libc/sys/vita/getentropy.c [20]: https://github.com/cygwin/cygwin/blob/main/winsup/cygwin/libc/getentropy.cc [`ProcessPrng`]: https://learn.microsoft.com/en-us/windows/win32/seccng/processprng [`RtlGenRandom`]: https://learn.microsoft.com/en-us/windows/win32/api/ntsecapi/nf-ntsecapi-rtlgenrandom [`Crypto.getRandomValues`]: https://www.w3.org/TR/WebCryptoAPI/#Crypto-method-getRandomValues [`RDRAND`]: https://software.intel.com/en-us/articles/intel-digital-random-number-generator-drng-software-implementation-guide [`RNDR`]: https://developer.arm.com/documentation/ddi0601/2024-06/AArch64-Registers/RNDR--Random-Number [`CCRandomGenerateBytes`]: https://opensource.apple.com/source/CommonCrypto/CommonCrypto-60074/include/CommonRandom.h.auto.html [`cprng_draw`]: https://fuchsia.dev/fuchsia-src/zircon/syscalls/cprng_draw [`esp_fill_random`]: https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/random.html#functions [esp-idf-rng]: https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/random.html [esp-trng-docs]: https://www.espressif.com/sites/default/files/documentation/esp32_technical_reference_manual_en.pdf#rng [`EFI_RNG_PROTOCOL`]: https://uefi.org/specs/UEFI/2.10/37_Secure_Technologies.html#efi-rng-protocol [`random_get`]: https://github.com/WebAssembly/WASI/blob/snapshot-01/phases/snapshot/docs.md#-random_getbuf-pointeru8-buf_len-size---errno [`get-random-u64`]: https://github.com/WebAssembly/WASI/blob/v0.2.1/wasip2/random/random.wit#L23-L28 [configuration flags]: #configuration-flags [custom backend]: #custom-backend [unsupported backend]: #unsupported-backend [`wasm-bindgen`]: https://github.com/rustwasm/wasm-bindgen [`module`]: https://rustwasm.github.io/wasm-bindgen/reference/attributes/on-js-imports/module.html [`sys_read_entropy`]: https://github.com/hermit-os/kernel/blob/315f58ff5efc81d9bf0618af85a59963ff55f8b1/src/syscalls/entropy.rs#L47-L55 [platform-support]: https://doc.rust-lang.org/stable/rustc/platform-support.html [WASI]: https://github.com/WebAssembly/WASI [Emscripten]: https://emscripten.org [opt-in]: #opt-in-backends [externally implemented interface]: #externally-implemented-interface [//]: # (licenses) [LICENSE-APACHE]: https://github.com/rust-random/getrandom/blob/master/LICENSE-APACHE [LICENSE-MIT]: https://github.com/rust-random/getrandom/blob/master/LICENSE-MIT [`Error::UNEXPECTED`]: https://docs.rs/getrandom/latest/getrandom/struct.Error.html#associatedconstant.UNEXPECTED [`fill_uninit`]: https://docs.rs/getrandom/latest/getrandom/fn.fill_uninit.html %https://www.rust-lang.org/favicon.ico9https://www.rust-lang.org/logos/rust-logo-128x128-blk.pngl*0@ABCH_HHH; I< I</I>@I?HHHHHdDDm L 'z L ({T L,%5c#L/T 96 This target/platform is not supported by `getrandom`.\  #@= The platform-specific `errno` returned a non-positive value.  LI Encountered an unexpected situation which should not happen in practice.T   t  $d  $,uefiT$B  ,2,;$B  c$#/B? Extract the raw OS error code (if this error came from the OS)MJ This method is identical to [`std::io::Error::raw_os_error()`][1], exceptKH that it works in `no_std` contexts. On most targets this method returnsOL `Option`, but some platforms (e.g. UEFI) may use a different primitive QN type like `usize`. Consult with the [`RawOsError`] docs for more information.!!MJ If this method returns `None`, the error value can still be formatted via!! the `Display` implementation.""OL [1]: https://doc.rust-lang.org/std/io/struct.Error.html#method.raw_os_error"IF [`RawOsError`]: https://doc.rust-lang.org/std/io/type.RawOsError.htmld#cB  10(/MJ Creates a new instance of an `Error` from a particular custom error code.T0\B  *321d3\B  \45/l5 řǙșəʙ˙G*R{9  B  5 $5C!̋DgD8D  ggg cg1cثq1ȡ́B D $D DHgI8I  ggg cg1cثq1ȡ́B I $I ID$ "#%'(), >\7 D,IidL$+2?.0 "P k l!! ?  ?6I ! rB  ",;| l kB$$   #?,N  l k&&   %?6 (L sB(L|Bѐ'Dx;B )|| *+, *,>io. *- :d .<) 3 //X $[ B.. /err` \ܲ<, 01> TryCryptoRngd"03TryRng4004dKL/16789879T,550d sB5 5 7$ 0d  |B5 5 8$  Bt   r'B5 5 9$ <B HH|܋ Id/I/I@I@I1 SP Fill `dest` with random bytes from the system's preferred random number source.NK This function returns an error on any failure, including partial reads. WeNK make no guarantees regarding the contents of `dest` on error. If `dest` isJG empty, `getrandom` immediately returns success, making no calls to the  underlying operating system.OL Blocking is possible, at least during early boot; see module documentation.MJ In general, `getrandom` will be fast enough for interactive usage, thoughJG significantly slower than a user-space CSPRNG; for the latter considerIF [`rand::thread_rng`](https://docs.rs/rand/*/rand/fn.thread_rng.html).t # Examples< ```1. # fn main() -> Result<(), getrandom::Error> { let mut buf = [0u8; 32]; getrandom::fill(&mut buf)?;t # Ok(()) }<$ r'B <bDLGD Fill potentially uninitialized buffer `dest` with random bytes fromDA the system's preferred random number source and return a mutable reference to those bytes.JG On successful completion this function is guaranteed to return a sliceFC which points to the same memory as `dest` and has the same length.HE In other words, it's safe to assume that `dest` is initialized after$! this function has returned `Ok`.JG No part of `dest` will ever be de-initialized at any point, regardless of what is returned.tl ```ignore>; # // We ignore this test since `uninit_array` is unstable.*' #![feature(maybe_uninit_uninit_array)]1A> let mut buf = core::mem::MaybeUninit::uninit_array::<1024>();;8 let buf: &mut [u8] = getrandom::fill_uninit(&mut buf)?;t<\ !ÜĜŜƜǜȜ_w rB q<xF"" FC Get random `u32` from the system's preferred random number source.!t!!]$_ΆDH4e5DI\wDJ AtomicI32LȞDLDDMd;}$M|MqsbdrWMGAC13,QSW, NO>\!NPLh RVd9)l/L3NRerrno_locationt 5Q ( L $B"l>LBNU\ ST 3 D  !   *1 ]t !!'BXX !0#! !+#!!l W!11Z\WYYYYW#LD 5LD$"|D$D``Va`68Rt$BDT !'B  ^<$,^____^_<< $;lD 5ÜĜŜƜǜȜ_w$B  ` $/dDB a*<DB bD$ # ##,#7$$Djkl,$ceE>$]cf|$ \cgl$ `ch,$Nci,$fhQS@B13#%'$'D B j+$,D B k999D'B l ܖ |}~DODmn,dmo>45mq\msL mt $mv<mw,Nmx  'z  ({|Hd]$o\{o oCuhj|]\ !  \m;$lm8$m8B9Gm !'B ;<$D! !'B <%D$m InfallibleT $/<5 AtomicPtrLRa`](https://doc.rust-lang.org/std/convert/trait.From.html).,  hՙZBpH3ZB  Z E K+++L+L++ BF  +9,M9,9,9,9,  BG  9,-N-N--  BH  - -:KH A [`TryRng`] interface over the system's preferred random number sourceQN This is a zero-sized struct. It can be freely constructed with just `SysRng`.NK This struct is also available as [`rand::rngs::SysRng`] when using [rand]. # Usage example# `SysRng` implements [`TryRng`]:</, use getrandom::{rand_core::TryRng, SysRng}; let mut key = [0u8; 32];-* SysRng.try_fill_bytes(&mut key).unwrap();<;8 Using it as an [`Rng`] is possible using [`UnwrapErr`]:</, use getrandom::rand_core::{Rng, UnwrapErr}; use getrandom::SysRng;$! let mut rng = UnwrapErr(SysRng);$! let random_u64 = rng.next_u64();<)& [rand]: https://crates.io/crates/randTQ [`rand::rngs::SysRng`]: https://docs.rs/rand/latest/rand/rngs/struct.SysRng.html [`Rng`]: rand_core::Rng'$ [`UnwrapErr`]: rand_core::UnwrapErr 4n@2)???T?T?? BO ? PU?Vg??  ggg cg1cثq1ȡ́BQ ??jAWjAjAB w K'm,, DD^+ II* *)J)?&&?& !+ 1https://deps.rs/repo/github/rust-random/getrandomunsupported backenddhttps://opensource.apple.com/source/CommonCrypto/CommonCrypto-60074/include/CommonRandom.h.auto.htmlMemorySanitizerApache License, Version 2.0Froml[z<*ؠ<3 gjq_hSPF#^adsdم3Seu>vM6|g9K+nq*!ۻ8(mL1??dysӑGHR5Q5I7`K1 U.n< 1Rpg\7EeN2+GPhA=999oIgN"G~@;h .$0=Ӈ746٘+- S - w_፛@zGOhl``ѓUs䅅JW^݃qY֫ԋ)#w@Ib&?f{27jr9D+f/piEWԂ_\S~visXX͢jҧs Cuӧk_dw>|%0Lh2 Ç, _ȼM6"nrǮC<o˦3,ߙΠJ@U ߹+CO 3Pеz p|6גo ~ΛB'Avs0o}X HYxtw-|Lq20\",ZC_JD@c?K15 x6G@ ].!3/u h .CX䬷oY(Gl5+P^۷>x93#~hsψ~iKnӃjb.;3ckxμn{#d˥&l.A({q5p\BȈ9Ae-Ǧų`N_x|oc\=HUG{ ;g*͈,HoAw0qǿXuB O$VzI1jӜޡ1B"eRBJ% =<6Np4F0%\yaDbwx;=r7U@oJBNWjM1},| `N!iw#睍$XԺPS%yɿ;\y+>+(Qgr*7DbD&_$ ^)q,/RR/aS1bkδT: I}@ea9Hhl*TϦU*5JD~kfeO}Ş 6]*sql^].g`VB ^ bJF#Vc6t֪ncU0 1_8쐣²7~{nܲ\{>fu?Q?Nco:!?/q´JZ=[xdptL g>œ' [J'TDc5\x9MQb;Є.U\~ƥ>葑reZak5vX>h ]|)cᩬ)9}t B穐fw*E@:T 8w3HJp{fۍEۺh>Xh5=K_ulxe'oa wSIP[bm<Tm Z.ib6Juz| p$,i  :g(,/Ct;@EHNPTZ\bhnqw~"k !&+\;/|q„ 0MƝƺ'9Wǿp̟̼ =ι jqe# n^|s m,>5GC̭.          '      '(hY(@X6ɠF ӢozѤNʥ(c!86f Rl@D\*[z9q1ǽ7tSbunųdn!\TNIGMPW^ݚhʛ7PhœU)ӡeģɣ̣ѣգ٣P]$1ܥ FǦrwz~˧kӨ!'d5dҵ׵$з'Ǹ+ƹʹιҹֹڹ޹>o8=BEJNRVZ`djntzѻg #(wڽW)6޿+x|mš-JƚƷ$6TǻCm̜̹ :9?ELRX^djpv|΂ΈΎΔΚΡΨήεμ JT[dU$,Է0иGڻ%|#`?/PZH@ z %/ C M W a l \0(5_0I5Y67;ABvBCDaGG  $'c),*+#,t,??TAm--K../13HMnHq1W67;?BtBCD_GGHo$'a)'*+!,r,k-?RAA-J../^013H5X67;?BuBCD`GGHpmH $'b)+*+H",s,l-?SAAޠM-C../W0-G../[0O"VI >d]d+>o`W9y%bơסi]ר gVtk+޽h 2);̡"b9Uy,(+26<@O[bfj| 0DHLSW^imquy} .59=AHVZ^bfjv #'37;KRbfuy   1 D R Y ] a e i m q |  " - E L X ] b g l q v {   ' : ] b v {       " & - 3 9 ? E K Q X _ f m t {  e; @I07 " ҡæ ,E5O̴5~RU/X(,,f$g""$CCC1=C=FFFGlobal ě +((RawVec+5,_markerXՔ777Os7677Simple7677 SimpleMessage7677Custom76VN7O CustomOwner6 fDIII4 K666Repr6666 Bia  OsFunctionsformat_os_errordecode_error_kindis_interrupted7U!a$a$b$66$ 77767 67 error_drop67 outer_drop6*I]@DU <$ ggg cg1cثq1ȡ́U 6$ xxwWZW$_$$ 7 $ $ $Boxljk# `(`"`$` `$` eoKjNmU[fhLkVYn\TiMWlZ~ ei_core_intrinsicsderive_eq_internals"imSɎ\ "im~\aF"im>Yע"imoU "im%ݕf&]"imPPP,? "imUdmɂo$ uderive_clone_copy_internals  "imUEǴq ,} fmt_helpers_for_derivegg"imtXXM "imLy8]L O_"im$r+} "im$|["imrPͭ "imnC"imסB&e ,}V"im;òv7 :="im$>e, h"imG$crate::cfg_if/ "imdr <l"imv!"imz12] %P"imó+%_Ŏ]"imySW "im: eu8"imQ' "im19Zbyo $  "im?2 !u"imv6cu"imT83u"im9/`uN"im[5xAu"imT @ :u"imh3_ٳu"ims[]PZ u"imZo8 uM"imE u"im6pw"w  u"imNvZU  u"im dz;  u"im)xG  M"im}KR _3 }"imXq#x1++4p4=4 433q3>3 322r2?2 21+,",+,+ ,&,,.,+,+++,+,*,+,+2,h.040i-t4A4433u3B3322v2C2210-/V,.|/1.Y0.r1-!/0;-E1-/,O/1,.F,.140-4`4-4333a3.3222b2/21I0 . 0,./1X.|0/1+-?/0Y-b1-/,l/51,.ODHT U@oJ 1 g>ǮC<=+BhS B'Avs0J!T葑rHJp{f)_ r~@U ߹A1 U.+- S - %XX͢j4œ' [oAwr ]|1)IJs:cU0ۦ5Ib&- zfeO}@.Rx^g {Go˦>_u?NcoRBJ%y)[\ 6"nr<XoXNQgr*7|g9K+nfw*b;Є.U3/UPs<?K15Q|Lq20\N< 4p|6G)9}t[ٛ%>ۍEz<*h5=KDD>l[,*>鹁y+>+(X>h`VB ^ yaDb\7EJD~kGOh'(GlZa9Hhl~iKn_vM6`N_luB OtξP}BNWjMԠR yaS1b 18TlJZ=[ܲ\{ϪŞ 6]*sPF#^a JW^*!.]=3ckxbdsdم F#Vc6>fu;g*p{27jr9/&l.fo Hp|7 Zs@}",ZCO5+P^[;\%0Lh8E@~ΛIؠ<3ΠJ@ u h .Vμc_$ ^)q,/RR/\~ƥ>)c B穐_JD@cPq_ UG{ ox|omB"ext֪nbD&29hs^ql^]:!?Pеz F @jBPhA=993)#w@,䬷oXndyɿD罐J'TDc5\x9MQmOJMYY, _ȼM;Ǧųk0qǿXsޡ1wp\Bh3Seu>3#~]h .$"{#d˥extw-M=<6N{ӑG1jӜv4F0%\qY֫ԋ+۷>x9\Ӄj`@ ].SԺPS%q*!ۻ8??dG~@;!vis3gS~2CCAe-jkδTHYL?f."imgj 3ERp3,?Ȉ9ib.;a$VzIu曆\N!iw*TϚHR5QU*(mL1n<.gݡBfUs)ӧk_6l``ѓ(bJeN2+G1_8쐣?QǬxdptLOD%d^wU~9_9B5zJ>$ m~><~SY`u9&fP,B mrMT.rk:FF \F4G]54O6PuO &<1-g9}nk]uTfQ5Z~:#pu27@,u4h]M=nO%s>-m /.z %v 8KptFz`{KWg.]g! ZD^1(&huY,xY?mA#S.E5P|J93?V *XN6cMofN?;g]A n3BMIx#Uc&L%d^wU~9_9B5zU/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/lib.rsJ/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3U/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/lib.rs g K͆7%%9-! Q?''?L   +KWbP% "0.&%( *CTOOK!PNKJ2  4C@> HEKGI%K?+2B< O%DF5G2& %G2& %Z4(!6?'"c/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/backends/use_file.rsJ/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3c/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/backends/use_file.rs ؝Bvq Y (:"2 2 +4%&'!-! &79"<-<#( = /CC?$ ( T/ 8 CWLIZ>?d=: K>U!JGONGMNPK<NPNNN N=MF6@1%" =><*,9D): $ ֙"MzSg:?Zr/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/backends/../utils/sys_fill_exact.rsJ/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3r/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/backends/../utils/sys_fill_exact.rs P$&۔TUJ )%52=%@! PV3)D*:KN=0  .54wS'v/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/backends/linux_android_with_fallback.rsJ/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3v/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/backends/linux_android_with_fallback.rs T-RXYMB&% >:EAQ9:0A.CQ$3B-& CI$BR F=)e GRPTVR&TN6!MKD# - ( b[^W=j\k<# R/\A6!MS9#('$[9^%(?B*_.@W.@E/O/I %?/3+$Q:7-6 ?3-D3:9 \+Qk]wjfaڢV/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/util.rsJ/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3V/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/util.rs \+A}}bB7Ϲ[P^H*0MS0P LE,>?PDI0Q=PB +0<?BE%B +0<?BE%;*Ui5!;k] #UAY/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/sys_rng.rsJ/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3Y/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/sys_rng.rs ',991 7'LRO$0.<0%%*U('77I#I Z `* D[/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/../README.mdJ/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3[/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/../README.md c5N - ." Z\SU&U( 9 !;;@ABT?@l@S@>=ZA>;|A=AJ>j?`AZ;ReKTR`[YKU]];ac`-YYa\[QZ:$=2BTXVQN2NVZZW+ML:#L0 MIFHMIQ,Q.G 0&.%3%O[WM:G**"!$ QPKEHMGLIJ#NOLRB1UR[YSOOL+FG>HIF=KFAIDGFIEJIJM9E'FKJDJ;NHMB>1nF3OX"(C@&M 71PQDWm03%5=R75$"85U*%AH*?lM)SZxRTh^hK|lyde,",;cQ,%FVPr$             ''))+lHnŊa/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/error_std_impls.rsJ/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3a/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/error_std_impls.rs -R> EЦ.   !"#@+ @VgY@$Z/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/backends.rsJ/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3Z/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/backends.rs V2?ܧo66%?HI@F) .>8536=#: :$ B- " XK[\(R> #)%%( TNH !)%)+'%(KJD)55 )0!KK9 .-.   H+$& -I.1=# Hd-$(SL0d UW BW`Q{fm/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/backends/../utils/get_errno.rsJ/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3m/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/backends/../utils/get_errno.rs ;,?%  o-6..H-,-*5aS. '*, I+1.uu v:m/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/backends/../utils/sanitizer.rsJ/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3m/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.3/src/backends/../utils/sanitizer.rs /ޫ.rܒ,mMTbo0KMLF,KMO>6$ L-"1 >pL,B yԫ,FH8JKMBOtQRmTWY[\x86_64-unknown-linux-gnujS=>d-400b4be9d2dc7810"im   ]~~11b -Npp J'rust-end-file