iron_learn/target/debug/deps/libgetrandom-1dc0a0d0c3ca7f7a.rmeta

📄 libgetrandom-1dc0a0d0c3ca7f7a.rmeta
/home/palash/git/iron_learn/target/debug/deps/libgetrandom-1dc0a0d0c3ca7f7a.rmeta
Language: rmeta • Lines: 1328
rust
�O#rustc 1.92.0 (ded5c06cf 2025-12-08)��١�	�T�6a��D�
-5080178c80bf7a93�cfg_if��v�
їG}�/x$YxD-e720413b8edafa0a��**�٭T��HО�9�-3e2e950d4bac10b5��	+Y�D]�O.ʼ��
$�-965a3d5e7b2182f0���%�<�,|error_std_impls�|��<��,�|�sys_rng�<��<��L���	rand_core�L��<��L���SysRng�4��<��L���implementation�t�
getrandom_backend���extern_impl�l���!0	inner_u32�L��L�android�L����L�linux�<�����,��10	inner_u64�L��T�KI�G�@><9;0�$��L��L����L��<�����,��1�_backends�error�UNSUPPORTED�ERRNO_NOT_POSITIVE�
UNEXPECTED�INTERNAL_START�CUSTOM_START�
from_errno�from_neg_error_code�raw_os_error�
new_custom�new_internal�
internal_desc���util�slice_assume_init_mut��uninit_slice_fill_zero�slice_as_uninit�"�slice_as_uninit_mut�$���truncate�fill�fill_uninit���use_file�0000000000utils�:::	get_errno�=�
:	sanitizer�??unpoison�::sys_fill_exact�C0impl Fn(&mut [MaybeUninit<u8>]) -> libc::ssize_t�C	0	FILE_PATH�0	FD_UNINIT�0FD_ONGOING_INIT�0FD�0
fill_inner�J	0
open_readonly�0open_or_wait�0open_fd�0�OOOOOOOwait�Owake�Owait_until_rng_ready�linux_android_with_fallback�YYYYYYYYYY	Y
YYY
YGetRandomFn�Y
NOT_AVAILABLE�Yinit�Yuse_file_fallback�Y�llazy�mmmmmmmmmLazyPtr�v
v�v�mz�z�
z	cold_init�}E�}&impl FnOnce() -> Result<NonNull<T>, E>�ztry_unsync_init�����zunsync_init��impl FnOnce() -> NonNull<T>��	lGETRANDOM_FN�l	=
RawOsError�NonZeroRawOsError���
��������88888888!8"8$8,8-8A8C8C8J8L8k8l8}8�8�8�8�8�8�8��������B��'P�`�������������_��_���������������5�������_�_|�

����k��inner��/�V>߿Y���)F�,�$c"/dev/urandom"��
������"G�\�$-1��
�������(H�\�$-2�̧T����0�0�0
__variant1��0�0
__variant2���,����X��1

��
���+���di�������_��M����|���X����_���|�
l�
��-:
At�
�Y�Qb���%
v���|��Pvvw�y�m	�̂��w�$��Y�Y\�Yp��X=nۼk�p�����
	��
�
0��5	�,�$_���
	�����
.��<
�,�$_���
	�����
.��4�,�$_�<���) �9	��I�e*�q���+�T����1_�<����) �9	��I�e*�q���)
�T����1_�$�1��1�1��1��1'��1
�	 
�=�T��11$�2��1&

��1 
�	�7,�2��18
��2�2�2��0���1z�,�0��0�A�A�A�#�	�	�	��	��	yk���9�
�	n�qcode����
��
�$�4��4�4��4��4)��4�	 �=�T��41$�4��4&

��4 �#1&�4��48
��4�5�5��2���4|�,�3��3�;�;�;�$�%����$:�$yqA�L���
v�w&�1�8?��

��%�0�%7>,-./�_4�MaybeUninit�\����,��*�T��+�9�$�9,) [`Error::UNEXPECTED`]: Error::UNEXPECTED��f  [`fill_uninit`]: fill_uninit�����8�l��79https://www.rust-lang.org/logos/rust-logo-128x128-blk.png���;$�8����7%https://www.rust-lang.org/favicon.ico���'�������# getrandom: system\'s random number generator\n\n[![Build Status]][GitHub Actions]\n[![Crate]][crates.io]\n[![Documentation]][docs.rs]\n[![Dependency Status]][deps.rs]\n[![Downloads]][crates.io]\n[![License]][LICENSE-MIT]\n\n`getrandom` is a Rust library for retrieving random data from (operating) system sources.\n\nIt is assumed that the system always provides high-quality, cryptographically secure random\ndata, ideally backed by hardware entropy sources. This crate derives its name from\nthe Linux `getrandom` syscall but is cross-platform, roughly supporting the same set\nof platforms as Rust\'s `std` library.\n\nThis is a low-level API. Most users should prefer using a higher-level random-number\nlibrary like [`rand`].\n\n[`rand`]: https://crates.io/crates/rand\n\n## Usage\n\nAdd the `getrandom` dependency to your `Cargo.toml` file:\n\n```toml\n[dependencies]\ngetrandom = \"0.3\"\n```\n\nThen invoke the `fill` function on a byte buffer to fill it with random data:\n\n```rust\nfn get_random_u128() -> Result<u128, getrandom::Error> {\n    let mut buf = [0u8; 16];\n    getrandom::fill(&mut buf)?;\n    Ok(u128::from_ne_bytes(buf))\n}\n```\n\n## Supported targets\n\n| Target             | Target Triple      | Implementation\n| ------------------ | ------------------ | --------------\n| Linux, Android     | `*\u{2011}linux\u{2011}*`        | [`getrandom`][1] system call if available, otherwise [`/dev/urandom`][2] after successfully polling `/dev/random`\n| Windows 10+        | `*\u{2011}windows\u{2011}*`      | [`ProcessPrng`]\n| Windows 7, 8       | `*-win7\u{2011}windows\u{2011}*` | [`RtlGenRandom`]\n| macOS              | `*\u{2011}apple\u{2011}darwin`   | [`getentropy`][3]\n| iOS, tvOS, watchOS | `*\u{2011}apple\u{2011}{ios,tvos,watchos}` | [`CCRandomGenerateBytes`]\n| FreeBSD            | `*\u{2011}freebsd`        | [`getrandom`][5]\n| OpenBSD            | `*\u{2011}openbsd`        | [`getentropy`][7]\n| NetBSD             | `*\u{2011}netbsd`         | [`getrandom`][16] if available, otherwise [`kern.arandom`][8]\n| Dragonfly\u{a0}BSD      | `*\u{2011}dragonfly`      | [`getrandom`][9]\n| Solaris            | `*\u{2011}solaris`        | [`getrandom`][11] with `GRND_RANDOM`\n| illumos            | `*\u{2011}illumos`        | [`getrandom`][12]\n| Fuchsia\u{a0}OS         | `*\u{2011}fuchsia`        | [`cprng_draw`]\n| Redox              | `*\u{2011}redox`          | `/dev/urandom`\n| Haiku              | `*\u{2011}haiku`          | `/dev/urandom` (identical to `/dev/random`)\n| Hermit             | `*-hermit`         | [`sys_read_entropy`]\n| Hurd               | `*-hurd-*`         | [`getrandom`][17]\n| SGX                | `x86_64\u{2011}*\u{2011}sgx`     | [`RDRAND`]\n| VxWorks            | `*\u{2011}wrs\u{2011}vxworks\u{2011}*`  | `randABytes` after checking entropy pool initialization with `randSecure`\n| Emscripten         | `*\u{2011}emscripten`     | [`getentropy`][13]\n| WASI 0.1           | `wasm32\u{2011}wasip1`    | [`random_get`]\n| WASI 0.2           | `wasm32\u{2011}wasip2`    | [`get-random-u64`]\n| SOLID              | `*-kmc-solid_*`    | `SOLID_RNG_SampleRandomBytes`\n| Nintendo 3DS       | `*-nintendo-3ds`   | [`getrandom`][18]\n| ESP-IDF            | `*\u{2011}espidf`         | [`esp_fill_random`] WARNING: see \"Early Boot\" section below\n| PS Vita            | `*-vita-*`         | [`getentropy`][19]\n| QNX Neutrino       | `*\u{2011}nto-qnx*`       | [`/dev/urandom`][14] (identical to `/dev/random`)\n| AIX                | `*-ibm-aix`        | [`/dev/urandom`][15]\n| Cygwin             | `*-cygwin`         | [`getrandom`][20] (based on [`RtlGenRandom`])\n| Motor OS           | `x86_64-unknown-motor` | [`RDRAND`]\n\nPull Requests that add support for new targets to `getrandom` are always welcome.\n\n### WebAssembly support\n\nThis crate fully supports the [WASI] and [Emscripten] targets. However,\nthe `wasm32-unknown-unknown` target (i.e. the target used by `wasm-pack`)\nis not automatically supported since, from the target name alone, we cannot deduce\nwhich JavaScript interface should be used (or if JavaScript is available at all).\n\nWe do not include support for this target in the default configuration because our JS backend\n(supporting web browsers, web workers and Node.js v19 or later) requires [`wasm-bindgen`],\n**bloating `Cargo.lock`** and **potentially breaking builds** on non-web WASM platforms.\n\nTo enable `getrandom`\'s functionality on `wasm32-unknown-unknown` using\n[`Crypto.getRandomValues`] via [`wasm-bindgen`], enable the `wasm_js` crate feature.\n\nWARNING: We strongly recommend against enabling this feature in libraries (except for tests)\nsince it is known to break non-Web WASM builds and further since the usage of `wasm-bindgen`\ncauses significant bloat to `Cargo.lock` (on all targets).\n\nThe only exception to this rule: if your crate already unconditionally depends on `wasm-bindgen`\nor `js-sys` on \"unknown\" WASM targets then it\'s acceptable to enable this feature unconditionally.\n\n### Opt-in backends\n\n`getrandom` also provides optional (opt-in) backends, which allow users to customize the source\nof randomness based on their specific needs:\n\n| Backend name        | Target               | Target Triple            | Implementation\n| ------------------- | -------------------- | ------------------------ | --------------\n| `linux_getrandom`   | Linux, Android       | `*\u{2011}linux\u{2011}*`              | [`getrandom`][1] system call (without `/dev/urandom` fallback). Bumps minimum supported Linux kernel version to 3.17 and Android API level to 23 (Marshmallow).\n| `linux_raw`         | Linux, Android       | `*\u{2011}linux\u{2011}*`              | Same as `linux_getrandom`, but uses raw `asm!`-based syscalls instead of `libc`.\n| `rdrand`            | x86, x86-64          | `x86_64-*`, `i686-*`     | [`RDRAND`] instruction\n| `rndr`              | AArch64              | `aarch64-*`              | [`RNDR`] register\n| `efi_rng`           | UEFI                 | `*-unknown\u{2011}uefi`         | [`EFI_RNG_PROTOCOL`] with `EFI_RNG_ALGORITHM_RAW` (requires `std` and Nightly compiler)\n| `windows_legacy`    | Windows              | `*-windows-*`            | [`RtlGenRandom`]\n| `custom`            | All targets          | `*`                      | User-provided custom implementation (see [custom backend])\n| `unsupported`       | All targets          | `*`                      | Always returns `Err(Error::UNSUPPORTED)` (see [unsupported backend])\n| `extern_impl`       | All targets          | `*`                      | Externally-provided custom implementation (see [externally implemented interface])\n\nOpt-in backends can be enabled using the `getrandom_backend` configuration flag.\nThe flag can be set either by specifying the `rustflags` field in [`.cargo/config.toml`]:\n```toml\n# It\'s recommended to set the flag on a per-target basis:\n[target.\'cfg(target_os = \"linux\")\']\nrustflags = [\'--cfg\', \'getrandom_backend=\"linux_getrandom\"\']\n```\n\nOr by using the `RUSTFLAGS` environment variable:\n\n```sh\nRUSTFLAGS=\'--cfg getrandom_backend=\"linux_getrandom\"\' cargo build\n```\n\nEnabling an opt-in backend will replace the backend used by default. Doing this for\nan incorrect target (e.g. using `linux_getrandom` while compiling for a Windows target)\nwill result in a compilation error. Be extremely careful while using opt-in backends,\nas incorrect configuration may result in vulnerable applications or applications\nthat always panic.\n\nNote that using an opt-in backend in a library (e.g. for tests or benchmarks)\nWILL NOT have any effect on its downstream users.\n\n[`.cargo/config.toml`]: https://doc.rust-lang.org/cargo/reference/config.html\n\n### Raw Linux syscall support\n\nCurrently the `linux_raw` backend supports only targets with stabilized `asm!` macro,\ni.e. `arm`, `aarch64`, `loongarch64`, `riscv32`, `riscv64`, `s390x`, `x86`, and `x86_64`.\n\nNote that the raw syscall backend may be slower than backends based on `libc::getrandom`,\ne.g. it does not implement vDSO optimizations and on `x86` it uses the infamously slow\n`int 0x80` instruction to perform syscall.\n\n### Custom backend\n\nIf this crate does not support your target out of the box or you have to use\na non-default entropy source, then you can provide a custom implementation.\nYou need to enable the custom backend as described in the\n[opt-in backends][opt-in] section.\n\nNext, you need to define an `extern` function with the following signature:\n\n```rust\nuse getrandom::Error;\n\n#[unsafe(no_mangle)]\nunsafe extern \"Rust\" fn __getrandom_v03_custom(\n    dest: *mut u8,\n    len: usize,\n) -> Result<(), Error> {\n    todo!()\n}\n```\n\nThis function should, ideally, be defined in the root crate of your project,\ne.g. in your `main.rs`. This function MUST be defined only once for your\nproject, i.e. upstream library crates SHOULD NOT define it outside of\ntests and benchmarks. Improper configuration of this backend may result\nin linking errors.\n\nThe function accepts a pointer to a buffer that should be filled with random\ndata and its length in bytes. Note that the buffer MAY be uninitialized.\nOn success, the function should return `Ok(())` and fully fill the input buffer;\notherwise, it should return an error value.\n\nWhile wrapping functions which work with byte slices you should fully initialize\nthe buffer before passing it to the function:\n```rust\nuse getrandom::Error;\n\nfn my_entropy_source(buf: &mut [u8]) -> Result<(), getrandom::Error> {\n    // ...\n    Ok(())\n}\n\n#[unsafe(no_mangle)]\nunsafe extern \"Rust\" fn __getrandom_v03_custom(\n    dest: *mut u8,\n    len: usize,\n) -> Result<(), Error> {\n    let buf = unsafe {\n        // fill the buffer with zeros\n        core::ptr::write_bytes(dest, 0, len);\n        // create mutable byte slice\n        core::slice::from_raw_parts_mut(dest, len)\n    };\n    my_entropy_source(buf)\n}\n```\n\n### Externally Implemented Interface\n\nUsing the nightly-only feature [`extern_item_impls`] it is possible to provide\na custom backend for `getrandom`, even to override an existing first-party implementation.\nFirst, enable the `extern_impl` opt-in backend to allow usage of this nightly feature.\nThen, you may provide implementations for `fill_uninit`, `u32`, and/or `u64`\nwith an attribute macro from the `implementation` module.\n\n[`extern_item_impls`]: https://github.com/rust-lang/rust/issues/125418\n\n```rust\nuse core::mem::MaybeUninit;\n\n#[cfg(getrandom_backend = \"extern_impl\")]\n#[getrandom::implementation::fill_uninit]\nfn my_fill_uninit_implementation(\n    dest: &mut [MaybeUninit<u8>]\n) -> Result<(), getrandom::Error> {\n    // ...\n    Ok(())\n}\n```\n\nFor further details on what a suitable implementation for `fill_uninit` may look\nlike, see [custom backend].\n\n`getrandom` will provide a default implementation for `u32` and `u64`, but does\nnot currently provide a default for `fill_uninit`, even if one is normally\navailable for the current target. If no implementation is available,\na compilation error will be raised with instructions for how to provide\nan implementation.\n\n### Unsupported backend\n\nIn some rare scenarios, you might be compiling this crate for an unsupported\ntarget (e.g. `wasm32-unknown-unknown`), but this crate\'s functionality\nis not actually used by your code. If you are confident that `getrandom` is\nnot used in your project, but it gets pulled nevertheless by one of your\ndependencies, then you can enable the `unsupported` backend, which always\nreturns `Err(Error::UNSUPPORTED)`.\n\n### Platform Support\n\nThis crate generally supports the same operating system and platform versions\nthat the Rust standard library does. Additional targets may be supported using\nthe opt-in custom backend.\n\nThis means that as Rust drops support for old versions of operating systems\n(such as old Linux kernel versions, Android API levels, etc.) in stable releases,\n`getrandom` may create new patch releases that remove support for\noutdated platform versions.\n\n### `/dev/urandom` fallback on Linux and Android\n\nOn Linux targets, the `/dev/urandom` fallback is present only if either `target_env`\nis `musl`, or `target_arch` is one of the following: `aarch64`, `arm`, `powerpc`,\n`powerpc64`, `s390x`, `x86`, `x86_64`. Other supported targets [require][platform-support]\nkernel versions that support the `getrandom` system call, so the fallback is not needed.\n\nOn Android targets the fallback is present only for the following `target_arch`es:\n`aarch64`, `arm`, `x86`, `x86_64`. Other `target_arch`es (e.g. RISC-V) require\nsufficiently high API levels.\n\nThe fallback can be disabled by enabling the `linux_getrandom` opt-in backend.\nNote that doing so will bump minimum supported Linux kernel version to 3.17\nand Android API level to 23 (Marshmallow).\n\n### Early boot\n\nSometimes, early in the boot process, the OS has not collected enough\nentropy to securely seed its RNG. This is especially common on virtual\nmachines, where standard \"random\" events are hard to come by.\n\nSome operating system interfaces always block until the RNG is securely\nseeded. This can take anywhere from a few seconds to more than a minute.\nA few (Linux, NetBSD and Solaris) offer a choice between blocking and\ngetting an error; in these cases, we always choose to block.\n\nOn Linux (when the `getrandom` system call is not available), reading from\n`/dev/urandom` never blocks, even when the OS hasn\'t collected enough\nentropy yet. To avoid returning low-entropy bytes, we first poll\n`/dev/random` and only switch to `/dev/urandom` once this has succeeded.\n\nOn OpenBSD, this kind of entropy accounting isn\'t available, and on\nNetBSD, blocking on it is discouraged. On these platforms, nonblocking\ninterfaces are used, even when reliable entropy may not be available.\nOn the platforms where it is used, the reliability of entropy accounting\nitself isn\'t free from controversy. This library provides randomness\nsourced according to the platform\'s best practices, but each platform has\nits own limits on the grade of randomness it can promise in environments\nwith few sources of entropy.\n\nOn ESP-IDF, if `esp_fill_random` is used before enabling WiFi, BT, or the\nvoltage noise entropy source (SAR ADC), the Hardware RNG will only be seeded\nvia RC_FAST_CLK. This can occur during early boot unless\n`bootloader_random_enable()` is called. For more information see the\n[ESP-IDF RNG Docs][esp-idf-rng] or the\n[RNG section of the ESP32 Technical Reference Manual][esp-trng-docs].\n\n## Error handling\n\nWe always prioritize failure over returning known insecure \"random\" bytes.\nGenerally, on supported platforms, failure is highly unlikely, though not\nimpossible. If an error does occur, it is likely that it will occur\non every call to `getrandom`. Therefore, after the first successful call,\none can be reasonably confident that no errors will occur.\n\n## Panic handling\n\nWe strive to eliminate all potential panics from our backend implementations.\nIn other words, when compiled with optimizations enabled, the generated\nbinary code for `getrandom` functions should not contain any panic branches.\nEven if the platform misbehaves and returns an unexpected result,\nour code should correctly handle it and return an error, e.g.\n[`Error::UNEXPECTED`].\n\n## Sanitizer support\n\nIf your code uses [`fill_uninit`] and you enable\n[MemorySanitizer](https://doc.rust-lang.org/beta/unstable-book/compiler-flags/sanitizer.html#memorysanitizer)\n(i.e. `-Zsanitizer=memory`), we will automatically handle unpoisoning\nof the destination buffer filled by `fill_uninit`.\n\nYou can run sanitizer tests for your crate dependent on `getrandom` like this:\n```sh\nRUSTFLAGS=\"-Zsanitizer=memory\" cargo test -Zbuild-std --target=x86_64-unknown-linux-gnu\n```\n\n## Minimum Supported Rust Version\n\nThis crate requires Rust 1.85 or later.\n\n## License\n\nThe `getrandom` library is distributed under either of\n\n * [Apache License, Version 2.0][LICENSE-APACHE]\n * [MIT license][LICENSE-MIT]\n\nat your option.\n\n### Contribution\n\nUnless you explicitly state otherwise, any contribution intentionally submitted\nfor inclusion in the work by you, as defined in the Apache-2.0 license, shall be\ndual licensed as above, without any additional terms or conditions.\n\n[//]: # (badges)\n\n[GitHub Actions]: https://github.com/rust-random/getrandom/actions?query=branch:master\n[Build Status]: https://github.com/rust-random/getrandom/actions/workflows/tests.yml/badge.svg?branch=master\n[crates.io]: https://crates.io/crates/getrandom\n[Crate]: https://img.shields.io/crates/v/getrandom\n[docs.rs]: https://docs.rs/getrandom\n[Documentation]: https://docs.rs/getrandom/badge.svg\n[deps.rs]: https://deps.rs/repo/github/rust-random/getrandom\n[Dependency Status]: https://deps.rs/repo/github/rust-random/getrandom/status.svg\n[Downloads]: https://img.shields.io/crates/d/getrandom\n[License]: https://img.shields.io/crates/l/getrandom\n\n[//]: # (supported targets)\n\n[1]: https://manned.org/getrandom.2\n[2]: https://manned.org/urandom.4\n[3]: https://www.unix.com/man-page/mojave/2/getentropy/\n[4]: https://www.unix.com/man-page/mojave/4/urandom/\n[5]: https://www.freebsd.org/cgi/man.cgi?query=getrandom&manpath=FreeBSD+12.0-stable\n[7]: https://man.openbsd.org/getentropy.2\n[8]: https://man.netbsd.org/sysctl.7\n[9]: https://leaf.dragonflybsd.org/cgi/web-man?command=getrandom\n[11]: https://docs.oracle.com/cd/E88353_01/html/E37841/getrandom-2.html\n[12]: https://illumos.org/man/2/getrandom\n[13]: https://github.com/emscripten-core/emscripten/pull/12240\n[14]: https://www.qnx.com/developers/docs/7.1/index.html#com.qnx.doc.neutrino.utilities/topic/r/random.html\n[15]: https://www.ibm.com/docs/en/aix/7.3?topic=files-random-urandom-devices\n[16]: https://man.netbsd.org/getrandom.2\n[17]: https://www.gnu.org/software/libc/manual/html_mono/libc.html#index-getrandom\n[18]: https://github.com/rust3ds/shim-3ds/commit/b01d2568836dea2a65d05d662f8e5f805c64389d\n[19]: https://github.com/vitasdk/newlib/blob/2d869fe47aaf02b8e52d04e9a2b79d5b210fd016/newlib/libc/sys/vita/getentropy.c\n[20]: https://github.com/cygwin/cygwin/blob/main/winsup/cygwin/libc/getentropy.cc\n\n[`ProcessPrng`]: https://learn.microsoft.com/en-us/windows/win32/seccng/processprng\n[`RtlGenRandom`]: https://learn.microsoft.com/en-us/windows/win32/api/ntsecapi/nf-ntsecapi-rtlgenrandom\n[`Crypto.getRandomValues`]: https://www.w3.org/TR/WebCryptoAPI/#Crypto-method-getRandomValues\n[`RDRAND`]: https://software.intel.com/en-us/articles/intel-digital-random-number-generator-drng-software-implementation-guide\n[`RNDR`]: https://developer.arm.com/documentation/ddi0601/2024-06/AArch64-Registers/RNDR--Random-Number\n[`CCRandomGenerateBytes`]: https://opensource.apple.com/source/CommonCrypto/CommonCrypto-60074/include/CommonRandom.h.auto.html\n[`cprng_draw`]: https://fuchsia.dev/fuchsia-src/zircon/syscalls/cprng_draw\n[`esp_fill_random`]: https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/random.html#functions\n[esp-idf-rng]: https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/random.html\n[esp-trng-docs]: https://www.espressif.com/sites/default/files/documentation/esp32_technical_reference_manual_en.pdf#rng\n[`EFI_RNG_PROTOCOL`]: https://uefi.org/specs/UEFI/2.10/37_Secure_Technologies.html#efi-rng-protocol\n[`random_get`]: https://github.com/WebAssembly/WASI/blob/snapshot-01/phases/snapshot/docs.md#-random_getbuf-pointeru8-buf_len-size---errno\n[`get-random-u64`]: https://github.com/WebAssembly/WASI/blob/v0.2.1/wasip2/random/random.wit#L23-L28\n[configuration flags]: #configuration-flags\n[custom backend]: #custom-backend\n[unsupported backend]: #unsupported-backend\n[`wasm-bindgen`]: https://github.com/rustwasm/wasm-bindgen\n[`module`]: https://rustwasm.github.io/wasm-bindgen/reference/attributes/on-js-imports/module.html\n[`sys_read_entropy`]: https://github.com/hermit-os/kernel/blob/315f58ff5efc81d9bf0618af85a59963ff55f8b1/src/syscalls/entropy.rs#L47-L55\n[platform-support]: https://doc.rust-lang.org/stable/rustc/platform-support.html\n[WASI]: https://github.com/WebAssembly/WASI\n[Emscripten]: https://emscripten.org\n[opt-in]: #opt-in-backends\n[externally implemented interface]: #externally-implemented-interface\n\n[//]: # (licenses)\n\n[LICENSE-APACHE]: https://github.com/rust-random/getrandom/blob/master/LICENSE-APACHE\n[LICENSE-MIT]: https://github.com/rust-random/getrandom/blob/master/LICENSE-MIT\n\n[`Error::UNEXPECTED`]: https://docs.rs/getrandom/latest/getrandom/struct.Error.html#associatedconstant.UNEXPECTED\n[`fill_uninit`]: https://docs.rs/getrandom/latest/getrandom/fn.fill_uninit.html\n���# 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

## Usage

Add the `getrandom` dependency to your `Cargo.toml` file:

```toml
[dependencies]
getrandom = "0.3"
```

Then invoke the `fill` function on a byte buffer to fill it with random data:

```rust
fn get_random_u128() -> Result<u128, getrandom::Error> {
    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` target (i.e. the target used by `wasm-pack`)
is 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 this target 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-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<u8>]
) -> 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.

## 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
������&,-./��_��)�����*��+���������d�D�0Y�L�&�f�L�'�g�T�l�L�,������5�[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����,T���
errno�,���;����
�$$���#/��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], except���KH that it works in `no_std` contexts. On most targets this method returns���OL `Option<i32>`, 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.html�d�#�����������������;t����
$�#��0(��/MJ Creates a new instance of an `Error` from a particular custom error code.�T�0��
�$���21d�3����$���5/l�5�������������������;t����5
$�5��C!�̋D��_��D8�D�������^�^��^��[�^buf��[����e�S����������������������q�aXÅÅą��:�����D
$�D��D��H��_��I8�I�������^�^��^��[�^���[����e�S�����I
$�I��ID�$�!"$&'(�, �*�)\7���D��,I�adL�+$�2@/1!#��P����
�����)��uninit�������B1}-�hn��
��  �����
��,���I����
�����)���������B1}-�hn�
�
!�,���;|������σ�##����
"��,���N��	�����σ�%%�	���	
$��,�	��(L���������������������q�aX��
&��(L���������������������q�aX�
'��'D��
(����!��1��
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. We���NK make no guarantees regarding the contents of `dest` on error. If `dest` is���JG 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, though���JG significantly slower than a user-space CSPRNG; for the latter consider���IF [`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(()) }�<���$������������������������q�aX��
,dest�$���L��GD Fill potentially uninitialized buffer `dest` with random bytes from���DA 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 slice���FC 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.���t�Տ��l�
 ```ignore���>; # // We ignore this test since `uninit_array` is unstable.���*' #![feature(maybe_uninit_uninit_array)]���1����A> let mut buf = core::mem::MaybeUninit::uninit_array::<1024>();���;8 let buf: &mut [u8] = getrandom::fill_uninit(&mut buf)?;�t���<���\�������������������������q�aX����
-��$���""�� FC Get random `u32` from the system's preferred random number source.��!�t�!Տ�!�<�!����!1����"%" let rng_seed = getrandom::u32()?;�t�"��<�"���"��
.��$"��#FC Get random `u64` from the system's preferred random number source.��#�t�#Տ�#�<�#����#1����$%" let rng_seed = getrandom::u64()?;�t�$��<�$���$��
/d�D�:FGHIJLMNO�,B�01*k$_��04�4e�005�)\w��06XL���08�D���09d;s�MagiXZ�rM?A/1��,�=?C�,�:;*�)\!��:<�
Lh>Bd9�)l/L3:>errno_location�t�	�/=���	(	L�		�
>l>LB:A�)\
��?@�
��3
D�
�����

A���
�]����t������
Β�
DD�������0���������+������l�
C�����sys_fill�D�gi�C<closure_kind>�E<closure_signature>�E<upvars>�EECE���������TryFromIntError����9�{�.���L�0���L�0���"|�0����0����X��v��X���|&k��B������DT�����Β�
J��$�,�J��K��K��KKJK�����;l�0�����������������������q�aX���
L�$���/d�0��
M��*<�0��
ND�$$�$0VWX�,�$�OQ1*��$IOR�|�$HOS�l�$LOT�
,�$:OU��$9fhQS@B24$&��'$�'0
V��+$�,0
W��99��90Β
X��ܖhijkl�	DO0YZ�,d�Y[*�4��0Y]�)\���Y_�L��Y`�$��Yb�<��Yc�
,�:Yd��&f��'g|H�d]��oW\{�	���r�eg|�Z��#$ '   ��\�Y�����$l�Y���$�Y�
j��G��Y����Β�
k��$���D� ����Β�
l��$�D�$�Yvw
Infallible�Tȩmo�$/�mq�<5�mr\LR�Ymt�<g��mu���mu�n�s	d)WYLN�]A+<��xx����	�̂��wwy��+Im��vv
w�]_d�mvv����{{����|}��Թ��zz
|���]L�m������������������������q�aX�������_��M�����z�~�~�z�����������&�����!�������
}�����$��
$�^`Z\��~|��������z�������z���̷��&޷��!���
������$��
$�=?BD��J\�����ضz����z����ܯ��������ضT�
����$��
$�HJ��������������������������������������q�aXضȩ1�FĿ�Xx����*d�Yvvw�y�m	�̂��w��,�l����������l�٩������	�
����� Raw error code.��$'�������85 This alias mirrors unstable [`std::io::RawOsError`].���JM�������RO [`std::io::RawOsError`]: https://doc.rust-lang.org/std/io/type.RawOsError.html���dgT�������%x��.+ A small and `no_std` compatible error type�����PM The [`Error::raw_os_error()`] will indicate if the error is from the OS, and���LI if so, which error code the OS gave the application. If such an error is���?< encountered, please consult with your system documentation.��	���	=: *If this crate's `"std"` Cargo feature is enabled*, then:���	,) - [`getrandom::Error`][Error] implements���
QN   [`std::error::Error`](https://doc.rust-lang.org/std/error/trait.Error.html)���
WT - [`std::io::Error`](https://doc.rust-lang.org/std/io/struct.Error.html) implements���XU   [`From<getrandom::Error>`](https://doc.rust-lang.org/std/convert/trait.From.html).�,�
��B��'P�`���%�x3�%���
���
���% C�
J�(D�
K����!#�����D�
�
�,�
E�
L����!�(*-/8�9=?����E�
�
��
HF�
M�M����46�������F�
�
�L�
���&Y%�D
�D�$�I�I!�#&�"+~"0"51:�?�D�I�O|TxYK
^
cW
ho	m�r�w)|����z�ProcessPrng�/https://github.com/rust-lang/rust/issues/125418�https://man.netbsd.org/sysctl.7�Ahttps://docs.oracle.com/cd/E88353_01/html/E37841/getrandom-2.html�)https://img.shields.io/crates/v/getrandom�rand::thread_rng�	getrandom�Lhttps://github.com/WebAssembly/WASI/blob/snapshot-01/phases/snapshot/docs.md�Hhttps://github.com/WebAssembly/WASI/blob/v0.2.1/wasip2/random/random.wit��	https://emscripten.org�(https://github.com/rustwasm/wasm-bindgen�https://manned.org/getrandom.2�
getentropy�5https://doc.rust-lang.org/cargo/reference/config.html�����/https://www.unix.com/man-page/mojave/4/urandom/����������	-��@https://github.com/rust-random/getrandom/blob/master/LICENSE-MIT�������"https://man.netbsd.org/getrandom.2�����8https://github.com/emscripten-core/emscripten/pull/12240����	#https://github.com/WebAssembly/WASI����� externally implemented interface�����Chttps://github.com/rust-random/getrandom/blob/master/LICENSE-APACHE�������	Downloads�����Ohttps://www.freebsd.org/cgi/man.cgi?query=getrandom&manpath=FreeBSD+12.0-stable�����RDRAND���Khttps://github.com/cygwin/cygwin/blob/main/winsup/cygwin/libc/getentropy.cc�����custom backend�����Jhttps://doc.rust-lang.org/beta/unstable-book/compiler-flags/sanitizer.html�������Dependency Status�����CCRandomGenerateBytes�����ihttps://github.com/hermit-os/kernel/blob/315f58ff5efc81d9bf0618af85a59963ff55f8b1/src/syscalls/entropy.rs���2https://www.qnx.com/developers/docs/7.1/index.html�����EFI_RNG_PROTOCOL�����Error::UNEXPECTED�����Vhttps://rustwasm.github.io/wasm-bindgen/reference/attributes/on-js-imports/module.html���
Documentation�����Uhttps://learn.microsoft.com/en-us/windows/win32/api/ntsecapi/nf-ntsecapi-rtlgenrandom�����:https://fuchsia.dev/fuchsia-src/zircon/syscalls/cprng_draw�����\https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/random.html�����RNDR�����3RNG section of the ESP32 Technical Reference Manual�����)https://img.shields.io/crates/d/getrandom�����Crate�����Bhttps://learn.microsoft.com/en-us/windows/win32/seccng/processprng�����#https://illumos.org/man/2/getrandom�����Shttps://github.com/rust3ds/shim-3ds/commit/b01d2568836dea2a65d05d662f8e5f805c64389d�����Crypto.getRandomValues�����<https://doc.rust-lang.org/stable/rustc/platform-support.html�����<https://deps.rs/repo/github/rust-random/getrandom/status.svg�����Build Status�����https://manned.org/urandom.4�����;https://leaf.dragonflybsd.org/cgi/web-man?command=getrandom�����get-random-u64�����wasm-bindgen�����opt-in backends�����\https://github.com/rust-random/getrandom/actions/workflows/tests.yml/badge.svg?branch=master���������https://crates.io/crates/rand�����kern.arandom�����
random_get���
Emscripten�����.cargo/config.toml�����MIT license�������License�����$https://man.openbsd.org/getentropy.2�����rhttps://software.intel.com/en-us/articles/intel-digital-random-number-generator-drng-software-implementation-guide���WASI�����
��unsupported backend���rand���Apache License, Version 2.0��������1https://deps.rs/repo/github/rust-random/getrandom��
����extern_item_impls�dhttps://opensource.apple.com/source/CommonCrypto/CommonCrypto-60074/include/CommonRandom.h.auto.html�������<https://www.gnu.org/software/libc/manual/html_mono/libc.html���Fhttps://www.ibm.com/docs/en/aix/7.3?topic=files-random-urandom-devices������<https://uefi.org/specs/UEFI/2.10/37_Secure_Technologies.html��
������MemorySanitizer���������https://docs.rs/getrandom�������2https://www.unix.com/man-page/mojave/2/getentropy/�����sys_read_entropy���qhttps://github.com/vitasdk/newlib/blob/2d869fe47aaf02b8e52d04e9a2b79d5b210fd016/newlib/libc/sys/vita/getentropy.c�����]https://developer.arm.com/documentation/ddi0601/2024-06/AArch64-Registers/RNDR--Random-Number�����chttps://www.espressif.com/sites/default/files/documentation/esp32_technical_reference_manual_en.pdf�����)https://img.shields.io/crates/l/getrandom���"https://crates.io/crates/getrandom�����RtlGenRandom�����
cprng_draw�����esp_fill_random�����#https://www.w3.org/TR/WebCryptoAPI/������/dev/urandom�ESP-IDF RNG Docs�����#https://docs.rs/getrandom/badge.svg���.https://docs.rs/rand/*/rand/fn.thread_rng.html���Dhttps://github.com/rust-random/getrandom/actions?query=branch:master����������������������������������������������������������������9Error::raw_os_error�getrandom::Error�std::error::Error�std::io::RawOsError�std::io�����2https://doc.rust-lang.org/std/io/struct.Error.html�From<getrandom::Error>�From<getrandom�����std::io::Error::raw_os_error()������std::io::Error�����Error::raw_os_error()�������4https://doc.rust-lang.org/std/error/trait.Error.html��������5https://doc.rust-lang.org/std/convert/trait.From.html���
std::error�����5https://doc.rust-lang.org/std/io/type.RawOsError.html�������������������������������������������H��������������������������I�I�I�H�J�������H��������������������������I�I�I�H�J������
/dev/urandom
���U�"�/
tλ�����a�3���!q%�OV"LF���ԃ@��
�nE|�S���8�� ��(��XH����O1T���A�̄��#�f��g�����)��
�퍳&)�B�1�U�h�g؍�{+�Fia�霟#oi�,���1��bG�����g��5Tf�ujf�<�{��D�t�q����L�{�c�C"�|��Y�:2�-ϻ��f����r�.���uL��h��b7��r\&f䉼�&��:���a@�d�a�f/&$s�>;�^8M��'����ꨅx5��P�J
EO��~�
 �J�[8^�خ�����@���|��<����\e����Y��@6�j���\���1`��'U��;�Ƥ���;��x�i�;��R����6_/�ݦ���őt4�N�|����G "�����k�܀�~�3��z�3�b�g��9�a�L�%�a�Mn��P�������~�x�)
X�P�PO�,����s��k��d�d�6	>i�jA�E=l�:c����׉/��3&�.�qho-�q�c�wj�����)��>(Ǩ�*Dg�0̣q>��鯱��
'\;y0>Bo�I��u������
�-G�D����\ױhrU�H�K�6uAT�H�#X��'��g��})|��=���t�2�dmvĲjT�ڌ~�{o�1CM��σf�Ww6�~����%��È<svl�Qt���F���G�� �E��"�ip�!J!��>p�+��[��׵�}gL���g��h��H.|1�P�}\�\M�=L���Mp�܋_�	�R*�����p��mA���t�Y��o��k8̒���^H�:o���{��z$�o������N\՚��tcM�,)��X�5$���>�FT9�	�mR��EQ6���~����;�V��eţ�~��-��� L���6Y�7�k�:G�]���᳼D���<�/p%��5����R�L�R.����L�׭�Ì��+|�P>b)�W��J��5}�~4�I�'͉l}^х���x����(n���Ch����H[ s�Z�4}��4.������|����q�3X�0���8����6D������k�2B���~B�+jNa���`�ϕd�6����,�ꔁ� ���E�f$_���:d�M ���${b(+t��sH�+�TT�ߧ}��C�9I'��4�p��|��3����"_�(jYA�[d��ы����uNHzk�x.���FT�V��N�q2�S�NSh�9�s���~�\�l�"�n�U���=ժ����E-�� �lI(��8j9u�c���b��W���ks���'��6�#�@'	J=��\���u��O�<z
!�����K��ϲ/�Pu������r�ے��m��PR�z�t?9�g�=������a�������p�������
���0W�������J����/�H�����8���������������(���������}���Eɽ	ͼ	κ�e������7���_�%�<�Q�e����|��I�x��2�a֑��׺�����Lؘ�=����� �X�����B��j����#�h�����#�������_������
�m������������������{��#��������



%%�]���6�����3�]���μ����ݾ���=�����Ē���)͢Ρ���k������L���)�@�U�z�����.�^�~��G�v֗��׾����`؞�Cٛ���5�m�����(����D�j���R���+<�B�E�L�S�����ŷ�E����+�C���¹3�ƽ�����þ����
�����#�����������m�z���xıĶļ���@ɸͷζ�?�D�H�J�N�R�W�Y�]�aЩЮг����-�2�ф�N�[�!�8�L�aӾ��w��D�t��������������.�\֌�T�Y�^�b�g�i�m�q�s�y�}׃׈׎ה׵�����Gؔ���$�&�+�/�1�5�:مټ�������Sڥ۲ۿ�h�u܂�1�>��f�������� �.�d�|����!����!�%�*�0�6�;�A�G�L�Q�V�[�`�e�j�o�u�z����������?�I�P�Y���÷2������/�H�������˽�Ⱦ������!�(����������o����}��ĿĤ�͍Όϼ�B�L�P�U�[�_�gЬби����0�7тъ�P�%�<�Q�e���|��I�z������������2�a֓�W�\�e�k�o�u�{ׁ��בט׺�����Lؚ�"�(�-�3�8�?وپ���� �Xڧ۴���j�w܇�3���������1�h���?���$�(�.�4�9�?�E�J�O�T�Y�^�c�h�m�s�x�}����������ѷ?����%�=�p���$���󽈾����п������r�����T�w���rģ�.ɩͱΰ�	�p���X���1�H�]ӂ���M��>�n�(�Vֆ�������8؅�Yٯ��������F�6ۯۼ�#�r����;݄�0ޫ���	�X�u������y���
�˷7�����5�h�������|�����Ŀ��������h�����=�q���lĝ�$ɟͫΪ��f���R�p�+�B�W�|���!���8�h�"�Pր�������.�{�F٧��������>�۩۶���l�yܽ�5�S�*�{����O�l������k�����ӷC����)�A�t���(�����������Կ������t���^���tĥ�0ɫͳβ��r�-���3�J�_ӄ���Q��@�p�*�Xֈ�������:؇�cٵ����Lڇ�I����2ޯ�
���_�z������~����_�������������>�����Ĕ���*ͣ΢���M�������0�`��I�x����a�Eٝ�6�o������F���S���_���ϼ����޾�?�����Ĕ���*ͣ΢���M�������0�`��I�x����a�|ٞ�7�r�����%�F���S���L�������Ͻ�̾
�,��������ā���͑ΐ���;���_�i���Ԁ��M��6�e����O���$�\�����B��j�3���A����	�	�	S	�	�	�	�	����y�Z�����۾�t܁�=��
$�����2
�
h)�v#�����(�
g�u�
�������J�]������
_~ �����
c�x���,�������������x���e���xĩ�4ɯͷζ��v�5���D�t�.�\֌���>؋�Sږ�Y�"��������`�޶W���ɷ���������e����x�����=��������	����q��e�
����������� 5HYs���������������7MTnu|������������������� '7;JNc��������'.26:>BFQ\w�����������������!,048<@DHLZ^elpw~�������#6:>BSkrw����������������������					#	)	0	7	>	E	L	t�����������������
���
���������s �� ����������������KMLJ8H<H�mH��O\core_intrinsics�����U�"�/
f���,)h�BIe�f\��	derive_eq������U�"�/
bQ�
gb������Z���U�"�/
N5Ѱ�l�9���
%���Z���U�"�/
9Bψ��tqJ}�J���derive_clone_copy����U�"�/
/M>𗢌�$crate::cfg_if���/���U�"�/
)��!�8�I�I��U�"�/
���Ly8]�~$�
u����������U�"�/
PUw�F�����u��U�"�/
���]����u��U�"�/
OO4�A �����u��U�"�/
�+x|�����u/�U�"�/
�����������ub�U�"�/
Ύ�I�;�����
�u��U�"�/
��z��+����u��U�"�/
�͔*�m������u��U�"�/
�Ş��Bog��
�
�u.�U�"�/
��X��
���	�ua�U�"�/
�'�*P������u��U�"�/
`Z�9�����
��u��U�"�/
t�ޝ0�?*
��	��u��U�"�/
f�D|��J�	����
�.�U�"�/
�S��с�_���3^�U�"�/
���3���RL/I-U-2�1�1~1K11�0�00L00�/�/�/P/Q-A-M-E-Y-�..26.�1�1�1O11�0�0�0P00�/�/�/T/�./g.�-}-m-/&.82W.2�1�1n1;11�0�0o0<0	0�/�/r/�.</�.�-�-�ODHT ����)��>F���\��,��+|�P>~�[��׵�_܋_�	�e�x�)
X�P<ϻ��f�����uN����
�-GL%�OV"LF�H�#XPg������'����#}gL���`�őt4�3Q6���~r�uL��h�o-�q�cD�E��"�i\�c�C�]����x�����Kܬ�K�6uATOL���6YvbG��������(n���1CM���V~�
 �J�&p�!J!]�U�"�/
霟#oif/&$s�!��Ch�����H[ s�Z���'��gQ�E�f$_�${b(+tΔ(Ǩ�*Dg�G�sH�+�T��PO�,���=����,��3&�.�qhCT�ߧ}�ޖ;y0>BoJC�9I'����Y�:2�-�N�q2�S���ϲ/�P�g��5Tfꨅx5��P$NSh�9�s��=l�:c��A^H�:o��j��O�<z
!�0̣q>���HY��@6�j+6�#�@'	J�&)�B�1�
�J
EO��%�{+�Fia���>�FT9�p\�\M�=c����O1T�Mn��P��:�	�mR��Eq���R�L�{�FT�Vޞ_�(jYA�[���~�\�lѡ>;�^8M�"�+jNa�������:d���ujf�<�?9�g�=�i�jA�E@�s��k��>�7�k�:Gw��>p�+�^\ױhrU�HN�È<svl�Y�I��u���K�f�Ww6�~WHzk�x.��PR�z�t�
�nE|�S��})|��=R�k�܀�~�6���ԃ@����A�̄	R*�����pf�,���1��N�|����4G "����5��׉/��BI�'͉l}^�����6D��tλ������wj����E����
'\I���t�2�S4�p��|�ݘ�L�%�a�9�k8̒���i"�|�`�ϕd�6���� �����-��� u�Ƥ���;/�4}��4��=ժ����r�ے��m�����8�� ��\e����*U�h�g؍�E-�� �lI(��8j9���mA���gt�Y��o�hs���'�����G�� [��M ����d�d�6	>?��#�f��
u�c���b��=��\���u���X�5$�o�b7��r\����%�X3����"�[8^�خ�'&f䉼�&�2B���~B�g��h��aH.|1�P�}bdmvĲjTT��eţ�~tQt���F�Z��x�i�;0׭�Ì��}��5}�~4�����q�3�u������������k轋��|��<��)�{��z$ka�3���!qp%��5�zd��ы���g��9�a8��r�.���N\՚��m����L�{����;�Vs�W���k�_/�ݦ��2��R����613��z�3�b7�����~;tcM�,)n.������|�a@�d�a� X�0���8�L���Mp�d�ڌ~�{oU"�n�U����D���<�/y)��
�퍳{��D�t�q�:���х���x����(��XH'U��;.�o�����lb)�W��J����@�(R.����L�|�1`��-�D����M����~�o(g##,yimD?f14!Yn*,F[gH
4
K-3
gJu4o7\S((��@_V�t�5%_��tOx������c�"No����-��h�[��H��w�@��"s#���^�$e�L�?a��)��X��k	8K}[/�Dkf.IneZuOY��TFt�gm\T���a{���:����.O@h����!r>*?TxyX^a�8XX0�ku=���+5h�1?>���D����7Y8�~$�]
jW�����~�o(g##,^/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.2/src/error.rs� G
R<� ��]3��0�U�M�$3DA[%:I
A[#8/QM@>-RXYMB&%
>:EAQ9:0A.CQ$3B-&
CI$BR
F=)e
GRPTVR&TN6!MKD#
-
(
b[^W=j\k<#
R/\<AT8^>A6!MS9#('$[9^%(?B*_.@W.@E/O/I%?/3+$Q:7-6
?3-D3:9
�J"�����Z�����\/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.2/src/lib.rs� �	�gK͆7������%�9-!Q?''?L


+KWbP%"0.&%( *CTOOK!PNKJ2 
4C@>HEKGI%K?+2B<
O%DF5G2&
%G2&
%��
�?57����ݢj/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.2/src/backends/use_file.rs� ��؝�B���v��q<w��A�7)=-'H=O1M6*^#)LIIIC)GHIEIH/2
G-2/E#>Y
(:"2
2+4%&'!-!
&79"<-<#(=/CC?$ (T/
8CWLIZ>?d=:K>U!JGONGMNPK<NPNNN N=MF6@1%"=><*,9D):$ζ�@��w���b�q}/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.2/src/backends/linux_android_with_fallback.rs� ��T<CV/�~Z�ҥ��VD#-cP e[%U 1?0`EJ5*+Hhc\0H
2"]3J
G%G/ 
f\3@hi�S_vuSn�CX�YXs/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.2/src/backends/../utils/lazy_ptr.rs� qF_�r5o�U�n����928PN PBKJ7,!._d-aV6!& "*
[0LQP
����.���x/�*�b/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.2/src/../README.md� �U��
�#��ySz
����." Z\SU&U(	:N9 !;;�@ABT?@l@S@>=ZA>;|A=AJ>j?`AZ;RHJSR^[YHU]];ac`-YY�a\�[���QZ:$=2BTXVQN2NVZZW+ML:#L0MIFHMIQ,Q.G0&.%3%O[WM:G**"!$QPKEHMGLIJ#NOLRB1UR[YSOOL+FG>HIF=KFAIDGFIEJIJM9E'FKJDJ;NHMB>1nF3OX"(71PQDWm03%5=R75$"85U*%AH*?lM)SZxRTh^h�K|lyd�e,",;c�Q,%FVPr$�
�
���������
�
��������������������(�(�*�*�,������:�@a��@l]/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.2/src/util.rs� \+A�}}bB7Ϲ[P^��H*0MS0P
LE,>?PDI0Q=PB
+0<?BE%B
+0<?BE%;*U/3H^b���Eg��t˧a/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.2/src/backends.rs� ~#����ټ3�k���6�%?HI@F)
.>8536=#: :$ B-
"
XK[\(R>
#)%%(TNH
!)%)+'%(KJD)55

)0!KK9
.-. 
 H+$&
-I.1=# Hd-$(XL0d

 UWӒ�q�`���YL$�C�y/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.2/src/backends/../utils/sys_fill_exact.rs� P$�&��۔TU��J�
)%52=%@! PV3)D*:KN=0
��&������X�r�~t/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.2/src/backends/../utils/get_errno.rs� ;���,����?�%� �

o-�6..H-,-*5aS.
'*,
I+1�I%#J��[aF��t/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.4.2/src/backends/../utils/sanitizer.rs� /ޫ�.rܒ,mM�Tb�o�0KMLF,KMO>6$ L-"1
OM�E0�,qM#�4�� 6#B�C�DtF�GmHK�K[M:NOx86_64-unknown-linux-gnu��S�Le���.hA~���-1dc0a0d0c3ca7f7a��U�"�/
���	���������n��n����������������������������������������jj���������������������G�N�N���5rust-end-file