diff options
| author | mo khan <mo@mokhan.ca> | 2025-07-15 16:37:08 -0600 |
|---|---|---|
| committer | mo khan <mo@mokhan.ca> | 2025-07-17 16:30:22 -0600 |
| commit | 45df4d0d9b577fecee798d672695fe24ff57fb1b (patch) | |
| tree | 1b99bf645035b58e0d6db08c7a83521f41f7a75b /vendor/getrandom | |
| parent | f94f79608393d4ab127db63cc41668445ef6b243 (diff) | |
feat: migrate from Cedar to SpiceDB authorization system
This is a major architectural change that replaces the Cedar policy-based
authorization system with SpiceDB's relation-based authorization.
Key changes:
- Migrate from Rust to Go implementation
- Replace Cedar policies with SpiceDB schema and relationships
- Switch from envoy `ext_authz` with Cedar to SpiceDB permission checks
- Update build system and dependencies for Go ecosystem
- Maintain Envoy integration for external authorization
This change enables more flexible permission modeling through SpiceDB's
Google Zanzibar inspired relation-based system, supporting complex
hierarchical permissions that were difficult to express in Cedar.
Breaking change: Existing Cedar policies and Rust-based configuration
will no longer work and need to be migrated to SpiceDB schema.
Diffstat (limited to 'vendor/getrandom')
40 files changed, 0 insertions, 4583 deletions
diff --git a/vendor/getrandom/.cargo-checksum.json b/vendor/getrandom/.cargo-checksum.json deleted file mode 100644 index 1da331a5..00000000 --- a/vendor/getrandom/.cargo-checksum.json +++ /dev/null @@ -1 +0,0 @@ -{"files":{"CHANGELOG.md":"fc99d55b89ff2dcca19d1d36f4e10b76e5adecc211afff67aac4d199f35e435c","Cargo.lock":"e55b09b283d1685505f5d15a2d79f0a7c1de35c79321eafd02074c815ef67597","Cargo.toml":"c11a6fef961eec45202c915ccde2aeec475c0950f31cb3c5a74e65fea2262bbc","LICENSE-APACHE":"aaff376532ea30a0cd5330b9502ad4a4c8bf769c539c87ffe78819d188a18ebf","LICENSE-MIT":"29e9fe5074bd27e0e5d5d110394fbbcd841baee2651a3c4b4560a632702cede4","README.md":"5afb17166a328f69726ae52321b3c6f698adefbfc64898e93e45cd3d4ce3e1e5","SECURITY.md":"816ea79f8c7937888ab5a972a1efb270c4bada028b448953a195359fe11d526e","benches/buffer.rs":"20fb7dd9edafe0c182f1fe037b28d7542f8e0ae742d51e97aeebf418edde49aa","build.rs":"9280e324b69c0c80c65de8074046104ac561cbfe0b7856e02a939e491936aaac","src/backends.rs":"1c43868fdb6b1bfd0f6b6ac1e4f8195ad0045fa472e366821be2249ef5aa6da6","src/backends/apple_other.rs":"f8fa784588f347cfd7c2b5f37a96b23d446f95c3157668069d7146e281fa783b","src/backends/custom.rs":"c8776ff0dda65cef1373b8624043f8a42ce4fd6183fbeb8918f9df5d4a13d457","src/backends/efi_rng.rs":"873b7343a003a5f222753fbd50cba3f2beeacec4386ad3272ec98d654a4466d4","src/backends/esp_idf.rs":"b50d6c582b49488204151c2036a100aac7902b8215fb791f271e1b5fc772db9a","src/backends/fuchsia.rs":"d7c660a62f1da2c41c537ccea085bba6d3f83b82c34e6e63175130feca9dece8","src/backends/getentropy.rs":"a0fdf57546e20be8e76d21ec5f815f07a3a4dfb590d4d693cc2e78b494676304","src/backends/getrandom.rs":"1d165160ab4526534f0981d0cddee4075d6ddfc07d7a3086b0b30544ad755b17","src/backends/hermit.rs":"92e0cf4103b5ddc15ed48cad8d7165ba8e344fde0f07960385b36590466ee67c","src/backends/linux_android_with_fallback.rs":"ba4b820542aceee7b3b0b8b8be6460140cd0f601132b4e79f1abe0051a997af8","src/backends/linux_raw.rs":"eea0428ac3a803ae1c8463cdbaf385b73008ec67a02c7c634eb4ce01589a97f8","src/backends/netbsd.rs":"ca6a6c4c17c04ec987002296debdd7a03b10f5efd5bcb79f159b9a13c4b6821f","src/backends/rdrand.rs":"2a06eb62ad7e97c2486ab1b0159e4b9fe3a1c0a39d479a836d23051f89cb9aed","src/backends/rndr.rs":"bc06a88e3314a06494b6fe70bdae684fe45f9a6a63d28c61dbd90f66595424d0","src/backends/solaris.rs":"b263a3e8bc3c490a0c589d2a1a67d8fdb36119993df1f8d05f43975ff88f9c3e","src/backends/solid.rs":"1c92fc4c5a8ac67b64af560bb7843d6e447efe9785e557f064348fb84b83ceb8","src/backends/use_file.rs":"a2582912793ed985f7c092243405c8ee15fc2d6cb23ef4233a842325cec69492","src/backends/vxworks.rs":"64ee8619c5b5aa267761aabc99552ba8df71d14cda7cc66d6c1e4f4fb1ed8d00","src/backends/wasi_p1.rs":"77755c8fefb9f36509b2e6764edb9f8293dc1efa3d5a9bc85d28723ceeb7aec0","src/backends/wasi_p2.rs":"5821dff8eb2a145a49adcb751f9ec794e0fb8989ff625c70a98afcba48de0731","src/backends/wasm_js.rs":"5913b33ec9cb4076cef65d461ce82af98e9233f621eac8fab44b68fd37080927","src/backends/windows.rs":"60a5c9a87c8b35d3816c8909d051ce76741121806de6ea4f17a847c89b9cd4a2","src/backends/windows7.rs":"a5fac48672fa109eff2dc67f424fe99fabe4ec8af4802ce4ecc2f07706b2201c","src/error.rs":"6497fc88435c341e5547c35f259f9bebf1272b83b782794d8c6251a4c3159d28","src/error_std_impls.rs":"4c068e81d876237a7e0a0e91519896bd670c2f999ca729f7fb970caf888cab46","src/lazy.rs":"9c7e3efcc7b4cc2252751d29e42465bae8cbe49461a4a81a006d8d2c45003fd1","src/lib.rs":"54279c7e2ac54bf990c89c37f12754da7183cde6fb51d9e6900aaaed4e1f995f","src/util.rs":"207e21353f4e402daf84ff137c8d4aa4ffafa48141194ae7148252e06dcadd9f","src/util_libc.rs":"1d3f16d8996295822e6cbfc848e90912795f378913627c6b765f47b2185d9480","tests/mod.rs":"b8e88300a1ec0b2f6cbc03d40cc66eacae625d1fdc1163f4cf50fae7712d2bdc"},"package":"26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"}
\ No newline at end of file diff --git a/vendor/getrandom/CHANGELOG.md b/vendor/getrandom/CHANGELOG.md deleted file mode 100644 index fbfe1d6d..00000000 --- a/vendor/getrandom/CHANGELOG.md +++ /dev/null @@ -1,628 +0,0 @@ -# Changelog -All notable changes to this project will be documented in this file. - -The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) -and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). - -## [0.3.3] - 2025-05-09 - -### Changed -- Doc improvements [#632] [#634] [#635] -- Add crate version to docs.rs links used in `compile_error!`s [#639] - -## Fixed -- Error handling in WASI p1 [#661] - -[#632]: https://github.com/rust-random/getrandom/pull/632 -[#634]: https://github.com/rust-random/getrandom/pull/634 -[#635]: https://github.com/rust-random/getrandom/pull/635 -[#639]: https://github.com/rust-random/getrandom/pull/639 -[#661]: https://github.com/rust-random/getrandom/pull/661 - -## [0.3.2] - 2025-03-17 - -### Added -- `efi_rng` opt-in backend [#570] -- `linux_raw` opt-in backend [#572] -- `.cargo/config.toml` example in the crate-level docs [#591] -- `getrandom_test_linux_without_fallback` configuration flag to test that file fallback - is not triggered in the `linux_android_with_fallback` backend [#605] -- Built-in support for `*-linux-none` targets [#618] -- Cygwin support [#626] - -### Changed -- Update `wasi` dependency to v0.14 [#594] -- Add `#[inline]` attribute to the inner functions [#596] -- Update WASI and Emscripten links in the crate-level docs [#597] -- Do not use `dlsym` on MUSL targets in the `linux_android_with_fallback` backend [#602] -- Remove `linux_android.rs` and use `getrandom.rs` instead [#603] -- Always use `RtlGenRandom` on Windows targets when compiling with pre-1.78 Rust [#610] -- Internal representation of the `Error` type [#614] -- Remove `windows-targets` dependency and use [`raw-dylib`] directly [#627] - -### Removed -- `Error::INTERNAL_START` and `Error::CUSTOM_START` associated constants [#614] - -[#570]: https://github.com/rust-random/getrandom/pull/570 -[#572]: https://github.com/rust-random/getrandom/pull/572 -[#591]: https://github.com/rust-random/getrandom/pull/591 -[#594]: https://github.com/rust-random/getrandom/pull/594 -[#596]: https://github.com/rust-random/getrandom/pull/596 -[#597]: https://github.com/rust-random/getrandom/pull/597 -[#602]: https://github.com/rust-random/getrandom/pull/602 -[#603]: https://github.com/rust-random/getrandom/pull/603 -[#605]: https://github.com/rust-random/getrandom/pull/605 -[#610]: https://github.com/rust-random/getrandom/pull/610 -[#614]: https://github.com/rust-random/getrandom/pull/614 -[#618]: https://github.com/rust-random/getrandom/pull/618 -[#626]: https://github.com/rust-random/getrandom/pull/626 -[#627]: https://github.com/rust-random/getrandom/pull/627 -[`raw-dylib`]: https://doc.rust-lang.org/reference/items/external-blocks.html?highlight=link#dylib-versus-raw-dylib - -## [0.3.1] - 2025-01-28 - -### Fixed -- Build error on Android [#588] - -[#588]: https://github.com/rust-random/getrandom/pull/588 - -## [0.3.0] - 2025-01-25 - -### Breaking Changes - -#### Changed -- Bump MSRV to 1.63 [#542] -- Rename `getrandom` and `getrandom_uninit` functions to `fill` and `fill_uninit` respectively [#532] - -#### Removed -- `wasm32-wasi` target support (use `wasm32-wasip1` or `wasm32-wasip2` instead) [#499] -- `linux_disable_fallback`, `rdrand`, `js`, `test-in-browser`, and `custom` crate features - in favor of configuration flags [#504] -- `register_custom_getrandom!` macro [#504] -- Implementation of `From<NonZeroU32>` for `Error` and `Error::code` method [#507] -- Internet Explorer 11 support [#554] -- Target-specific assocciated `Error` constants [#562] - -### Changed -- Use `ProcessPrng` on Windows 10 and up, and use `RtlGenRandom` on older Windows versions [#415] -- Do not use locale-specific `strerror_r` for retrieving error code descriptions [#440] -- Avoid assuming `usize` is the native word size in the `rdrand` backend [#442] -- Do not read from `errno` when `libc` did not indicate error on Solaris [#448] -- Switch from `libpthread`'s mutex to `futex` on Linux and to `nanosleep`-based wait loop - on other targets in the `use_file` backend [#490] -- Do not retry on `EAGAIN` while polling `/dev/random` on Linux [#522] -- Remove separate codepath for Node.js in the `wasm_js` backend - (bumps minimum supported Node.js version to v19) [#557] -- Use `js_namespace` in the `wasm_js` backend [#559] - -### Added -- `wasm32-wasip1` and `wasm32-wasip2` support [#499] -- `getrandom_backend` configuration flag for selection of opt-in backends [#504] -- `Error::new_custom` method [#507] -- `rndr` opt-in backend [#512] -- Automatic MemorySanitizer support [#521] [#571] -- `u32` and `u64` functions for generating random values of the respective type [#544] -- `wasm32v1-none` support in the `wasm_js` backend [#560] -- `wasm_js` crate feature which allows users to enable the `wasm_js` opt-in backend [#574] - -### Fixed -- NetBSD fallback code based on `KERN_ARND` [#555] - -[#415]: https://github.com/rust-random/getrandom/pull/415 -[#440]: https://github.com/rust-random/getrandom/pull/440 -[#442]: https://github.com/rust-random/getrandom/pull/442 -[#448]: https://github.com/rust-random/getrandom/pull/448 -[#490]: https://github.com/rust-random/getrandom/pull/490 -[#499]: https://github.com/rust-random/getrandom/pull/499 -[#504]: https://github.com/rust-random/getrandom/pull/504 -[#507]: https://github.com/rust-random/getrandom/pull/507 -[#512]: https://github.com/rust-random/getrandom/pull/512 -[#521]: https://github.com/rust-random/getrandom/pull/521 -[#522]: https://github.com/rust-random/getrandom/pull/522 -[#532]: https://github.com/rust-random/getrandom/pull/532 -[#542]: https://github.com/rust-random/getrandom/pull/542 -[#544]: https://github.com/rust-random/getrandom/pull/544 -[#554]: https://github.com/rust-random/getrandom/pull/554 -[#555]: https://github.com/rust-random/getrandom/pull/555 -[#557]: https://github.com/rust-random/getrandom/pull/557 -[#559]: https://github.com/rust-random/getrandom/pull/559 -[#560]: https://github.com/rust-random/getrandom/pull/560 -[#562]: https://github.com/rust-random/getrandom/pull/562 -[#571]: https://github.com/rust-random/getrandom/pull/571 -[#574]: https://github.com/rust-random/getrandom/pull/574 - -## [0.2.16] - 2025-04-22 -### Added -- Cygwin support (backport of [#626]) [#654] - -[#654]: https://github.com/rust-random/getrandom/pull/654 - -## [0.2.15] - 2024-05-06 -### Added -- Apple visionOS support [#410] - -### Changed -- Use `libc::getrandom` on DragonflyBSD, FreeBSD, illumos, and Solaris [#411] [#416] [#417] [#420] -- Unify `libc::getentropy`-based implementations [#418] - -[#410]: https://github.com/rust-random/getrandom/pull/410 -[#411]: https://github.com/rust-random/getrandom/pull/411 -[#416]: https://github.com/rust-random/getrandom/pull/416 -[#417]: https://github.com/rust-random/getrandom/pull/417 -[#418]: https://github.com/rust-random/getrandom/pull/418 -[#420]: https://github.com/rust-random/getrandom/pull/420 - -## [0.2.14] - 2024-04-08 -### Fixed -- Enable `/dev/urandom` fallback for MUSL-based Linux targets [#408] - -[#408]: https://github.com/rust-random/getrandom/pull/408 - -## [0.2.13] - 2024-04-06 -### Added -- `linux_disable_fallback` crate feature to disable `/dev/urandom`-based fallback on Linux and - Android targets. Enabling this feature bumps minimum supported Linux kernel version to 3.17 and - Android API level to 23 (Marshmallow). [#396] - -### Changed -- Disable `/dev/urandom` fallback for Linux targets outside of the following `target_arch`es: - `aarch64`, `arm`, `powerpc`, `powerpc64`, `s390x`, `x86`, `x86_64` [#396] -- Do not catch `EPERM` error code on Android while checking availability of - the `getrandom` syscall [#396] - -[#396]: https://github.com/rust-random/getrandom/pull/396 - -## [0.2.12] - 2024-01-09 -### Fixed -- Custom backend for targets without atomics [#385] - -### Changed -- Improve robustness of the Hermit backend and `sys_fill_exact` [#386] -- Raise minimum supported Apple OS versions to macOS 10.12 and iOS 10 [#388] - -### Added -- Document platform support policy [#387] - -[#385]: https://github.com/rust-random/getrandom/pull/385 -[#386]: https://github.com/rust-random/getrandom/pull/386 -[#387]: https://github.com/rust-random/getrandom/pull/387 -[#388]: https://github.com/rust-random/getrandom/pull/388 - -## [0.2.11] - 2023-11-08 -### Added -- GNU/Hurd support [#370] - -### Changed -- Renamed `__getrandom_internal` to `__GETRANDOM_INTERNAL` [#369] -- Updated link to Hermit docs [#374] - -[#369]: https://github.com/rust-random/getrandom/pull/369 -[#370]: https://github.com/rust-random/getrandom/pull/370 -[#374]: https://github.com/rust-random/getrandom/pull/374 - -## [0.2.10] - 2023-06-06 -### Added -- Support for PS Vita (`armv7-sony-vita-newlibeabihf`) [#359] - -### Changed -- Use getentropy from libc on Emscripten targets [#362] - -[#359]: https://github.com/rust-random/getrandom/pull/359 -[#362]: https://github.com/rust-random/getrandom/pull/362 - -## [0.2.9] - 2023-04-06 -### Added -- AIX support [#282] -- `getrandom_uninit` function [#291] -- `wasm64-unknown-unknown` support [#303] -- tvOS and watchOS support [#317] -- QNX/nto support [#325] -- Support for `getrandom` syscall on NetBSD ≥ 10.0 [#331] -- `RtlGenRandom` fallback for non-UWP Windows [#337] - -### Breaking Changes -- Update MSRV to 1.36 [#291] - -### Fixed -- Solaris/OpenBSD/Dragonfly build [#301] - -### Changed -- Update MSRV to 1.36 [#291] -- Use getentropy on Emscripten [#307] -- Solaris: consistantly use `/dev/random` source [#310] -- Move 3ds selection above rdrand/js/custom fallback [#312] -- Remove buffer zeroing from Node.js implementation [#315] -- Use `open` instead of `open64` [#326] -- Remove #cfg from bsd_arandom.rs [#332] -- Hermit: use `sys_read_entropy` syscall [#333] -- Eliminate potential panic in sys_fill_exact [#334] -- rdrand: Remove checking for 0 and !0 and instead check CPU family and do a self-test [#335] -- Move `__getrandom_custom` definition into a const block [#344] -- Switch the custom backend to Rust ABI [#347] - -[#282]: https://github.com/rust-random/getrandom/pull/282 -[#291]: https://github.com/rust-random/getrandom/pull/291 -[#301]: https://github.com/rust-random/getrandom/pull/301 -[#303]: https://github.com/rust-random/getrandom/pull/303 -[#307]: https://github.com/rust-random/getrandom/pull/307 -[#310]: https://github.com/rust-random/getrandom/pull/310 -[#312]: https://github.com/rust-random/getrandom/pull/312 -[#315]: https://github.com/rust-random/getrandom/pull/315 -[#317]: https://github.com/rust-random/getrandom/pull/317 -[#325]: https://github.com/rust-random/getrandom/pull/325 -[#326]: https://github.com/rust-random/getrandom/pull/326 -[#331]: https://github.com/rust-random/getrandom/pull/331 -[#332]: https://github.com/rust-random/getrandom/pull/332 -[#333]: https://github.com/rust-random/getrandom/pull/333 -[#334]: https://github.com/rust-random/getrandom/pull/334 -[#335]: https://github.com/rust-random/getrandom/pull/335 -[#337]: https://github.com/rust-random/getrandom/pull/337 -[#344]: https://github.com/rust-random/getrandom/pull/344 -[#347]: https://github.com/rust-random/getrandom/pull/347 - -## [0.2.8] - 2022-10-20 -### Changed -- The [Web Cryptography API] will now be preferred on `wasm32-unknown-unknown` - when using the `"js"` feature, even on Node.js [#284] [#295] - -### Added -- Added benchmarks to track buffer initialization cost [#272] - -### Fixed -- Use `$crate` in `register_custom_getrandom!` [#270] - -### Documentation -- Add information about enabling `"js"` feature [#280] -- Fix link to `wasm-bindgen` [#278] -- Document the varied implementations for underlying randomness sources [#276] - -[Web Cryptography API]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API -[#284]: https://github.com/rust-random/getrandom/pull/284 -[#295]: https://github.com/rust-random/getrandom/pull/295 -[#272]: https://github.com/rust-random/getrandom/pull/272 -[#270]: https://github.com/rust-random/getrandom/pull/270 -[#280]: https://github.com/rust-random/getrandom/pull/280 -[#278]: https://github.com/rust-random/getrandom/pull/278 -[#276]: https://github.com/rust-random/getrandom/pull/276 - -## [0.2.7] - 2022-06-14 -### Changed -- Update `wasi` dependency to `0.11` [#253] - -### Fixed -- Use `AtomicPtr` instead of `AtomicUsize` for Strict Provenance compatibility. [#263] - -### Documentation -- Add comments explaining use of fallback mechanisms [#257] [#260] - -[#263]: https://github.com/rust-random/getrandom/pull/263 -[#260]: https://github.com/rust-random/getrandom/pull/260 -[#253]: https://github.com/rust-random/getrandom/pull/253 -[#257]: https://github.com/rust-random/getrandom/pull/257 - -## [0.2.6] - 2022-03-28 -### Added -- Nintendo 3DS (`armv6k-nintendo-3ds`) support [#248] - -### Changed -- Retry `open` when interrupted [#252] - -[#248]: https://github.com/rust-random/getrandom/pull/248 -[#252]: https://github.com/rust-random/getrandom/pull/252 - -## [0.2.5] - 2022-02-22 -### Added -- ESP-IDF targets (`*‑espidf`) support [#245] - -### Fixed -- Webpack warning caused by dynamic require [#234] -- Error checking on iOS for `SecRandomCopyBytes` [#244] - -[#234]: https://github.com/rust-random/getrandom/pull/234 -[#244]: https://github.com/rust-random/getrandom/pull/244 -[#245]: https://github.com/rust-random/getrandom/pull/245 - -## [0.2.4] - 2021-12-13 -### Changed -- Use explicit imports in the `js` backend [#220] -- Use `/dev/urandom` on Redox instead of `rand:` [#222] -- Use `NonZeroU32::new_unchecked` to convert wasi error [#233] - -### Added -- SOLID targets (`*-kmc-solid_*`) support [#235] -- Limited Hermit (`x86_64-unknown-hermit`) support [#236] - -[#220]: https://github.com/rust-random/getrandom/pull/220 -[#222]: https://github.com/rust-random/getrandom/pull/222 -[#233]: https://github.com/rust-random/getrandom/pull/233 -[#235]: https://github.com/rust-random/getrandom/pull/235 -[#236]: https://github.com/rust-random/getrandom/pull/236 - -## [0.2.3] - 2021-04-10 -### Changed -- Replace build.rs with link attributes. [#205] -- Add support for getrandom syscall on DragonFly BSD. [#210] -- Improve Node.js detection. [#215] - -[#205]: https://github.com/rust-random/getrandom/pull/205 -[#210]: https://github.com/rust-random/getrandom/pull/210 -[#215]: https://github.com/rust-random/getrandom/pull/215 - -## [0.2.2] - 2021-01-19 -### Changed -- Forward `rustc-dep-of-std` to dependencies. [#198] -- Highlight feature-dependent functionality in documentation using the `doc_cfg` feature. [#200] - -[#198]: https://github.com/rust-random/getrandom/pull/198 -[#200]: https://github.com/rust-random/getrandom/pull/200 - -## [0.2.1] - 2021-01-03 -### Changed -- Update `cfg-if` to v1.0. [#166] -- Update `wasi` to v0.10. [#167] - -### Fixed -- Multithreaded WASM support. [#165] - -### Removed -- Windows XP support. [#177] -- Direct `stdweb` support. [#178] -- CloudABI support. [#184] - -[#165]: https://github.com/rust-random/getrandom/pull/165 -[#166]: https://github.com/rust-random/getrandom/pull/166 -[#167]: https://github.com/rust-random/getrandom/pull/167 -[#177]: https://github.com/rust-random/getrandom/pull/177 -[#178]: https://github.com/rust-random/getrandom/pull/178 -[#184]: https://github.com/rust-random/getrandom/pull/184 - -## [0.2.0] - 2020-09-10 -### Features for using getrandom on unsupported targets - -The following (off by default) Cargo features have been added: -- `"rdrand"` - use the RDRAND instruction on `no_std` `x86`/`x86_64` targets [#133] -- `"js"` - use JavaScript calls on `wasm32-unknown-unknown` [#149] - - Replaces the `stdweb` and `wasm-bindgen` features (which are removed) -- `"custom"` - allows a user to specify a custom implementation [#109] - -### Breaking Changes -- Unsupported targets no longer compile [#107] -- Change/Add `Error` constants [#120] -- Only impl `std` traits when the `"std"` Cargo feature is specified [#106] -- Remove official support for Hermit, L4Re, and UEFI [#133] -- Remove optional `"log"` dependency [#131] -- Update minimum supported Linux kernel to 2.6.32 [#153] -- Update MSRV to 1.34 [#159] - -[#106]: https://github.com/rust-random/getrandom/pull/106 -[#107]: https://github.com/rust-random/getrandom/pull/107 -[#109]: https://github.com/rust-random/getrandom/pull/109 -[#120]: https://github.com/rust-random/getrandom/pull/120 -[#131]: https://github.com/rust-random/getrandom/pull/131 -[#133]: https://github.com/rust-random/getrandom/pull/133 -[#149]: https://github.com/rust-random/getrandom/pull/149 -[#153]: https://github.com/rust-random/getrandom/pull/153 -[#159]: https://github.com/rust-random/getrandom/pull/159 - -## [0.1.16] - 2020-12-31 -### Changed -- Update `cfg-if` to v1.0. [#173] -- Implement `std::error::Error` for the `Error` type on additional targets. [#169] - -### Fixed -- Multithreaded WASM support. [#171] - -[#173]: https://github.com/rust-random/getrandom/pull/173 -[#171]: https://github.com/rust-random/getrandom/pull/171 -[#169]: https://github.com/rust-random/getrandom/pull/169 - -## [0.1.15] - 2020-09-10 -### Changed -- Added support for Internet Explorer 11 [#139] -- Fix Webpack require warning with `wasm-bindgen` [#137] - -[#137]: https://github.com/rust-random/getrandom/pull/137 -[#139]: https://github.com/rust-random/getrandom/pull/139 - -## [0.1.14] - 2020-01-07 -### Changed -- Remove use of spin-locks in the `use_file` module. [#125] -- Update `wasi` to v0.9. [#126] -- Do not read errno value on DragonFlyBSD to fix compilation failure. [#129] - -[#125]: https://github.com/rust-random/getrandom/pull/125 -[#126]: https://github.com/rust-random/getrandom/pull/126 -[#129]: https://github.com/rust-random/getrandom/pull/129 - -## [0.1.13] - 2019-08-25 -### Added -- VxWorks targets support. [#86] - -### Changed -- If zero-length slice is passed to the `getrandom` function, always return -`Ok(())` immediately without doing any calls to the underlying operating -system. [#104] -- Use the `kern.arandom` sysctl on NetBSD. [#115] - -### Fixed -- Bump `cfg-if` minimum version from 0.1.0 to 0.1.2. [#112] -- Typos and bad doc links. [#117] - -[#86]: https://github.com/rust-random/getrandom/pull/86 -[#104]: https://github.com/rust-random/getrandom/pull/104 -[#112]: https://github.com/rust-random/getrandom/pull/112 -[#115]: https://github.com/rust-random/getrandom/pull/115 -[#117]: https://github.com/rust-random/getrandom/pull/117 - -## [0.1.12] - 2019-08-18 -### Changed -- Update wasi dependency from v0.5 to v0.7. [#100] - -[#100]: https://github.com/rust-random/getrandom/pull/100 - -## [0.1.11] - 2019-08-25 -### Fixed -- Implement `std`-dependent traits for selected targets even if `std` -feature is disabled. (backward compatibility with v0.1.8) [#96] - -[#96]: https://github.com/rust-random/getrandom/pull/96 - -## [0.1.10] - 2019-08-18 [YANKED] -### Changed -- Use the dummy implementation on `wasm32-unknown-unknown` even with the -disabled `dummy` feature. [#90] - -### Fixed -- Fix CSP error for `wasm-bindgen`. [#92] - -[#90]: https://github.com/rust-random/getrandom/pull/90 -[#92]: https://github.com/rust-random/getrandom/pull/92 - -## [0.1.9] - 2019-08-14 [YANKED] -### Changed -- Remove `std` dependency for opening and reading files. [#58] -- Use `wasi` instead of `libc` on WASI target. [#64] -- By default emit a compile-time error when built for an unsupported target. -This behaviour can be disabled by using the `dummy` feature. [#71] - -### Added -- Add support for UWP targets. [#69] -- Add unstable `rustc-dep-of-std` feature. [#78] - -[#58]: https://github.com/rust-random/getrandom/pull/58 -[#64]: https://github.com/rust-random/getrandom/pull/64 -[#69]: https://github.com/rust-random/getrandom/pull/69 -[#71]: https://github.com/rust-random/getrandom/pull/71 -[#78]: https://github.com/rust-random/getrandom/pull/78 - -## [0.1.8] - 2019-07-29 -### Changed -- Explicitly specify types to arguments of 'libc::syscall'. [#74] - -[#74]: https://github.com/rust-random/getrandom/pull/74 - -## [0.1.7] - 2019-07-29 -### Added -- Support for hermit and l4re. [#61] -- `Error::raw_os_error` method, `Error::INTERNAL_START` and -`Error::CUSTOM_START` constants. Use `libc` for retrieving OS error descriptions. [#54] - -### Changed -- Remove `lazy_static` dependency and use custom structures for lock-free -initialization. [#51] [#52] -- Try `getrandom()` first on FreeBSD. [#57] - -### Removed -- Bitrig support. [#56] - -### Deprecated -- `Error::UNKNOWN`, `Error::UNAVAILABLE`. [#54] - -[#51]: https://github.com/rust-random/getrandom/pull/51 -[#52]: https://github.com/rust-random/getrandom/pull/52 -[#54]: https://github.com/rust-random/getrandom/pull/54 -[#56]: https://github.com/rust-random/getrandom/pull/56 -[#57]: https://github.com/rust-random/getrandom/pull/57 -[#61]: https://github.com/rust-random/getrandom/pull/61 - -## [0.1.6] - 2019-06-30 -### Changed -- Minor change of RDRAND AMD bug handling. [#48] - -[#48]: https://github.com/rust-random/getrandom/pull/48 - -## [0.1.5] - 2019-06-29 -### Fixed -- Use shared `File` instead of shared file descriptor. [#44] -- Workaround for RDRAND hardware bug present on some AMD CPUs. [#43] - -### Changed -- Try `getentropy` and then fallback to `/dev/random` on macOS. [#38] - -[#38]: https://github.com/rust-random/getrandom/issues/38 -[#43]: https://github.com/rust-random/getrandom/pull/43 -[#44]: https://github.com/rust-random/getrandom/issues/44 - -## [0.1.4] - 2019-06-28 -### Added -- Add support for `x86_64-unknown-uefi` target by using RDRAND with CPUID -feature detection. [#30] - -### Fixed -- Fix long buffer issues on Windows and Linux. [#31] [#32] -- Check `EPERM` in addition to `ENOSYS` on Linux. [#37] - -### Changed -- Improve efficiency by sharing file descriptor across threads. [#13] -- Remove `cloudabi`, `winapi`, and `fuchsia-cprng` dependencies. [#40] -- Improve RDRAND implementation. [#24] -- Don't block during syscall detection on Linux. [#26] -- Increase consistency with libc implementation on FreeBSD. [#36] -- Apply `rustfmt`. [#39] - -[#30]: https://github.com/rust-random/getrandom/pull/30 -[#13]: https://github.com/rust-random/getrandom/issues/13 -[#40]: https://github.com/rust-random/getrandom/pull/40 -[#26]: https://github.com/rust-random/getrandom/pull/26 -[#24]: https://github.com/rust-random/getrandom/pull/24 -[#39]: https://github.com/rust-random/getrandom/pull/39 -[#36]: https://github.com/rust-random/getrandom/pull/36 -[#31]: https://github.com/rust-random/getrandom/issues/31 -[#32]: https://github.com/rust-random/getrandom/issues/32 -[#37]: https://github.com/rust-random/getrandom/issues/37 - -## [0.1.3] - 2019-05-15 -- Update for `wasm32-unknown-wasi` being renamed to `wasm32-wasi`, and for - WASI being categorized as an OS. - -## [0.1.2] - 2019-04-06 -- Add support for `wasm32-unknown-wasi` target. - -## [0.1.1] - 2019-04-05 -- Enable std functionality for CloudABI by default. - -## [0.1.0] - 2019-03-23 -Publish initial implementation. - -## [0.0.0] - 2019-01-19 -Publish an empty template library. - -[0.3.3]: https://github.com/rust-random/getrandom/compare/v0.3.2...v0.3.3 -[0.3.2]: https://github.com/rust-random/getrandom/compare/v0.3.1...v0.3.2 -[0.3.1]: https://github.com/rust-random/getrandom/compare/v0.3.0...v0.3.1 -[0.3.0]: https://github.com/rust-random/getrandom/compare/v0.2.15...v0.3.0 -[0.2.16]: https://github.com/rust-random/getrandom/compare/v0.2.15...v0.2.16 -[0.2.15]: https://github.com/rust-random/getrandom/compare/v0.2.14...v0.2.15 -[0.2.14]: https://github.com/rust-random/getrandom/compare/v0.2.13...v0.2.14 -[0.2.13]: https://github.com/rust-random/getrandom/compare/v0.2.12...v0.2.13 -[0.2.12]: https://github.com/rust-random/getrandom/compare/v0.2.11...v0.2.12 -[0.2.11]: https://github.com/rust-random/getrandom/compare/v0.2.10...v0.2.11 -[0.2.10]: https://github.com/rust-random/getrandom/compare/v0.2.9...v0.2.10 -[0.2.9]: https://github.com/rust-random/getrandom/compare/v0.2.8...v0.2.9 -[0.2.8]: https://github.com/rust-random/getrandom/compare/v0.2.7...v0.2.8 -[0.2.7]: https://github.com/rust-random/getrandom/compare/v0.2.6...v0.2.7 -[0.2.6]: https://github.com/rust-random/getrandom/compare/v0.2.5...v0.2.6 -[0.2.5]: https://github.com/rust-random/getrandom/compare/v0.2.4...v0.2.5 -[0.2.4]: https://github.com/rust-random/getrandom/compare/v0.2.3...v0.2.4 -[0.2.3]: https://github.com/rust-random/getrandom/compare/v0.2.2...v0.2.3 -[0.2.2]: https://github.com/rust-random/getrandom/compare/v0.2.1...v0.2.2 -[0.2.1]: https://github.com/rust-random/getrandom/compare/v0.2.0...v0.2.1 -[0.2.0]: https://github.com/rust-random/getrandom/compare/v0.1.16...v0.2.0 -[0.1.16]: https://github.com/rust-random/getrandom/compare/v0.1.15...v0.1.16 -[0.1.15]: https://github.com/rust-random/getrandom/compare/v0.1.14...v0.1.15 -[0.1.14]: https://github.com/rust-random/getrandom/compare/v0.1.13...v0.1.14 -[0.1.13]: https://github.com/rust-random/getrandom/compare/v0.1.12...v0.1.13 -[0.1.12]: https://github.com/rust-random/getrandom/compare/v0.1.11...v0.1.12 -[0.1.11]: https://github.com/rust-random/getrandom/compare/v0.1.10...v0.1.11 -[0.1.10]: https://github.com/rust-random/getrandom/compare/v0.1.9...v0.1.10 -[0.1.9]: https://github.com/rust-random/getrandom/compare/v0.1.8...v0.1.9 -[0.1.8]: https://github.com/rust-random/getrandom/compare/v0.1.7...v0.1.8 -[0.1.7]: https://github.com/rust-random/getrandom/compare/v0.1.6...v0.1.7 -[0.1.6]: https://github.com/rust-random/getrandom/compare/v0.1.5...v0.1.6 -[0.1.5]: https://github.com/rust-random/getrandom/compare/v0.1.4...v0.1.5 -[0.1.4]: https://github.com/rust-random/getrandom/compare/v0.1.3...v0.1.4 -[0.1.3]: https://github.com/rust-random/getrandom/compare/v0.1.2...v0.1.3 -[0.1.2]: https://github.com/rust-random/getrandom/compare/v0.1.1...v0.1.2 -[0.1.1]: https://github.com/rust-random/getrandom/compare/v0.1.0...v0.1.1 -[0.1.0]: https://github.com/rust-random/getrandom/compare/v0.0.0...v0.1.0 -[0.0.0]: https://github.com/rust-random/getrandom/releases/tag/v0.0.0 diff --git a/vendor/getrandom/Cargo.lock b/vendor/getrandom/Cargo.lock deleted file mode 100644 index c27e9a5b..00000000 --- a/vendor/getrandom/Cargo.lock +++ /dev/null @@ -1,365 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -version = 3 - -[[package]] -name = "bitflags" -version = "2.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd" - -[[package]] -name = "bumpalo" -version = "3.17.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1628fb46dfa0b37568d12e5edd512553eccf6a22a78e8bde00bb4aed84d5bdbf" - -[[package]] -name = "cc" -version = "1.2.21" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8691782945451c1c383942c4874dbe63814f61cb57ef773cda2972682b7bb3c0" -dependencies = [ - "shlex", -] - -[[package]] -name = "cfg-if" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" - -[[package]] -name = "compiler_builtins" -version = "0.1.157" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "74f103f5a97b25e3ed7134dee586e90bbb0496b33ba41816f0e7274e5bb73b50" - -[[package]] -name = "getrandom" -version = "0.3.3" -dependencies = [ - "cfg-if", - "compiler_builtins", - "js-sys", - "libc", - "r-efi", - "rustc-std-workspace-core", - "wasi", - "wasm-bindgen", - "wasm-bindgen-test", -] - -[[package]] -name = "js-sys" -version = "0.3.77" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f" -dependencies = [ - "once_cell", - "wasm-bindgen", -] - -[[package]] -name = "libc" -version = "0.2.171" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6" - -[[package]] -name = "log" -version = "0.4.27" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" - -[[package]] -name = "minicov" -version = "0.3.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f27fe9f1cc3c22e1687f9446c2083c4c5fc7f0bcf1c7a86bdbded14985895b4b" -dependencies = [ - "cc", - "walkdir", -] - -[[package]] -name = "once_cell" -version = "1.21.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" - -[[package]] -name = "proc-macro2" -version = "1.0.95" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778" -dependencies = [ - "unicode-ident", -] - -[[package]] -name = "quote" -version = "1.0.40" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d" -dependencies = [ - "proc-macro2", -] - -[[package]] -name = "r-efi" -version = "5.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5" - -[[package]] -name = "rustc-std-workspace-core" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aa9c45b374136f52f2d6311062c7146bff20fec063c3f5d46a410bd937746955" - -[[package]] -name = "same-file" -version = "1.0.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" -dependencies = [ - "winapi-util", -] - -[[package]] -name = "shlex" -version = "1.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" - -[[package]] -name = "syn" -version = "2.0.101" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ce2b7fc941b3a24138a0a7cf8e858bfc6a992e7978a068a5c760deb0ed43caf" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "unicode-ident" -version = "1.0.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512" - -[[package]] -name = "walkdir" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" -dependencies = [ - "same-file", - "winapi-util", -] - -[[package]] -name = "wasi" -version = "0.14.2+wasi-0.2.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3" -dependencies = [ - "wit-bindgen-rt", -] - -[[package]] -name = "wasm-bindgen" -version = "0.2.100" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5" -dependencies = [ - "cfg-if", - "once_cell", - "wasm-bindgen-macro", -] - -[[package]] -name = "wasm-bindgen-backend" -version = "0.2.100" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6" -dependencies = [ - "bumpalo", - "log", - "proc-macro2", - "quote", - "syn", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-futures" -version = "0.4.50" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "555d470ec0bc3bb57890405e5d4322cc9ea83cebb085523ced7be4144dac1e61" -dependencies = [ - "cfg-if", - "js-sys", - "once_cell", - "wasm-bindgen", - "web-sys", -] - -[[package]] -name = "wasm-bindgen-macro" -version = "0.2.100" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407" -dependencies = [ - "quote", - "wasm-bindgen-macro-support", -] - -[[package]] -name = "wasm-bindgen-macro-support" -version = "0.2.100" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de" -dependencies = [ - "proc-macro2", - "quote", - "syn", - "wasm-bindgen-backend", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-shared" -version = "0.2.100" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d" -dependencies = [ - "unicode-ident", -] - -[[package]] -name = "wasm-bindgen-test" -version = "0.3.50" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "66c8d5e33ca3b6d9fa3b4676d774c5778031d27a578c2b007f905acf816152c3" -dependencies = [ - "js-sys", - "minicov", - "wasm-bindgen", - "wasm-bindgen-futures", - "wasm-bindgen-test-macro", -] - -[[package]] -name = "wasm-bindgen-test-macro" -version = "0.3.50" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "17d5042cc5fa009658f9a7333ef24291b1291a25b6382dd68862a7f3b969f69b" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - -[[package]] -name = "web-sys" -version = "0.3.77" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2" -dependencies = [ - "js-sys", - "wasm-bindgen", -] - -[[package]] -name = "winapi-util" -version = "0.1.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb" -dependencies = [ - "windows-sys", -] - -[[package]] -name = "windows-sys" -version = "0.59.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" -dependencies = [ - "windows-targets", -] - -[[package]] -name = "windows-targets" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" -dependencies = [ - "windows_aarch64_gnullvm", - "windows_aarch64_msvc", - "windows_i686_gnu", - "windows_i686_gnullvm", - "windows_i686_msvc", - "windows_x86_64_gnu", - "windows_x86_64_gnullvm", - "windows_x86_64_msvc", -] - -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" - -[[package]] -name = "windows_i686_gnu" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" - -[[package]] -name = "windows_i686_gnullvm" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" - -[[package]] -name = "windows_i686_msvc" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" - -[[package]] -name = "windows_x86_64_gnu" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" - -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" - -[[package]] -name = "windows_x86_64_msvc" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" - -[[package]] -name = "wit-bindgen-rt" -version = "0.39.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1" -dependencies = [ - "bitflags", -] diff --git a/vendor/getrandom/Cargo.toml b/vendor/getrandom/Cargo.toml deleted file mode 100644 index f4f2f6c6..00000000 --- a/vendor/getrandom/Cargo.toml +++ /dev/null @@ -1,147 +0,0 @@ -# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO -# -# When uploading crates to the registry Cargo will automatically -# "normalize" Cargo.toml files for maximal compatibility -# with all versions of Cargo and also rewrite `path` dependencies -# to registry (e.g., crates.io) dependencies. -# -# If you are reading this file be aware that the original Cargo.toml -# will likely look very different (and much more reasonable). -# See Cargo.toml.orig for the original contents. - -[package] -edition = "2021" -rust-version = "1.63" -name = "getrandom" -version = "0.3.3" -authors = ["The Rand Project Developers"] -build = "build.rs" -exclude = [".*"] -autolib = false -autobins = false -autoexamples = false -autotests = false -autobenches = false -description = "A small cross-platform library for retrieving random data from system source" -documentation = "https://docs.rs/getrandom" -readme = "README.md" -categories = [ - "os", - "no-std", -] -license = "MIT OR Apache-2.0" -repository = "https://github.com/rust-random/getrandom" - -[package.metadata.cross.target.x86_64-unknown-netbsd] -pre-build = [ - "mkdir -p /tmp/netbsd", - "curl -fO https://cdn.netbsd.org/pub/NetBSD/NetBSD-9.3/amd64/binary/sets/base.tar.xz", - "tar -C /tmp/netbsd -xJf base.tar.xz", - "cp /tmp/netbsd/usr/lib/libexecinfo.so /usr/local/x86_64-unknown-netbsd/lib", - "rm base.tar.xz", - "rm -rf /tmp/netbsd", -] - -[package.metadata.docs.rs] -features = ["std"] - -[features] -rustc-dep-of-std = [ - "dep:compiler_builtins", - "dep:core", -] -std = [] -wasm_js = [ - "dep:wasm-bindgen", - "dep:js-sys", -] - -[lib] -name = "getrandom" -path = "src/lib.rs" - -[[test]] -name = "mod" -path = "tests/mod.rs" - -[[bench]] -name = "buffer" -path = "benches/buffer.rs" - -[dependencies.cfg-if] -version = "1" - -[dependencies.compiler_builtins] -version = "0.1" -optional = true - -[dependencies.core] -version = "1.0" -optional = true -package = "rustc-std-workspace-core" - -[target.'cfg(all(any(target_os = "linux", target_os = "android"), not(any(all(target_os = "linux", target_env = ""), getrandom_backend = "custom", getrandom_backend = "linux_raw", getrandom_backend = "rdrand", getrandom_backend = "rndr"))))'.dependencies.libc] -version = "0.2.154" -default-features = false - -[target.'cfg(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "none")))'.dependencies.wasm-bindgen] -version = "0.2.98" -optional = true -default-features = false - -[target.'cfg(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "none")))'.dev-dependencies.wasm-bindgen-test] -version = "0.3" - -[target.'cfg(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "none"), target_feature = "atomics"))'.dependencies.js-sys] -version = "0.3.77" -optional = true -default-features = false - -[target.'cfg(all(target_arch = "wasm32", target_os = "wasi", target_env = "p2"))'.dependencies.wasi] -version = "0.14" -default-features = false - -[target.'cfg(all(target_os = "uefi", getrandom_backend = "efi_rng"))'.dependencies.r-efi] -version = "5.1" -default-features = false - -[target.'cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "hurd", target_os = "illumos", target_os = "cygwin", all(target_os = "horizon", target_arch = "arm")))'.dependencies.libc] -version = "0.2.154" -default-features = false - -[target.'cfg(any(target_os = "haiku", target_os = "redox", target_os = "nto", target_os = "aix"))'.dependencies.libc] -version = "0.2.154" -default-features = false - -[target.'cfg(any(target_os = "ios", target_os = "visionos", target_os = "watchos", target_os = "tvos"))'.dependencies.libc] -version = "0.2.154" -default-features = false - -[target.'cfg(any(target_os = "macos", target_os = "openbsd", target_os = "vita", target_os = "emscripten"))'.dependencies.libc] -version = "0.2.154" -default-features = false - -[target.'cfg(target_os = "netbsd")'.dependencies.libc] -version = "0.2.154" -default-features = false - -[target.'cfg(target_os = "solaris")'.dependencies.libc] -version = "0.2.154" -default-features = false - -[target.'cfg(target_os = "vxworks")'.dependencies.libc] -version = "0.2.154" -default-features = false - -[lints.rust.unexpected_cfgs] -level = "warn" -priority = 0 -check-cfg = [ - 'cfg(getrandom_backend, values("custom", "efi_rng", "rdrand", "rndr", "linux_getrandom", "linux_raw", "wasm_js"))', - "cfg(getrandom_msan)", - "cfg(getrandom_windows_legacy)", - "cfg(getrandom_test_linux_fallback)", - "cfg(getrandom_test_linux_without_fallback)", - "cfg(getrandom_test_netbsd_fallback)", - 'cfg(target_os, values("cygwin"))', -] diff --git a/vendor/getrandom/LICENSE-APACHE b/vendor/getrandom/LICENSE-APACHE deleted file mode 100644 index 17d74680..00000000 --- a/vendor/getrandom/LICENSE-APACHE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - https://www.apache.org/licenses/ - -TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - -1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - -2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - -3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - -4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - -5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - -6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - -7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - -8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - -9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - -END OF TERMS AND CONDITIONS - -APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - -Copyright [yyyy] [name of copyright owner] - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - https://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. diff --git a/vendor/getrandom/LICENSE-MIT b/vendor/getrandom/LICENSE-MIT deleted file mode 100644 index e54440a9..00000000 --- a/vendor/getrandom/LICENSE-MIT +++ /dev/null @@ -1,26 +0,0 @@ -Copyright (c) 2018-2025 The rust-random Project Developers -Copyright (c) 2014 The Rust Project Developers - -Permission is hereby granted, free of charge, to any -person obtaining a copy of this software and associated -documentation files (the "Software"), to deal in the -Software without restriction, including without -limitation the rights to use, copy, modify, merge, -publish, distribute, sublicense, and/or sell copies of -the Software, and to permit persons to whom the Software -is furnished to do so, subject to the following -conditions: - -The above copyright notice and this permission notice -shall be included in all copies or substantial portions -of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF -ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED -TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A -PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT -SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR -IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -DEALINGS IN THE SOFTWARE. diff --git a/vendor/getrandom/README.md b/vendor/getrandom/README.md deleted file mode 100644 index b0e17d47..00000000 --- a/vendor/getrandom/README.md +++ /dev/null @@ -1,390 +0,0 @@ -# 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`] on Rust 1.78+, [`RtlGenRandom`] otherwise -| 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`]) - -Pull Requests that add support for new targets to `getrandom` are always welcome. - -### 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 -| `wasm_js` | Web Browser, Node.js | `wasm32‑unknown‑unknown`, `wasm32v1-none` | [`Crypto.getRandomValues`]. Requires feature `wasm_js` ([see below](#webassembly-support)). -| `efi_rng` | UEFI | `*-unknown‑uefi` | [`EFI_RNG_PROTOCOL`] with `EFI_RNG_ALGORITHM_RAW` (requires `std` and Nigthly compiler) -| `custom` | All targets | `*` | User-provided custom implementation (see [custom backend]) - -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.wasm32-unknown-unknown] -rustflags = ['--cfg', 'getrandom_backend="wasm_js"'] -``` - -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. - -### 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). - -To enable `getrandom`'s functionality on `wasm32-unknown-unknown` using the Web -Crypto methods [described above][opt-in] via [`wasm-bindgen`], do -*both* of the following: - -- Use the `wasm_js` feature flag, i.e. - `getrandom = { version = "0.3", features = ["wasm_js"] }`. - On its own, this only makes the backend available. (As a side effect this - will make your `Cargo.lock` significantly larger if you are not already - using [`wasm-bindgen`], but otherwise enabling this feature is harmless.) -- Set `RUSTFLAGS='--cfg getrandom_backend="wasm_js"'` ([see above][opt-in]). - -This backend supports both web browsers (main window and Web Workers) -and Node.js (v19 or later) environments. - -WARNING: It is highly recommended to enable the `wasm_js` feature only for -binary crates and tests, i.e. avoid unconditionally enabling it in library crates. - -### 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; - -#[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(()) -} - -#[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) -} -``` - -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 -use the following custom backend, which always returns the "unsupported" error: -```rust -use getrandom::Error; - -#[no_mangle] -unsafe extern "Rust" fn __getrandom_v03_custom( - dest: *mut u8, - len: usize, -) -> Result<(), Error> { - 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.63 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 -[`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 - -[//]: # (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 diff --git a/vendor/getrandom/SECURITY.md b/vendor/getrandom/SECURITY.md deleted file mode 100644 index 19bfb9a2..00000000 --- a/vendor/getrandom/SECURITY.md +++ /dev/null @@ -1,13 +0,0 @@ -# Security Policy - -## Supported Versions - -Security updates are applied only to the latest release. - -## Reporting a Vulnerability - -If you have discovered a security vulnerability in this project, please report it privately. **Do not disclose it as a public issue.** This gives us time to work with you to fix the issue before public exposure, reducing the chance that the exploit will be used before a patch is released. - -Please disclose it at [security advisory](https://github.com/rust-random/getrandom/security/advisories/new). - -This project is maintained by a team of volunteers on a reasonable-effort basis. As such, please give us at least 90 days to work on a fix before public exposure. diff --git a/vendor/getrandom/benches/buffer.rs b/vendor/getrandom/benches/buffer.rs deleted file mode 100644 index 0063a453..00000000 --- a/vendor/getrandom/benches/buffer.rs +++ /dev/null @@ -1,121 +0,0 @@ -#![feature(test, maybe_uninit_uninit_array_transpose)] -extern crate test; - -use std::{ - mem::{size_of, MaybeUninit}, - slice, -}; - -// Call getrandom on a zero-initialized stack buffer -#[inline(always)] -fn bench_fill<const N: usize>() { - let mut buf = [0u8; N]; - getrandom::fill(&mut buf).unwrap(); - test::black_box(&buf[..]); -} - -// Call fill_uninit on an uninitialized stack buffer -#[inline(always)] -fn bench_fill_uninit<const N: usize>() { - let mut uninit = [MaybeUninit::uninit(); N]; - let buf: &[u8] = getrandom::fill_uninit(&mut uninit).unwrap(); - test::black_box(buf); -} - -#[bench] -pub fn bench_u32(b: &mut test::Bencher) { - #[inline(never)] - fn inner() -> u32 { - getrandom::u32().unwrap() - } - b.bytes = 4; - b.iter(inner); -} -#[bench] -pub fn bench_u32_via_fill(b: &mut test::Bencher) { - #[inline(never)] - fn inner() -> u32 { - let mut res = MaybeUninit::<u32>::uninit(); - let dst: &mut [MaybeUninit<u8>] = - unsafe { slice::from_raw_parts_mut(res.as_mut_ptr().cast(), size_of::<u32>()) }; - getrandom::fill_uninit(dst).unwrap(); - unsafe { res.assume_init() } - } - b.bytes = 4; - b.iter(inner); -} - -#[bench] -pub fn bench_u64(b: &mut test::Bencher) { - #[inline(never)] - fn inner() -> u64 { - getrandom::u64().unwrap() - } - b.bytes = 8; - b.iter(inner); -} - -#[bench] -pub fn bench_u64_via_fill(b: &mut test::Bencher) { - #[inline(never)] - fn inner() -> u64 { - let mut res = MaybeUninit::<u64>::uninit(); - let dst: &mut [MaybeUninit<u8>] = - unsafe { slice::from_raw_parts_mut(res.as_mut_ptr().cast(), size_of::<u64>()) }; - getrandom::fill_uninit(dst).unwrap(); - unsafe { res.assume_init() } - } - b.bytes = 8; - b.iter(inner); -} - -// We benchmark using #[inline(never)] "inner" functions for two reasons: -// - Avoiding inlining reduces a source of variance when running benchmarks. -// - It is _much_ easier to get the assembly or IR for the inner loop. -// -// For example, using cargo-show-asm (https://github.com/pacak/cargo-show-asm), -// we can get the assembly for a particular benchmark's inner loop by running: -// cargo asm --bench buffer --release buffer::p384::bench_getrandom::inner -macro_rules! bench { - ( $name:ident, $size:expr ) => { - pub mod $name { - #[bench] - pub fn bench_fill(b: &mut test::Bencher) { - #[inline(never)] - fn inner() { - super::bench_fill::<{ $size }>() - } - - b.bytes = $size as u64; - b.iter(inner); - } - #[bench] - pub fn bench_fill_uninit(b: &mut test::Bencher) { - #[inline(never)] - fn inner() { - super::bench_fill_uninit::<{ $size }>() - } - - b.bytes = $size as u64; - b.iter(inner); - } - } - }; -} - -// 16 bytes (128 bits) is the size of an 128-bit AES key/nonce. -bench!(aes128, 128 / 8); - -// 32 bytes (256 bits) is the seed sized used for rand::thread_rng -// and the `random` value in a ClientHello/ServerHello for TLS. -// This is also the size of a 256-bit AES/HMAC/P-256/Curve25519 key -// and/or nonce. -bench!(p256, 256 / 8); - -// A P-384/HMAC-384 key and/or nonce. -bench!(p384, 384 / 8); - -// Initializing larger buffers is not the primary use case of this library, as -// this should normally be done by a userspace CSPRNG. However, we have a test -// here to see the effects of a lower (amortized) syscall overhead. -bench!(page, 4096); diff --git a/vendor/getrandom/build.rs b/vendor/getrandom/build.rs deleted file mode 100644 index 14aaf0c8..00000000 --- a/vendor/getrandom/build.rs +++ /dev/null @@ -1,57 +0,0 @@ -use std::{env, ffi::OsString, process::Command}; - -/// Tries to get the minor version of the Rust compiler in use. -/// If it fails for any reason, returns `None`. -/// -/// Based on the `rustc_version` crate. -fn rustc_minor_version() -> Option<u64> { - let rustc = env::var_os("RUSTC").unwrap_or_else(|| OsString::from("rustc")); - let mut cmd = if let Some(wrapper) = env::var_os("RUSTC_WRAPPER").filter(|w| !w.is_empty()) { - let mut cmd = Command::new(wrapper); - cmd.arg(rustc); - cmd - } else { - Command::new(rustc) - }; - - let out = cmd.arg("-vV").output().ok()?; - - if !out.status.success() { - return None; - } - - let stdout = std::str::from_utf8(&out.stdout).ok()?; - - // Assumes that the first line contains "rustc 1.xx.0-channel (abcdef 2025-01-01)" - // where "xx" is the minor version which we want to extract - let mut lines = stdout.lines(); - let first_line = lines.next()?; - let minor_ver_str = first_line.split(".").nth(1)?; - minor_ver_str.parse().ok() -} - -fn main() { - // Automatically detect cfg(sanitize = "memory") even if cfg(sanitize) isn't - // supported. Build scripts get cfg() info, even if the cfg is unstable. - println!("cargo:rerun-if-changed=build.rs"); - let santizers = std::env::var("CARGO_CFG_SANITIZE").unwrap_or_default(); - if santizers.contains("memory") { - println!("cargo:rustc-cfg=getrandom_msan"); - } - - // Use `RtlGenRandom` on older compiler versions since win7 targets - // TODO(MSRV 1.78): Remove this check - let target_family = env::var_os("CARGO_CFG_TARGET_FAMILY").and_then(|f| f.into_string().ok()); - if target_family.as_deref() == Some("windows") { - /// Minor version of the Rust compiler in which win7 targets were inroduced - const WIN7_INTRODUCED_MINOR_VER: u64 = 78; - - match rustc_minor_version() { - Some(minor_ver) if minor_ver < WIN7_INTRODUCED_MINOR_VER => { - println!("cargo:rustc-cfg=getrandom_windows_legacy"); - } - None => println!("cargo:warning=Couldn't detect minor version of the Rust compiler"), - _ => {} - } - } -} diff --git a/vendor/getrandom/src/backends.rs b/vendor/getrandom/src/backends.rs deleted file mode 100644 index 2c539df2..00000000 --- a/vendor/getrandom/src/backends.rs +++ /dev/null @@ -1,181 +0,0 @@ -//! System-specific implementations. -//! -//! This module should provide `fill_inner` with the signature -//! `fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error>`. -//! The function MUST fully initialize `dest` when `Ok(())` is returned. -//! The function MUST NOT ever write uninitialized bytes into `dest`, -//! regardless of what value it returns. - -cfg_if! { - if #[cfg(getrandom_backend = "custom")] { - mod custom; - pub use custom::*; - } else if #[cfg(getrandom_backend = "linux_getrandom")] { - mod getrandom; - pub use getrandom::*; - } else if #[cfg(getrandom_backend = "linux_raw")] { - mod linux_raw; - pub use linux_raw::*; - } else if #[cfg(getrandom_backend = "rdrand")] { - mod rdrand; - pub use rdrand::*; - } else if #[cfg(getrandom_backend = "rndr")] { - mod rndr; - pub use rndr::*; - } else if #[cfg(getrandom_backend = "efi_rng")] { - mod efi_rng; - pub use efi_rng::*; - } else if #[cfg(all(getrandom_backend = "wasm_js"))] { - cfg_if! { - if #[cfg(feature = "wasm_js")] { - mod wasm_js; - pub use wasm_js::*; - } else { - compile_error!(concat!( - "The \"wasm_js\" backend requires the `wasm_js` feature \ - for `getrandom`. For more information see: \ - https://docs.rs/getrandom/", env!("CARGO_PKG_VERSION"), "/#webassembly-support" - )); - } - } - } else if #[cfg(all(target_os = "linux", target_env = ""))] { - mod linux_raw; - pub use linux_raw::*; - } else if #[cfg(target_os = "espidf")] { - mod esp_idf; - pub use esp_idf::*; - } else if #[cfg(any( - target_os = "haiku", - target_os = "redox", - target_os = "nto", - target_os = "aix", - ))] { - mod use_file; - pub use use_file::*; - } else if #[cfg(any( - target_os = "macos", - target_os = "openbsd", - target_os = "vita", - target_os = "emscripten", - ))] { - mod getentropy; - pub use getentropy::*; - } else if #[cfg(any( - // Rust supports Android API level 19 (KitKat) [0] and the next upgrade targets - // level 21 (Lollipop) [1], while `getrandom(2)` was added only in - // level 23 (Marshmallow). Note that it applies only to the "old" `target_arch`es, - // RISC-V Android targets sufficiently new API level, same will apply for potential - // new Android `target_arch`es. - // [0]: https://blog.rust-lang.org/2023/01/09/android-ndk-update-r25.html - // [1]: https://github.com/rust-lang/rust/pull/120593 - all( - target_os = "android", - any( - target_arch = "aarch64", - target_arch = "arm", - target_arch = "x86", - target_arch = "x86_64", - ), - ), - // Only on these `target_arch`es Rust supports Linux kernel versions (3.2+) - // that precede the version (3.17) in which `getrandom(2)` was added: - // https://doc.rust-lang.org/stable/rustc/platform-support.html - all( - target_os = "linux", - any( - target_arch = "aarch64", - target_arch = "arm", - target_arch = "powerpc", - target_arch = "powerpc64", - target_arch = "s390x", - target_arch = "x86", - target_arch = "x86_64", - // Minimum supported Linux kernel version for MUSL targets - // is not specified explicitly (as of Rust 1.77) and they - // are used in practice to target pre-3.17 kernels. - target_env = "musl", - ), - ) - ))] { - mod use_file; - mod linux_android_with_fallback; - pub use linux_android_with_fallback::*; - } else if #[cfg(any( - target_os = "android", - target_os = "linux", - target_os = "dragonfly", - target_os = "freebsd", - target_os = "hurd", - target_os = "illumos", - target_os = "cygwin", - // Check for target_arch = "arm" to only include the 3DS. Does not - // include the Nintendo Switch (which is target_arch = "aarch64"). - all(target_os = "horizon", target_arch = "arm"), - ))] { - mod getrandom; - pub use getrandom::*; - } else if #[cfg(target_os = "solaris")] { - mod solaris; - pub use solaris::*; - } else if #[cfg(target_os = "netbsd")] { - mod netbsd; - pub use netbsd::*; - } else if #[cfg(target_os = "fuchsia")] { - mod fuchsia; - pub use fuchsia::*; - } else if #[cfg(any( - target_os = "ios", - target_os = "visionos", - target_os = "watchos", - target_os = "tvos", - ))] { - mod apple_other; - pub use apple_other::*; - } else if #[cfg(all(target_arch = "wasm32", target_os = "wasi"))] { - cfg_if! { - if #[cfg(target_env = "p1")] { - mod wasi_p1; - pub use wasi_p1::*; - } else if #[cfg(target_env = "p2")] { - mod wasi_p2; - pub use wasi_p2::*; - } else { - compile_error!( - "Unknown version of WASI (only previews 1 and 2 are supported) \ - or Rust version older than 1.80 was used" - ); - } - } - } else if #[cfg(target_os = "hermit")] { - mod hermit; - pub use hermit::*; - } else if #[cfg(target_os = "vxworks")] { - mod vxworks; - pub use vxworks::*; - } else if #[cfg(target_os = "solid_asp3")] { - mod solid; - pub use solid::*; - } else if #[cfg(all(windows, any(target_vendor = "win7", getrandom_windows_legacy)))] { - mod windows7; - pub use windows7::*; - } else if #[cfg(windows)] { - mod windows; - pub use windows::*; - } else if #[cfg(all(target_arch = "x86_64", target_env = "sgx"))] { - mod rdrand; - pub use rdrand::*; - } else if #[cfg(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "none")))] { - compile_error!(concat!( - "The wasm32-unknown-unknown targets are not supported by default; \ - you may need to enable the \"wasm_js\" configuration flag. Note \ - that enabling the `wasm_js` feature flag alone is insufficient. \ - For more information see: \ - https://docs.rs/getrandom/", env!("CARGO_PKG_VERSION"), "/#webassembly-support" - )); - } else { - compile_error!(concat!( - "target is not supported. You may need to define a custom backend see: \ - https://docs.rs/getrandom/", env!("CARGO_PKG_VERSION"), "/#custom-backend" - )); - } -} diff --git a/vendor/getrandom/src/backends/apple_other.rs b/vendor/getrandom/src/backends/apple_other.rs deleted file mode 100644 index c7b51c0e..00000000 --- a/vendor/getrandom/src/backends/apple_other.rs +++ /dev/null @@ -1,21 +0,0 @@ -//! Implementation for iOS, tvOS, and watchOS where `getentropy` is unavailable. -use crate::Error; -use core::{ffi::c_void, mem::MaybeUninit}; - -pub use crate::util::{inner_u32, inner_u64}; - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - let dst_ptr = dest.as_mut_ptr().cast::<c_void>(); - let ret = unsafe { libc::CCRandomGenerateBytes(dst_ptr, dest.len()) }; - if ret == libc::kCCSuccess { - Ok(()) - } else { - Err(Error::IOS_RANDOM_GEN) - } -} - -impl Error { - /// Call to `CCRandomGenerateBytes` failed. - pub(crate) const IOS_RANDOM_GEN: Error = Self::new_internal(10); -} diff --git a/vendor/getrandom/src/backends/custom.rs b/vendor/getrandom/src/backends/custom.rs deleted file mode 100644 index c505481a..00000000 --- a/vendor/getrandom/src/backends/custom.rs +++ /dev/null @@ -1,13 +0,0 @@ -//! An implementation which calls out to an externally defined function. -use crate::Error; -use core::mem::MaybeUninit; - -pub use crate::util::{inner_u32, inner_u64}; - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - extern "Rust" { - fn __getrandom_v03_custom(dest: *mut u8, len: usize) -> Result<(), Error>; - } - unsafe { __getrandom_v03_custom(dest.as_mut_ptr().cast(), dest.len()) } -} diff --git a/vendor/getrandom/src/backends/efi_rng.rs b/vendor/getrandom/src/backends/efi_rng.rs deleted file mode 100644 index 768c8cc8..00000000 --- a/vendor/getrandom/src/backends/efi_rng.rs +++ /dev/null @@ -1,124 +0,0 @@ -//! Implementation for UEFI using EFI_RNG_PROTOCOL -use crate::Error; -use core::{ - mem::MaybeUninit, - ptr::{self, null_mut, NonNull}, - sync::atomic::{AtomicPtr, Ordering::Relaxed}, -}; -use r_efi::{ - efi::{BootServices, Handle}, - protocols::rng, -}; - -extern crate std; - -pub use crate::util::{inner_u32, inner_u64}; - -#[cfg(not(target_os = "uefi"))] -compile_error!("`efi_rng` backend can be enabled only for UEFI targets!"); - -static RNG_PROTOCOL: AtomicPtr<rng::Protocol> = AtomicPtr::new(null_mut()); - -#[cold] -#[inline(never)] -fn init() -> Result<NonNull<rng::Protocol>, Error> { - const HANDLE_SIZE: usize = size_of::<Handle>(); - - let boot_services = std::os::uefi::env::boot_services() - .ok_or(Error::BOOT_SERVICES_UNAVAILABLE)? - .cast::<BootServices>(); - - let mut handles = [ptr::null_mut(); 16]; - // `locate_handle` operates with length in bytes - let mut buf_size = handles.len() * HANDLE_SIZE; - let mut guid = rng::PROTOCOL_GUID; - let ret = unsafe { - ((*boot_services.as_ptr()).locate_handle)( - r_efi::efi::BY_PROTOCOL, - &mut guid, - null_mut(), - &mut buf_size, - handles.as_mut_ptr(), - ) - }; - - if ret.is_error() { - return Err(Error::from_uefi_code(ret.as_usize())); - } - - let handles_len = buf_size / HANDLE_SIZE; - let handles = handles.get(..handles_len).ok_or(Error::UNEXPECTED)?; - - let system_handle = std::os::uefi::env::image_handle(); - for &handle in handles { - let mut protocol: MaybeUninit<*mut rng::Protocol> = MaybeUninit::uninit(); - - let mut protocol_guid = rng::PROTOCOL_GUID; - let ret = unsafe { - ((*boot_services.as_ptr()).open_protocol)( - handle, - &mut protocol_guid, - protocol.as_mut_ptr().cast(), - system_handle.as_ptr(), - ptr::null_mut(), - r_efi::system::OPEN_PROTOCOL_GET_PROTOCOL, - ) - }; - - let protocol = if ret.is_error() { - continue; - } else { - let protocol = unsafe { protocol.assume_init() }; - NonNull::new(protocol).ok_or(Error::UNEXPECTED)? - }; - - // Try to use the acquired protocol handle - let mut buf = [0u8; 8]; - let mut alg_guid = rng::ALGORITHM_RAW; - let ret = unsafe { - ((*protocol.as_ptr()).get_rng)( - protocol.as_ptr(), - &mut alg_guid, - buf.len(), - buf.as_mut_ptr(), - ) - }; - - if ret.is_error() { - continue; - } - - RNG_PROTOCOL.store(protocol.as_ptr(), Relaxed); - return Ok(protocol); - } - Err(Error::NO_RNG_HANDLE) -} - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - let protocol = match NonNull::new(RNG_PROTOCOL.load(Relaxed)) { - Some(p) => p, - None => init()?, - }; - - let mut alg_guid = rng::ALGORITHM_RAW; - let ret = unsafe { - ((*protocol.as_ptr()).get_rng)( - protocol.as_ptr(), - &mut alg_guid, - dest.len(), - dest.as_mut_ptr().cast::<u8>(), - ) - }; - - if ret.is_error() { - Err(Error::from_uefi_code(ret.as_usize())) - } else { - Ok(()) - } -} - -impl Error { - pub(crate) const BOOT_SERVICES_UNAVAILABLE: Error = Self::new_internal(10); - pub(crate) const NO_RNG_HANDLE: Error = Self::new_internal(11); -} diff --git a/vendor/getrandom/src/backends/esp_idf.rs b/vendor/getrandom/src/backends/esp_idf.rs deleted file mode 100644 index 4d1689dc..00000000 --- a/vendor/getrandom/src/backends/esp_idf.rs +++ /dev/null @@ -1,21 +0,0 @@ -//! Implementation for ESP-IDF -use crate::Error; -use core::{ffi::c_void, mem::MaybeUninit}; - -pub use crate::util::{inner_u32, inner_u64}; - -extern "C" { - fn esp_fill_random(buf: *mut c_void, len: usize) -> u32; -} - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - // Not that NOT enabling WiFi, BT, or the voltage noise entropy source (via `bootloader_random_enable`) - // will cause ESP-IDF to return pseudo-random numbers based on the voltage noise entropy, after the initial boot process: - // https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/system/random.html - // - // However tracking if some of these entropy sources is enabled is way too difficult to implement here - unsafe { esp_fill_random(dest.as_mut_ptr().cast(), dest.len()) }; - - Ok(()) -} diff --git a/vendor/getrandom/src/backends/fuchsia.rs b/vendor/getrandom/src/backends/fuchsia.rs deleted file mode 100644 index b5f1ade5..00000000 --- a/vendor/getrandom/src/backends/fuchsia.rs +++ /dev/null @@ -1,16 +0,0 @@ -//! Implementation for Fuchsia Zircon -use crate::Error; -use core::mem::MaybeUninit; - -pub use crate::util::{inner_u32, inner_u64}; - -#[link(name = "zircon")] -extern "C" { - fn zx_cprng_draw(buffer: *mut u8, length: usize); -} - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - unsafe { zx_cprng_draw(dest.as_mut_ptr().cast::<u8>(), dest.len()) } - Ok(()) -} diff --git a/vendor/getrandom/src/backends/getentropy.rs b/vendor/getrandom/src/backends/getentropy.rs deleted file mode 100644 index ed181f01..00000000 --- a/vendor/getrandom/src/backends/getentropy.rs +++ /dev/null @@ -1,27 +0,0 @@ -//! Implementation using getentropy(2) -//! -//! Available since: -//! - macOS 10.12 -//! - OpenBSD 5.6 -//! - Emscripten 2.0.5 -//! - vita newlib since Dec 2021 -//! -//! For these targets, we use getentropy(2) because getrandom(2) doesn't exist. -use crate::Error; -use core::{ffi::c_void, mem::MaybeUninit}; - -pub use crate::util::{inner_u32, inner_u64}; - -#[path = "../util_libc.rs"] -mod util_libc; - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - for chunk in dest.chunks_mut(256) { - let ret = unsafe { libc::getentropy(chunk.as_mut_ptr().cast::<c_void>(), chunk.len()) }; - if ret != 0 { - return Err(util_libc::last_os_error()); - } - } - Ok(()) -} diff --git a/vendor/getrandom/src/backends/getrandom.rs b/vendor/getrandom/src/backends/getrandom.rs deleted file mode 100644 index 27d5a1f5..00000000 --- a/vendor/getrandom/src/backends/getrandom.rs +++ /dev/null @@ -1,31 +0,0 @@ -//! Implementation using getrandom(2). -//! -//! Available since: -//! - Linux Kernel 3.17, Glibc 2.25, Musl 1.1.20 -//! - Android API level 23 (Marshmallow) -//! - NetBSD 10.0 -//! - FreeBSD 12.0 -//! - illumos since Dec 2018 -//! - DragonFly 5.7 -//! - Hurd Glibc 2.31 -//! - shim-3ds since Feb 2022 -//! -//! For these platforms, we always use the default pool and never set the -//! GRND_RANDOM flag to use the /dev/random pool. On Linux/Android/Hurd, using -//! GRND_RANDOM is not recommended. On NetBSD/FreeBSD/Dragonfly/3ds, it does -//! nothing. On illumos, the default pool is used to implement getentropy(2), -//! so we assume it is acceptable here. -use crate::Error; -use core::mem::MaybeUninit; - -pub use crate::util::{inner_u32, inner_u64}; - -#[path = "../util_libc.rs"] -mod util_libc; - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - util_libc::sys_fill_exact(dest, |buf| unsafe { - libc::getrandom(buf.as_mut_ptr().cast(), buf.len(), 0) - }) -} diff --git a/vendor/getrandom/src/backends/hermit.rs b/vendor/getrandom/src/backends/hermit.rs deleted file mode 100644 index 34d7cdbb..00000000 --- a/vendor/getrandom/src/backends/hermit.rs +++ /dev/null @@ -1,53 +0,0 @@ -//! Implementation for Hermit -use crate::Error; -use core::mem::MaybeUninit; - -extern "C" { - fn sys_read_entropy(buffer: *mut u8, length: usize, flags: u32) -> isize; - // Note that `sys_secure_rand32/64` are implemented using `sys_read_entropy`: - // https://github.com/hermit-os/kernel/blob/430da84/src/syscalls/entropy.rs#L62-L104 - // But this may change in future and can depend on compilation target, - // so to future-proof we use these "syscalls". - fn sys_secure_rand32(value: *mut u32) -> i32; - fn sys_secure_rand64(value: *mut u64) -> i32; -} - -#[inline] -pub fn inner_u32() -> Result<u32, Error> { - let mut res = MaybeUninit::uninit(); - let ret = unsafe { sys_secure_rand32(res.as_mut_ptr()) }; - match ret { - 0 => Ok(unsafe { res.assume_init() }), - -1 => Err(Error::UNSUPPORTED), - _ => Err(Error::UNEXPECTED), - } -} - -#[inline] -pub fn inner_u64() -> Result<u64, Error> { - let mut res = MaybeUninit::uninit(); - let ret = unsafe { sys_secure_rand64(res.as_mut_ptr()) }; - match ret { - 0 => Ok(unsafe { res.assume_init() }), - -1 => Err(Error::UNSUPPORTED), - _ => Err(Error::UNEXPECTED), - } -} - -#[inline] -pub fn fill_inner(mut dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - while !dest.is_empty() { - let res = unsafe { sys_read_entropy(dest.as_mut_ptr().cast::<u8>(), dest.len(), 0) }; - match res { - res if res > 0 => { - let len = usize::try_from(res).map_err(|_| Error::UNEXPECTED)?; - dest = dest.get_mut(len..).ok_or(Error::UNEXPECTED)?; - } - code => { - let code = i32::try_from(code).map_err(|_| Error::UNEXPECTED)?; - return Err(Error::from_neg_error_code(code)); - } - } - } - Ok(()) -} diff --git a/vendor/getrandom/src/backends/linux_android_with_fallback.rs b/vendor/getrandom/src/backends/linux_android_with_fallback.rs deleted file mode 100644 index 2ad8f0a4..00000000 --- a/vendor/getrandom/src/backends/linux_android_with_fallback.rs +++ /dev/null @@ -1,101 +0,0 @@ -//! Implementation for Linux / Android with `/dev/urandom` fallback -use super::use_file; -use crate::Error; -use core::{ - ffi::c_void, - mem::{transmute, MaybeUninit}, - ptr::NonNull, - sync::atomic::{AtomicPtr, Ordering}, -}; -use use_file::util_libc; - -pub use crate::util::{inner_u32, inner_u64}; - -type GetRandomFn = unsafe extern "C" fn(*mut c_void, libc::size_t, libc::c_uint) -> libc::ssize_t; - -/// Sentinel value which indicates that `libc::getrandom` either not available, -/// or not supported by kernel. -const NOT_AVAILABLE: NonNull<c_void> = unsafe { NonNull::new_unchecked(usize::MAX as *mut c_void) }; - -static GETRANDOM_FN: AtomicPtr<c_void> = AtomicPtr::new(core::ptr::null_mut()); - -#[cold] -#[inline(never)] -fn init() -> NonNull<c_void> { - // Use static linking to `libc::getrandom` on MUSL targets and `dlsym` everywhere else - #[cfg(not(target_env = "musl"))] - let raw_ptr = { - static NAME: &[u8] = b"getrandom\0"; - let name_ptr = NAME.as_ptr().cast::<libc::c_char>(); - unsafe { libc::dlsym(libc::RTLD_DEFAULT, name_ptr) } - }; - #[cfg(target_env = "musl")] - let raw_ptr = { - let fptr: GetRandomFn = libc::getrandom; - unsafe { transmute::<GetRandomFn, *mut c_void>(fptr) } - }; - - let res_ptr = match NonNull::new(raw_ptr) { - Some(fptr) => { - let getrandom_fn = unsafe { transmute::<NonNull<c_void>, GetRandomFn>(fptr) }; - let dangling_ptr = NonNull::dangling().as_ptr(); - // Check that `getrandom` syscall is supported by kernel - let res = unsafe { getrandom_fn(dangling_ptr, 0, 0) }; - if cfg!(getrandom_test_linux_fallback) { - NOT_AVAILABLE - } else if res.is_negative() { - match util_libc::last_os_error().raw_os_error() { - Some(libc::ENOSYS) => NOT_AVAILABLE, // No kernel support - // The fallback on EPERM is intentionally not done on Android since this workaround - // seems to be needed only for specific Linux-based products that aren't based - // on Android. See https://github.com/rust-random/getrandom/issues/229. - #[cfg(target_os = "linux")] - Some(libc::EPERM) => NOT_AVAILABLE, // Blocked by seccomp - _ => fptr, - } - } else { - fptr - } - } - None => NOT_AVAILABLE, - }; - - #[cfg(getrandom_test_linux_without_fallback)] - if res_ptr == NOT_AVAILABLE { - panic!("Fallback is triggered with enabled `getrandom_test_linux_without_fallback`") - } - - GETRANDOM_FN.store(res_ptr.as_ptr(), Ordering::Release); - res_ptr -} - -// Prevent inlining of the fallback implementation -#[inline(never)] -fn use_file_fallback(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - use_file::fill_inner(dest) -} - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - // Despite being only a single atomic variable, we still cannot always use - // Ordering::Relaxed, as we need to make sure a successful call to `init` - // is "ordered before" any data read through the returned pointer (which - // occurs when the function is called). Our implementation mirrors that of - // the one in libstd, meaning that the use of non-Relaxed operations is - // probably unnecessary. - let raw_ptr = GETRANDOM_FN.load(Ordering::Acquire); - let fptr = match NonNull::new(raw_ptr) { - Some(p) => p, - None => init(), - }; - - if fptr == NOT_AVAILABLE { - use_file_fallback(dest) - } else { - // note: `transmute` is currently the only way to convert a pointer into a function reference - let getrandom_fn = unsafe { transmute::<NonNull<c_void>, GetRandomFn>(fptr) }; - util_libc::sys_fill_exact(dest, |buf| unsafe { - getrandom_fn(buf.as_mut_ptr().cast(), buf.len(), 0) - }) - } -} diff --git a/vendor/getrandom/src/backends/linux_raw.rs b/vendor/getrandom/src/backends/linux_raw.rs deleted file mode 100644 index 4a59eef0..00000000 --- a/vendor/getrandom/src/backends/linux_raw.rs +++ /dev/null @@ -1,136 +0,0 @@ -//! Implementation for Linux / Android using `asm!`-based syscalls. -use crate::{Error, MaybeUninit}; - -pub use crate::util::{inner_u32, inner_u64}; - -#[cfg(not(any(target_os = "android", target_os = "linux")))] -compile_error!("`linux_raw` backend can be enabled only for Linux/Android targets!"); - -#[allow(non_upper_case_globals)] -unsafe fn getrandom_syscall(buf: *mut u8, buflen: usize, flags: u32) -> isize { - let r0; - - // Based on `rustix` and `linux-raw-sys` code. - cfg_if! { - if #[cfg(target_arch = "arm")] { - const __NR_getrandom: u32 = 384; - // In thumb-mode, r7 is the frame pointer and is not permitted to be used in - // an inline asm operand, so we have to use a different register and copy it - // into r7 inside the inline asm. - // Theoretically, we could detect thumb mode in the build script, but several - // register moves are cheap enough compared to the syscall cost, so we do not - // bother with it. - core::arch::asm!( - "mov {tmp}, r7", - "mov r7, {nr}", - "svc 0", - "mov r7, {tmp}", - nr = const __NR_getrandom, - tmp = out(reg) _, - inlateout("r0") buf => r0, - in("r1") buflen, - in("r2") flags, - options(nostack, preserves_flags) - ); - } else if #[cfg(target_arch = "aarch64")] { - const __NR_getrandom: u32 = 278; - core::arch::asm!( - "svc 0", - in("x8") __NR_getrandom, - inlateout("x0") buf => r0, - in("x1") buflen, - in("x2") flags, - options(nostack, preserves_flags) - ); - } else if #[cfg(target_arch = "loongarch64")] { - const __NR_getrandom: u32 = 278; - core::arch::asm!( - "syscall 0", - in("$a7") __NR_getrandom, - inlateout("$a0") buf => r0, - in("$a1") buflen, - in("$a2") flags, - options(nostack, preserves_flags) - ); - } else if #[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))] { - const __NR_getrandom: u32 = 278; - core::arch::asm!( - "ecall", - in("a7") __NR_getrandom, - inlateout("a0") buf => r0, - in("a1") buflen, - in("a2") flags, - options(nostack, preserves_flags) - ); - } else if #[cfg(target_arch = "s390x")] { - const __NR_getrandom: u32 = 349; - core::arch::asm!( - "svc 0", - in("r1") __NR_getrandom, - inlateout("r2") buf => r0, - in("r3") buflen, - in("r4") flags, - options(nostack, preserves_flags) - ); - } else if #[cfg(target_arch = "x86")] { - const __NR_getrandom: u32 = 355; - // `int 0x80` is famously slow, but implementing vDSO is too complex - // and `sysenter`/`syscall` have their own portability issues, - // so we use the simple "legacy" way of doing syscalls. - core::arch::asm!( - "int $$0x80", - in("eax") __NR_getrandom, - in("ebx") buf, - in("ecx") buflen, - in("edx") flags, - lateout("eax") r0, - options(nostack, preserves_flags) - ); - } else if #[cfg(target_arch = "x86_64")] { - #[cfg(target_pointer_width = "64")] - const __NR_getrandom: u32 = 318; - #[cfg(target_pointer_width = "32")] - const __NR_getrandom: u32 = (1 << 30) + 318; - - core::arch::asm!( - "syscall", - in("rax") __NR_getrandom, - in("rdi") buf, - in("rsi") buflen, - in("rdx") flags, - lateout("rax") r0, - lateout("rcx") _, - lateout("r11") _, - options(nostack, preserves_flags) - ); - } else { - compile_error!("`linux_raw` backend does not support this target arch"); - } - } - - r0 -} - -#[inline] -pub fn fill_inner(mut dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - // Value of this error code is stable across all target arches. - const EINTR: isize = -4; - - loop { - let ret = unsafe { getrandom_syscall(dest.as_mut_ptr().cast(), dest.len(), 0) }; - match usize::try_from(ret) { - Ok(0) => return Err(Error::UNEXPECTED), - Ok(len) => { - dest = dest.get_mut(len..).ok_or(Error::UNEXPECTED)?; - if dest.is_empty() { - return Ok(()); - } - } - Err(_) if ret == EINTR => continue, - Err(_) => { - let code = i32::try_from(ret).map_err(|_| Error::UNEXPECTED)?; - return Err(Error::from_neg_error_code(code)); - } - } - } -} diff --git a/vendor/getrandom/src/backends/netbsd.rs b/vendor/getrandom/src/backends/netbsd.rs deleted file mode 100644 index f228a8b1..00000000 --- a/vendor/getrandom/src/backends/netbsd.rs +++ /dev/null @@ -1,78 +0,0 @@ -//! Implementation for NetBSD -//! -//! `getrandom(2)` was introduced in NetBSD 10. To support older versions we -//! implement our own weak linkage to it, and provide a fallback based on the -//! KERN_ARND sysctl. -use crate::Error; -use core::{ - cmp, - ffi::c_void, - mem::{self, MaybeUninit}, - ptr, - sync::atomic::{AtomicPtr, Ordering}, -}; - -pub use crate::util::{inner_u32, inner_u64}; - -#[path = "../util_libc.rs"] -mod util_libc; - -unsafe extern "C" fn polyfill_using_kern_arand( - buf: *mut c_void, - buflen: libc::size_t, - flags: libc::c_uint, -) -> libc::ssize_t { - debug_assert_eq!(flags, 0); - - const MIB_LEN: libc::c_uint = 2; - static MIB: [libc::c_int; MIB_LEN as usize] = [libc::CTL_KERN, libc::KERN_ARND]; - - // NetBSD will only return up to 256 bytes at a time, and - // older NetBSD kernels will fail on longer buffers. - let mut len = cmp::min(buflen, 256); - let ret = unsafe { libc::sysctl(MIB.as_ptr(), MIB_LEN, buf, &mut len, ptr::null(), 0) }; - - match ret { - 0 if len <= 256 => libc::ssize_t::try_from(len).expect("len is in the range of 0..=256"), - -1 => -1, - // Zero return result will be converted into `Error::UNEXPECTED` by `sys_fill_exact` - _ => 0, - } -} - -type GetRandomFn = unsafe extern "C" fn(*mut c_void, libc::size_t, libc::c_uint) -> libc::ssize_t; - -static GETRANDOM: AtomicPtr<c_void> = AtomicPtr::new(ptr::null_mut()); - -#[cold] -#[inline(never)] -fn init() -> *mut c_void { - static NAME: &[u8] = b"getrandom\0"; - let name_ptr = NAME.as_ptr().cast::<libc::c_char>(); - let mut ptr = unsafe { libc::dlsym(libc::RTLD_DEFAULT, name_ptr) }; - if ptr.is_null() || cfg!(getrandom_test_netbsd_fallback) { - // Verify `polyfill_using_kern_arand` has the right signature. - const POLYFILL: GetRandomFn = polyfill_using_kern_arand; - ptr = POLYFILL as *mut c_void; - } - GETRANDOM.store(ptr, Ordering::Release); - ptr -} - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - // Despite being only a single atomic variable, we still cannot always use - // Ordering::Relaxed, as we need to make sure a successful call to `init` - // is "ordered before" any data read through the returned pointer (which - // occurs when the function is called). Our implementation mirrors that of - // the one in libstd, meaning that the use of non-Relaxed operations is - // probably unnecessary. - let mut fptr = GETRANDOM.load(Ordering::Acquire); - if fptr.is_null() { - fptr = init(); - } - let fptr = unsafe { mem::transmute::<*mut c_void, GetRandomFn>(fptr) }; - util_libc::sys_fill_exact(dest, |buf| unsafe { - fptr(buf.as_mut_ptr().cast::<c_void>(), buf.len(), 0) - }) -} diff --git a/vendor/getrandom/src/backends/rdrand.rs b/vendor/getrandom/src/backends/rdrand.rs deleted file mode 100644 index 609fcc38..00000000 --- a/vendor/getrandom/src/backends/rdrand.rs +++ /dev/null @@ -1,182 +0,0 @@ -//! RDRAND backend for x86(-64) targets -use crate::{util::slice_as_uninit, Error}; -use core::mem::{size_of, MaybeUninit}; - -#[path = "../lazy.rs"] -mod lazy; - -#[cfg(not(any(target_arch = "x86_64", target_arch = "x86")))] -compile_error!("`rdrand` backend can be enabled only for x86 and x86-64 targets!"); - -cfg_if! { - if #[cfg(target_arch = "x86_64")] { - use core::arch::x86_64 as arch; - use arch::_rdrand64_step as rdrand_step; - type Word = u64; - } else if #[cfg(target_arch = "x86")] { - use core::arch::x86 as arch; - use arch::_rdrand32_step as rdrand_step; - type Word = u32; - } -} - -static RDRAND_GOOD: lazy::LazyBool = lazy::LazyBool::new(); - -// Recommendation from "Intel® Digital Random Number Generator (DRNG) Software -// Implementation Guide" - Section 5.2.1 and "Intel® 64 and IA-32 Architectures -// Software Developer’s Manual" - Volume 1 - Section 7.3.17.1. -const RETRY_LIMIT: usize = 10; - -#[target_feature(enable = "rdrand")] -unsafe fn rdrand() -> Option<Word> { - for _ in 0..RETRY_LIMIT { - let mut val = 0; - if rdrand_step(&mut val) == 1 { - return Some(val); - } - } - None -} - -// "rdrand" target feature requires "+rdrand" flag, see https://github.com/rust-lang/rust/issues/49653. -#[cfg(all(target_env = "sgx", not(target_feature = "rdrand")))] -compile_error!( - "SGX targets require 'rdrand' target feature. Enable by using -C target-feature=+rdrand." -); - -// Run a small self-test to make sure we aren't repeating values -// Adapted from Linux's test in arch/x86/kernel/cpu/rdrand.c -// Fails with probability < 2^(-90) on 32-bit systems -#[target_feature(enable = "rdrand")] -unsafe fn self_test() -> bool { - // On AMD, RDRAND returns 0xFF...FF on failure, count it as a collision. - let mut prev = !0; // TODO(MSRV 1.43): Move to usize::MAX - let mut fails = 0; - for _ in 0..8 { - match rdrand() { - Some(val) if val == prev => fails += 1, - Some(val) => prev = val, - None => return false, - }; - } - fails <= 2 -} - -fn is_rdrand_good() -> bool { - #[cfg(not(target_feature = "rdrand"))] - { - // SAFETY: All Rust x86 targets are new enough to have CPUID, and we - // check that leaf 1 is supported before using it. - let cpuid0 = unsafe { arch::__cpuid(0) }; - if cpuid0.eax < 1 { - return false; - } - let cpuid1 = unsafe { arch::__cpuid(1) }; - - let vendor_id = [ - cpuid0.ebx.to_le_bytes(), - cpuid0.edx.to_le_bytes(), - cpuid0.ecx.to_le_bytes(), - ]; - if vendor_id == [*b"Auth", *b"enti", *b"cAMD"] { - let mut family = (cpuid1.eax >> 8) & 0xF; - if family == 0xF { - family += (cpuid1.eax >> 20) & 0xFF; - } - // AMD CPUs families before 17h (Zen) sometimes fail to set CF when - // RDRAND fails after suspend. Don't use RDRAND on those families. - // See https://bugzilla.redhat.com/show_bug.cgi?id=1150286 - if family < 0x17 { - return false; - } - } - - const RDRAND_FLAG: u32 = 1 << 30; - if cpuid1.ecx & RDRAND_FLAG == 0 { - return false; - } - } - - // SAFETY: We have already checked that rdrand is available. - unsafe { self_test() } -} - -// TODO: make this function safe when we have feature(target_feature_11) -#[target_feature(enable = "rdrand")] -unsafe fn rdrand_exact(dest: &mut [MaybeUninit<u8>]) -> Option<()> { - // We use chunks_exact_mut instead of chunks_mut as it allows almost all - // calls to memcpy to be elided by the compiler. - let mut chunks = dest.chunks_exact_mut(size_of::<Word>()); - for chunk in chunks.by_ref() { - let src = rdrand()?.to_ne_bytes(); - chunk.copy_from_slice(slice_as_uninit(&src)); - } - - let tail = chunks.into_remainder(); - let n = tail.len(); - if n > 0 { - let src = rdrand()?.to_ne_bytes(); - tail.copy_from_slice(slice_as_uninit(&src[..n])); - } - Some(()) -} - -#[cfg(target_arch = "x86_64")] -#[target_feature(enable = "rdrand")] -unsafe fn rdrand_u32() -> Option<u32> { - rdrand().map(crate::util::truncate) -} - -#[cfg(target_arch = "x86_64")] -#[target_feature(enable = "rdrand")] -unsafe fn rdrand_u64() -> Option<u64> { - rdrand() -} - -#[cfg(target_arch = "x86")] -#[target_feature(enable = "rdrand")] -unsafe fn rdrand_u32() -> Option<u32> { - rdrand() -} - -#[cfg(target_arch = "x86")] -#[target_feature(enable = "rdrand")] -unsafe fn rdrand_u64() -> Option<u64> { - let a = rdrand()?; - let b = rdrand()?; - Some((u64::from(a) << 32) | u64::from(b)) -} - -#[inline] -pub fn inner_u32() -> Result<u32, Error> { - if !RDRAND_GOOD.unsync_init(is_rdrand_good) { - return Err(Error::NO_RDRAND); - } - // SAFETY: After this point, we know rdrand is supported. - unsafe { rdrand_u32() }.ok_or(Error::FAILED_RDRAND) -} - -#[inline] -pub fn inner_u64() -> Result<u64, Error> { - if !RDRAND_GOOD.unsync_init(is_rdrand_good) { - return Err(Error::NO_RDRAND); - } - // SAFETY: After this point, we know rdrand is supported. - unsafe { rdrand_u64() }.ok_or(Error::FAILED_RDRAND) -} - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - if !RDRAND_GOOD.unsync_init(is_rdrand_good) { - return Err(Error::NO_RDRAND); - } - // SAFETY: After this point, we know rdrand is supported. - unsafe { rdrand_exact(dest) }.ok_or(Error::FAILED_RDRAND) -} - -impl Error { - /// RDRAND instruction failed due to a hardware issue. - pub(crate) const FAILED_RDRAND: Error = Self::new_internal(10); - /// RDRAND instruction unsupported on this target. - pub(crate) const NO_RDRAND: Error = Self::new_internal(11); -} diff --git a/vendor/getrandom/src/backends/rndr.rs b/vendor/getrandom/src/backends/rndr.rs deleted file mode 100644 index eea741a2..00000000 --- a/vendor/getrandom/src/backends/rndr.rs +++ /dev/null @@ -1,145 +0,0 @@ -//! RNDR register backend for aarch64 targets -//! -//! Arm Architecture Reference Manual for A-profile architecture: -//! ARM DDI 0487K.a, ID032224, D23.2.147 RNDR, Random Number -use crate::{ - util::{slice_as_uninit, truncate}, - Error, -}; -use core::arch::asm; -use core::mem::{size_of, MaybeUninit}; - -#[cfg(not(target_arch = "aarch64"))] -compile_error!("the `rndr` backend can be enabled only for AArch64 targets!"); - -const RETRY_LIMIT: usize = 5; - -/// Read a random number from the aarch64 RNDR register -/// -/// Callers must ensure that FEAT_RNG is available on the system -/// The function assumes that the RNDR register is available -/// If it fails to read a random number, it will retry up to 5 times -/// After 5 failed reads the function will return `None` -#[target_feature(enable = "rand")] -unsafe fn rndr() -> Option<u64> { - for _ in 0..RETRY_LIMIT { - let mut x: u64; - let mut nzcv: u64; - - // AArch64 RNDR register is accessible by s3_3_c2_c4_0 - asm!( - "mrs {x}, RNDR", - "mrs {nzcv}, NZCV", - x = out(reg) x, - nzcv = out(reg) nzcv, - ); - - // If the hardware returns a genuine random number, PSTATE.NZCV is set to 0b0000 - if nzcv == 0 { - return Some(x); - } - } - - None -} - -#[target_feature(enable = "rand")] -unsafe fn rndr_fill(dest: &mut [MaybeUninit<u8>]) -> Option<()> { - let mut chunks = dest.chunks_exact_mut(size_of::<u64>()); - for chunk in chunks.by_ref() { - let src = rndr()?.to_ne_bytes(); - chunk.copy_from_slice(slice_as_uninit(&src)); - } - - let tail = chunks.into_remainder(); - let n = tail.len(); - if n > 0 { - let src = rndr()?.to_ne_bytes(); - tail.copy_from_slice(slice_as_uninit(&src[..n])); - } - Some(()) -} - -#[cfg(target_feature = "rand")] -fn is_rndr_available() -> bool { - true -} - -#[cfg(not(target_feature = "rand"))] -fn is_rndr_available() -> bool { - #[path = "../lazy.rs"] - mod lazy; - static RNDR_GOOD: lazy::LazyBool = lazy::LazyBool::new(); - - cfg_if::cfg_if! { - if #[cfg(feature = "std")] { - extern crate std; - RNDR_GOOD.unsync_init(|| std::arch::is_aarch64_feature_detected!("rand")) - } else if #[cfg(target_os = "linux")] { - /// Check whether FEAT_RNG is available on the system - /// - /// Requires the caller either be running in EL1 or be on a system supporting MRS - /// emulation. Due to the above, the implementation is currently restricted to Linux. - /// - /// Relying on runtime detection bumps minimum supported Linux kernel version to 4.11. - fn mrs_check() -> bool { - let mut id_aa64isar0: u64; - - // If FEAT_RNG is implemented, ID_AA64ISAR0_EL1.RNDR (bits 60-63) are 0b0001 - // This is okay to do from EL0 in Linux because Linux will emulate MRS as per - // https://docs.kernel.org/arch/arm64/cpu-feature-registers.html - unsafe { - asm!( - "mrs {id}, ID_AA64ISAR0_EL1", - id = out(reg) id_aa64isar0, - ); - } - - (id_aa64isar0 >> 60) & 0xf >= 1 - } - - RNDR_GOOD.unsync_init(mrs_check) - } else { - compile_error!( - "RNDR `no_std` runtime detection is currently supported only on Linux targets. \ - Either enable the `std` crate feature, or `rand` target feature at compile time." - ); - } - } -} - -#[inline] -pub fn inner_u32() -> Result<u32, Error> { - if !is_rndr_available() { - return Err(Error::RNDR_NOT_AVAILABLE); - } - // SAFETY: after this point, we know the `rand` target feature is enabled - let res = unsafe { rndr() }; - res.map(truncate).ok_or(Error::RNDR_FAILURE) -} - -#[inline] -pub fn inner_u64() -> Result<u64, Error> { - if !is_rndr_available() { - return Err(Error::RNDR_NOT_AVAILABLE); - } - // SAFETY: after this point, we know the `rand` target feature is enabled - let res = unsafe { rndr() }; - res.ok_or(Error::RNDR_FAILURE) -} - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - if !is_rndr_available() { - return Err(Error::RNDR_NOT_AVAILABLE); - } - // SAFETY: after this point, we know the `rand` target feature is enabled - unsafe { rndr_fill(dest).ok_or(Error::RNDR_FAILURE) } -} - -impl Error { - /// RNDR register read failed due to a hardware issue. - pub(crate) const RNDR_FAILURE: Error = Self::new_internal(10); - /// RNDR register is not supported on this target. - pub(crate) const RNDR_NOT_AVAILABLE: Error = Self::new_internal(11); -} diff --git a/vendor/getrandom/src/backends/solaris.rs b/vendor/getrandom/src/backends/solaris.rs deleted file mode 100644 index c27f91a5..00000000 --- a/vendor/getrandom/src/backends/solaris.rs +++ /dev/null @@ -1,42 +0,0 @@ -//! Solaris implementation using getrandom(2). -//! -//! While getrandom(2) has been available since Solaris 11.3, it has a few -//! quirks not present on other OSes. First, on Solaris 11.3, calls will always -//! fail if bufsz > 1024. Second, it will always either fail or completely fill -//! the buffer (returning bufsz). Third, error is indicated by returning 0, -//! rather than by returning -1. Finally, "if GRND_RANDOM is not specified -//! then getrandom(2) is always a non blocking call". This _might_ imply that -//! in early-boot scenarios with low entropy, getrandom(2) will not properly -//! block. To be safe, we set GRND_RANDOM, mirroring the man page examples. -//! -//! For more information, see the man page linked in lib.rs and this blog post: -//! https://blogs.oracle.com/solaris/post/solaris-new-system-calls-getentropy2-and-getrandom2 -//! which also explains why this crate should not use getentropy(2). -use crate::Error; -use core::{ffi::c_void, mem::MaybeUninit}; - -pub use crate::util::{inner_u32, inner_u64}; - -#[path = "../util_libc.rs"] -mod util_libc; - -const MAX_BYTES: usize = 1024; - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - for chunk in dest.chunks_mut(MAX_BYTES) { - let ptr = chunk.as_mut_ptr().cast::<c_void>(); - let ret = unsafe { libc::getrandom(ptr, chunk.len(), libc::GRND_RANDOM) }; - // In case the man page has a typo, we also check for negative ret. - // If getrandom(2) succeeds, it should have completely filled chunk. - match usize::try_from(ret) { - // Good. Keep going. - Ok(ret) if ret == chunk.len() => {} - // The syscall failed. - Ok(0) => return Err(util_libc::last_os_error()), - // All other cases should be impossible. - _ => return Err(Error::UNEXPECTED), - } - } - Ok(()) -} diff --git a/vendor/getrandom/src/backends/solid.rs b/vendor/getrandom/src/backends/solid.rs deleted file mode 100644 index caa773f8..00000000 --- a/vendor/getrandom/src/backends/solid.rs +++ /dev/null @@ -1,19 +0,0 @@ -//! Implementation for SOLID -use crate::Error; -use core::mem::MaybeUninit; - -pub use crate::util::{inner_u32, inner_u64}; - -extern "C" { - pub fn SOLID_RNG_SampleRandomBytes(buffer: *mut u8, length: usize) -> i32; -} - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - let ret = unsafe { SOLID_RNG_SampleRandomBytes(dest.as_mut_ptr().cast::<u8>(), dest.len()) }; - if ret >= 0 { - Ok(()) - } else { - Err(Error::from_neg_error_code(ret)) - } -} diff --git a/vendor/getrandom/src/backends/use_file.rs b/vendor/getrandom/src/backends/use_file.rs deleted file mode 100644 index 7b48d433..00000000 --- a/vendor/getrandom/src/backends/use_file.rs +++ /dev/null @@ -1,234 +0,0 @@ -//! Implementations that just need to read from a file -use crate::Error; -use core::{ - ffi::c_void, - mem::MaybeUninit, - sync::atomic::{AtomicI32, Ordering}, -}; - -#[cfg(not(any(target_os = "android", target_os = "linux")))] -pub use crate::util::{inner_u32, inner_u64}; - -#[path = "../util_libc.rs"] -pub(super) mod util_libc; - -/// For all platforms, we use `/dev/urandom` rather than `/dev/random`. -/// For more information see the linked man pages in lib.rs. -/// - On Linux, "/dev/urandom is preferred and sufficient in all use cases". -/// - On Redox, only /dev/urandom is provided. -/// - On AIX, /dev/urandom will "provide cryptographically secure output". -/// - On Haiku and QNX Neutrino they are identical. -const FILE_PATH: &[u8] = b"/dev/urandom\0"; - -// File descriptor is a "nonnegative integer", so we can safely use negative sentinel values. -const FD_UNINIT: libc::c_int = -1; -const FD_ONGOING_INIT: libc::c_int = -2; - -// In theory `libc::c_int` could be something other than `i32`, but for the -// targets we currently support that use `use_file`, it is always `i32`. -// If/when we add support for a target where that isn't the case, we may -// need to use a different atomic type or make other accomodations. The -// compiler will let us know if/when that is the case, because the -// `FD.store(fd)` would fail to compile. -// -// The opening of the file, by libc/libstd/etc. may write some unknown -// state into in-process memory. (Such state may include some sanitizer -// bookkeeping, or we might be operating in a unikernal-like environment -// where all the "kernel" file descriptor bookkeeping is done in our -// process.) `get_fd_locked` stores into FD using `Ordering::Release` to -// ensure any such state is synchronized. `get_fd` loads from `FD` with -// `Ordering::Acquire` to synchronize with it. -static FD: AtomicI32 = AtomicI32::new(FD_UNINIT); - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - let mut fd = FD.load(Ordering::Acquire); - if fd == FD_UNINIT || fd == FD_ONGOING_INIT { - fd = open_or_wait()?; - } - util_libc::sys_fill_exact(dest, |buf| unsafe { - libc::read(fd, buf.as_mut_ptr().cast::<c_void>(), buf.len()) - }) -} - -/// Open a file in read-only mode. -/// -/// # Panics -/// If `path` does not contain any zeros. -// TODO: Move `path` to `CStr` and use `CStr::from_bytes_until_nul` (MSRV 1.69) -// or C-string literals (MSRV 1.77) for statics -fn open_readonly(path: &[u8]) -> Result<libc::c_int, Error> { - assert!(path.contains(&0)); - loop { - let fd = unsafe { - libc::open( - path.as_ptr().cast::<libc::c_char>(), - libc::O_RDONLY | libc::O_CLOEXEC, - ) - }; - if fd >= 0 { - return Ok(fd); - } - let err = util_libc::last_os_error(); - // We should try again if open() was interrupted. - if err.raw_os_error() != Some(libc::EINTR) { - return Err(err); - } - } -} - -#[cold] -#[inline(never)] -fn open_or_wait() -> Result<libc::c_int, Error> { - loop { - match FD.load(Ordering::Acquire) { - FD_UNINIT => { - let res = FD.compare_exchange_weak( - FD_UNINIT, - FD_ONGOING_INIT, - Ordering::AcqRel, - Ordering::Relaxed, - ); - if res.is_ok() { - break; - } - } - FD_ONGOING_INIT => sync::wait(), - fd => return Ok(fd), - } - } - - let res = open_fd(); - let val = match res { - Ok(fd) => fd, - Err(_) => FD_UNINIT, - }; - FD.store(val, Ordering::Release); - - // On non-Linux targets `wait` is just 1 ms sleep, - // so we don't need any explicit wake up in addition - // to updating value of `FD`. - #[cfg(any(target_os = "android", target_os = "linux"))] - sync::wake(); - - res -} - -fn open_fd() -> Result<libc::c_int, Error> { - #[cfg(any(target_os = "android", target_os = "linux"))] - sync::wait_until_rng_ready()?; - let fd = open_readonly(FILE_PATH)?; - debug_assert!(fd >= 0); - Ok(fd) -} - -#[cfg(not(any(target_os = "android", target_os = "linux")))] -mod sync { - /// Sleep 1 ms before checking `FD` again. - /// - /// On non-Linux targets the critical section only opens file, - /// which should not block, so in the unlikely contended case, - /// we can sleep-wait for the opening operation to finish. - pub(super) fn wait() { - let rqtp = libc::timespec { - tv_sec: 0, - tv_nsec: 1_000_000, - }; - let mut rmtp = libc::timespec { - tv_sec: 0, - tv_nsec: 0, - }; - // We do not care if sleep gets interrupted, so the return value is ignored - unsafe { - libc::nanosleep(&rqtp, &mut rmtp); - } - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -mod sync { - use super::{open_readonly, util_libc::last_os_error, Error, FD, FD_ONGOING_INIT}; - - /// Wait for atomic `FD` to change value from `FD_ONGOING_INIT` to something else. - /// - /// Futex syscall with `FUTEX_WAIT` op puts the current thread to sleep - /// until futex syscall with `FUTEX_WAKE` op gets executed for `FD`. - /// - /// For more information read: https://www.man7.org/linux/man-pages/man2/futex.2.html - pub(super) fn wait() { - let op = libc::FUTEX_WAIT | libc::FUTEX_PRIVATE_FLAG; - let timeout_ptr = core::ptr::null::<libc::timespec>(); - let ret = unsafe { libc::syscall(libc::SYS_futex, &FD, op, FD_ONGOING_INIT, timeout_ptr) }; - // FUTEX_WAIT should return either 0 or EAGAIN error - debug_assert!({ - match ret { - 0 => true, - -1 => last_os_error().raw_os_error() == Some(libc::EAGAIN), - _ => false, - } - }); - } - - /// Wake up all threads which wait for value of atomic `FD` to change. - pub(super) fn wake() { - let op = libc::FUTEX_WAKE | libc::FUTEX_PRIVATE_FLAG; - let ret = unsafe { libc::syscall(libc::SYS_futex, &FD, op, libc::INT_MAX) }; - debug_assert!(ret >= 0); - } - - // Polls /dev/random to make sure it is ok to read from /dev/urandom. - // - // Polling avoids draining the estimated entropy from /dev/random; - // short-lived processes reading even a single byte from /dev/random could - // be problematic if they are being executed faster than entropy is being - // collected. - // - // OTOH, reading a byte instead of polling is more compatible with - // sandboxes that disallow `poll()` but which allow reading /dev/random, - // e.g. sandboxes that assume that `poll()` is for network I/O. This way, - // fewer applications will have to insert pre-sandbox-initialization logic. - // Often (blocking) file I/O is not allowed in such early phases of an - // application for performance and/or security reasons. - // - // It is hard to write a sandbox policy to support `libc::poll()` because - // it may invoke the `poll`, `ppoll`, `ppoll_time64` (since Linux 5.1, with - // newer versions of glibc), and/or (rarely, and probably only on ancient - // systems) `select`. depending on the libc implementation (e.g. glibc vs - // musl), libc version, potentially the kernel version at runtime, and/or - // the target architecture. - // - // BoringSSL and libstd don't try to protect against insecure output from - // `/dev/urandom'; they don't open `/dev/random` at all. - // - // OpenSSL uses `libc::select()` unless the `dev/random` file descriptor - // is too large; if it is too large then it does what we do here. - // - // libsodium uses `libc::poll` similarly to this. - pub(super) fn wait_until_rng_ready() -> Result<(), Error> { - let fd = open_readonly(b"/dev/random\0")?; - let mut pfd = libc::pollfd { - fd, - events: libc::POLLIN, - revents: 0, - }; - - let res = loop { - // A negative timeout means an infinite timeout. - let res = unsafe { libc::poll(&mut pfd, 1, -1) }; - if res >= 0 { - // We only used one fd, and cannot timeout. - debug_assert_eq!(res, 1); - break Ok(()); - } - let err = last_os_error(); - // Assuming that `poll` is called correctly, - // on Linux it can return only EINTR and ENOMEM errors. - match err.raw_os_error() { - Some(libc::EINTR) => continue, - _ => break Err(err), - } - }; - unsafe { libc::close(fd) }; - res - } -} diff --git a/vendor/getrandom/src/backends/vxworks.rs b/vendor/getrandom/src/backends/vxworks.rs deleted file mode 100644 index 5f5e6773..00000000 --- a/vendor/getrandom/src/backends/vxworks.rs +++ /dev/null @@ -1,54 +0,0 @@ -//! Implementation for VxWorks -use crate::Error; -use core::{ - cmp::Ordering::{Equal, Greater, Less}, - mem::MaybeUninit, - sync::atomic::{AtomicBool, Ordering::Relaxed}, -}; - -#[path = "../util_libc.rs"] -mod util_libc; - -pub use crate::util::{inner_u32, inner_u64}; - -static RNG_INIT: AtomicBool = AtomicBool::new(false); - -#[cold] -fn init() -> Result<(), Error> { - let ret = unsafe { libc::randSecure() }; - match ret.cmp(&0) { - Greater => RNG_INIT.store(true, Relaxed), - Equal => unsafe { - libc::usleep(10); - }, - Less => return Err(Error::VXWORKS_RAND_SECURE), - } - Ok(()) -} - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - while !RNG_INIT.load(Relaxed) { - init()?; - } - - // Prevent overflow of i32 - let chunk_size = usize::try_from(i32::MAX).expect("VxWorks does not support 16-bit targets"); - for chunk in dest.chunks_mut(chunk_size) { - let chunk_len: libc::c_int = chunk - .len() - .try_into() - .expect("chunk size is bounded by i32::MAX"); - let p: *mut libc::c_uchar = chunk.as_mut_ptr().cast(); - let ret = unsafe { libc::randABytes(p, chunk_len) }; - if ret != 0 { - return Err(util_libc::last_os_error()); - } - } - Ok(()) -} - -impl Error { - /// On VxWorks, call to `randSecure` failed (random number generator is not yet initialized). - pub(crate) const VXWORKS_RAND_SECURE: Error = Self::new_internal(10); -} diff --git a/vendor/getrandom/src/backends/wasi_p1.rs b/vendor/getrandom/src/backends/wasi_p1.rs deleted file mode 100644 index 25b5ca3b..00000000 --- a/vendor/getrandom/src/backends/wasi_p1.rs +++ /dev/null @@ -1,32 +0,0 @@ -//! Implementation for WASI Preview 1 -use crate::Error; -use core::mem::MaybeUninit; - -pub use crate::util::{inner_u32, inner_u64}; - -// This linking is vendored from the wasi crate: -// https://docs.rs/wasi/0.11.0+wasi-snapshot-preview1/src/wasi/lib_generated.rs.html#2344-2350 -#[link(wasm_import_module = "wasi_snapshot_preview1")] -extern "C" { - fn random_get(arg0: i32, arg1: i32) -> i32; -} - -/// WASI p1 uses `u16` for error codes in its witx definitions: -/// https://github.com/WebAssembly/WASI/blob/38454e9e/legacy/preview1/witx/typenames.witx#L34-L39 -const MAX_ERROR_CODE: i32 = u16::MAX as i32; - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - // Based on the wasi code: - // https://docs.rs/wasi/0.11.0+wasi-snapshot-preview1/src/wasi/lib_generated.rs.html#2046-2062 - // Note that size of an allocated object can not be bigger than isize::MAX bytes. - // WASI 0.1 supports only 32-bit WASM, so casting length to `i32` is safe. - #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)] - let ret = unsafe { random_get(dest.as_mut_ptr() as i32, dest.len() as i32) }; - match ret { - 0 => Ok(()), - // WASI functions should return positive error codes which are smaller than `MAX_ERROR_CODE` - code if code <= MAX_ERROR_CODE => Err(Error::from_neg_error_code(-code)), - _ => Err(Error::UNEXPECTED), - } -} diff --git a/vendor/getrandom/src/backends/wasi_p2.rs b/vendor/getrandom/src/backends/wasi_p2.rs deleted file mode 100644 index 63bd2d7c..00000000 --- a/vendor/getrandom/src/backends/wasi_p2.rs +++ /dev/null @@ -1,50 +0,0 @@ -//! Implementation for WASI Preview 2. -use crate::Error; -use core::mem::MaybeUninit; -use wasi::random::random::get_random_u64; - -#[inline] -pub fn inner_u32() -> Result<u32, Error> { - let val = get_random_u64(); - Ok(crate::util::truncate(val)) -} - -#[inline] -pub fn inner_u64() -> Result<u64, Error> { - Ok(get_random_u64()) -} - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - use core::ptr::copy_nonoverlapping; - use wasi::random::random::get_random_u64; - - let (prefix, chunks, suffix) = unsafe { dest.align_to_mut::<MaybeUninit<u64>>() }; - - // We use `get_random_u64` instead of `get_random_bytes` because the latter creates - // an allocation due to the Wit IDL [restrictions][0]. This should be fine since - // the main use case of `getrandom` is seed generation. - // - // [0]: https://github.com/WebAssembly/wasi-random/issues/27 - if !prefix.is_empty() { - let val = get_random_u64(); - let src = (&val as *const u64).cast(); - unsafe { - copy_nonoverlapping(src, prefix.as_mut_ptr(), prefix.len()); - } - } - - for dst in chunks { - dst.write(get_random_u64()); - } - - if !suffix.is_empty() { - let val = get_random_u64(); - let src = (&val as *const u64).cast(); - unsafe { - copy_nonoverlapping(src, suffix.as_mut_ptr(), suffix.len()); - } - } - - Ok(()) -} diff --git a/vendor/getrandom/src/backends/wasm_js.rs b/vendor/getrandom/src/backends/wasm_js.rs deleted file mode 100644 index 1320d9fc..00000000 --- a/vendor/getrandom/src/backends/wasm_js.rs +++ /dev/null @@ -1,72 +0,0 @@ -//! Implementation for WASM based on Web and Node.js -use crate::Error; -use core::mem::MaybeUninit; - -pub use crate::util::{inner_u32, inner_u64}; - -#[cfg(not(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "none"))))] -compile_error!("`wasm_js` backend can be enabled only for OS-less WASM targets!"); - -use wasm_bindgen::{prelude::wasm_bindgen, JsValue}; - -// Maximum buffer size allowed in `Crypto.getRandomValuesSize` is 65536 bytes. -// See https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues -const MAX_BUFFER_SIZE: usize = 65536; - -#[cfg(not(target_feature = "atomics"))] -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - for chunk in dest.chunks_mut(MAX_BUFFER_SIZE) { - if get_random_values(chunk).is_err() { - return Err(Error::WEB_CRYPTO); - } - } - Ok(()) -} - -#[cfg(target_feature = "atomics")] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - // getRandomValues does not work with all types of WASM memory, - // so we initially write to browser memory to avoid exceptions. - let buf_len = usize::min(dest.len(), MAX_BUFFER_SIZE); - let buf_len_u32 = buf_len - .try_into() - .expect("buffer length is bounded by MAX_BUFFER_SIZE"); - let buf = js_sys::Uint8Array::new_with_length(buf_len_u32); - for chunk in dest.chunks_mut(buf_len) { - let chunk_len = chunk - .len() - .try_into() - .expect("chunk length is bounded by MAX_BUFFER_SIZE"); - // The chunk can be smaller than buf's length, so we call to - // JS to create a smaller view of buf without allocation. - let sub_buf = if chunk_len == buf_len_u32 { - &buf - } else { - &buf.subarray(0, chunk_len) - }; - - if get_random_values(sub_buf).is_err() { - return Err(Error::WEB_CRYPTO); - } - - sub_buf.copy_to_uninit(chunk); - } - Ok(()) -} - -#[wasm_bindgen] -extern "C" { - // Crypto.getRandomValues() - #[cfg(not(target_feature = "atomics"))] - #[wasm_bindgen(js_namespace = ["globalThis", "crypto"], js_name = getRandomValues, catch)] - fn get_random_values(buf: &mut [MaybeUninit<u8>]) -> Result<(), JsValue>; - #[cfg(target_feature = "atomics")] - #[wasm_bindgen(js_namespace = ["globalThis", "crypto"], js_name = getRandomValues, catch)] - fn get_random_values(buf: &js_sys::Uint8Array) -> Result<(), JsValue>; -} - -impl Error { - /// The environment does not support the Web Crypto API. - pub(crate) const WEB_CRYPTO: Error = Self::new_internal(10); -} diff --git a/vendor/getrandom/src/backends/windows.rs b/vendor/getrandom/src/backends/windows.rs deleted file mode 100644 index b5cd504f..00000000 --- a/vendor/getrandom/src/backends/windows.rs +++ /dev/null @@ -1,61 +0,0 @@ -//! Implementation for Windows 10 and later -//! -//! On Windows 10 and later, ProcessPrng "is the primary interface to the -//! user-mode per-processor PRNGs" and only requires bcryptprimitives.dll, -//! making it a better option than the other Windows RNG APIs: -//! - BCryptGenRandom: https://learn.microsoft.com/en-us/windows/win32/api/bcrypt/nf-bcrypt-bcryptgenrandom -//! - Requires bcrypt.dll (which loads bcryptprimitives.dll anyway) -//! - Can cause crashes/hangs as BCrypt accesses the Windows Registry: -//! https://github.com/rust-lang/rust/issues/99341 -//! - Causes issues inside sandboxed code: -//! https://issues.chromium.org/issues/40277768 -//! - CryptGenRandom: https://learn.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptgenrandom -//! - Deprecated and not available on UWP targets -//! - Requires advapi32.lib/advapi32.dll (in addition to bcryptprimitives.dll) -//! - Thin wrapper around ProcessPrng -//! - RtlGenRandom: https://learn.microsoft.com/en-us/windows/win32/api/ntsecapi/nf-ntsecapi-rtlgenrandom -//! - Deprecated and not available on UWP targets -//! - Requires advapi32.dll (in addition to bcryptprimitives.dll) -//! - Requires using name "SystemFunction036" -//! - Thin wrapper around ProcessPrng -//! -//! For more information see the Windows RNG Whitepaper: https://aka.ms/win10rng -use crate::Error; -use core::mem::MaybeUninit; - -pub use crate::util::{inner_u32, inner_u64}; - -// Binding to the Windows.Win32.Security.Cryptography.ProcessPrng API. As -// bcryptprimitives.dll lacks an import library, we use "raw-dylib". This -// was added in Rust 1.65 for x86_64/aarch64 and in Rust 1.71 for x86. -// We don't need MSRV 1.71, as we only use this backend on Rust 1.78 and later. -#[cfg_attr( - target_arch = "x86", - link( - name = "bcryptprimitives", - kind = "raw-dylib", - import_name_type = "undecorated" - ) -)] -#[cfg_attr( - not(target_arch = "x86"), - link(name = "bcryptprimitives", kind = "raw-dylib") -)] -extern "system" { - fn ProcessPrng(pbdata: *mut u8, cbdata: usize) -> BOOL; -} -#[allow(clippy::upper_case_acronyms)] -type BOOL = core::ffi::c_int; // MSRV 1.64, similarly OK for this backend. -const TRUE: BOOL = 1; - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - let result = unsafe { ProcessPrng(dest.as_mut_ptr().cast::<u8>(), dest.len()) }; - // Since Windows 10, calls to the user-mode RNG are guaranteed to never - // fail during runtime (rare windows W); `ProcessPrng` will only ever - // return 1 (which is how windows represents TRUE). - // See the bottom of page 6 of the aforementioned Windows RNG - // whitepaper for more information. - debug_assert!(result == TRUE); - Ok(()) -} diff --git a/vendor/getrandom/src/backends/windows7.rs b/vendor/getrandom/src/backends/windows7.rs deleted file mode 100644 index 8a353a9f..00000000 --- a/vendor/getrandom/src/backends/windows7.rs +++ /dev/null @@ -1,45 +0,0 @@ -//! Legacy implementation for Windows XP and later -//! -//! For targets where we cannot use ProcessPrng (added in Windows 10), we use -//! RtlGenRandom. See windows.rs for a more detailed discussion of the Windows -//! RNG APIs (and why we don't use BCryptGenRandom). On versions prior to -//! Windows 10, this implementation is secure. On Windows 10 and later, this -//! implementation behaves identically to the windows.rs implementation, except -//! that it forces the loading of an additonal DLL (advapi32.dll). -//! -//! This implementation will not work on UWP targets (which lack advapi32.dll), -//! but such targets require Windows 10, so can use the standard implementation. -use crate::Error; -use core::{ffi::c_void, mem::MaybeUninit}; - -pub use crate::util::{inner_u32, inner_u64}; - -// Binding to the Windows.Win32.Security.Authentication.Identity.RtlGenRandom -// API. Don't use windows-targets as it doesn't support Windows 7 targets. -#[link(name = "advapi32")] -extern "system" { - #[link_name = "SystemFunction036"] - fn RtlGenRandom(randombuffer: *mut c_void, randombufferlength: u32) -> BOOLEAN; -} -#[allow(clippy::upper_case_acronyms)] -type BOOLEAN = u8; -const TRUE: BOOLEAN = 1u8; - -#[inline] -pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { - // Prevent overflow of u32 - let chunk_size = usize::try_from(i32::MAX).expect("Windows does not support 16-bit targets"); - for chunk in dest.chunks_mut(chunk_size) { - let chunk_len = u32::try_from(chunk.len()).expect("chunk size is bounded by i32::MAX"); - let ret = unsafe { RtlGenRandom(chunk.as_mut_ptr().cast::<c_void>(), chunk_len) }; - if ret != TRUE { - return Err(Error::WINDOWS_RTL_GEN_RANDOM); - } - } - Ok(()) -} - -impl Error { - /// Call to Windows [`RtlGenRandom`](https://docs.microsoft.com/en-us/windows/win32/api/ntsecapi/nf-ntsecapi-rtlgenrandom) failed. - pub(crate) const WINDOWS_RTL_GEN_RANDOM: Error = Self::new_internal(10); -} diff --git a/vendor/getrandom/src/error.rs b/vendor/getrandom/src/error.rs deleted file mode 100644 index 13f3121f..00000000 --- a/vendor/getrandom/src/error.rs +++ /dev/null @@ -1,212 +0,0 @@ -#[cfg(feature = "std")] -extern crate std; - -use core::fmt; - -// This private alias mirrors `std::io::RawOsError`: -// https://doc.rust-lang.org/std/io/type.RawOsError.html) -cfg_if::cfg_if!( - if #[cfg(target_os = "uefi")] { - // See the UEFI spec for more information: - // https://uefi.org/specs/UEFI/2.10/Apx_D_Status_Codes.html - type RawOsError = usize; - type NonZeroRawOsError = core::num::NonZeroUsize; - const UEFI_ERROR_FLAG: RawOsError = 1 << (RawOsError::BITS - 1); - } else { - type RawOsError = i32; - type NonZeroRawOsError = core::num::NonZeroI32; - } -); - -/// A small and `no_std` compatible error type -/// -/// The [`Error::raw_os_error()`] will indicate if the error is from the OS, and -/// 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 -/// [`std::error::Error`](https://doc.rust-lang.org/std/error/trait.Error.html) -/// - [`std::io::Error`](https://doc.rust-lang.org/std/io/struct.Error.html) implements -/// [`From<getrandom::Error>`](https://doc.rust-lang.org/std/convert/trait.From.html). - -// note: on non-UEFI targets OS errors are represented as negative integers, -// while on UEFI targets OS errors have the highest bit set to 1. -#[derive(Copy, Clone, Eq, PartialEq)] -pub struct Error(NonZeroRawOsError); - -impl Error { - /// This target/platform is not supported by `getrandom`. - pub const UNSUPPORTED: Error = Self::new_internal(0); - /// The platform-specific `errno` returned a non-positive value. - pub const ERRNO_NOT_POSITIVE: Error = Self::new_internal(1); - /// Encountered an unexpected situation which should not happen in practice. - pub const UNEXPECTED: Error = Self::new_internal(2); - - /// Internal errors can be in the range of 2^16..2^17 - const INTERNAL_START: RawOsError = 1 << 16; - /// Custom errors can be in the range of 2^17..(2^17 + 2^16) - const CUSTOM_START: RawOsError = 1 << 17; - - /// Creates a new instance of an `Error` from a negative error code. - #[cfg(not(target_os = "uefi"))] - #[allow(dead_code)] - pub(super) fn from_neg_error_code(code: RawOsError) -> Self { - if code < 0 { - let code = NonZeroRawOsError::new(code).expect("`code` is negative"); - Self(code) - } else { - Error::UNEXPECTED - } - } - - /// Creates a new instance of an `Error` from an UEFI error code. - #[cfg(target_os = "uefi")] - #[allow(dead_code)] - pub(super) fn from_uefi_code(code: RawOsError) -> Self { - if code & UEFI_ERROR_FLAG != 0 { - let code = NonZeroRawOsError::new(code).expect("The highest bit of `code` is set to 1"); - Self(code) - } else { - Self::UNEXPECTED - } - } - - /// Extract the raw OS error code (if this error came from the OS) - /// - /// This method is identical to [`std::io::Error::raw_os_error()`][1], except - /// that it works in `no_std` contexts. On most targets this method returns - /// `Option<i32>`, but some platforms (e.g. UEFI) may use a different primitive - /// type like `usize`. Consult with the [`RawOsError`] docs for more information. - /// - /// If this method returns `None`, the error value can still be formatted via - /// the `Display` implementation. - /// - /// [1]: https://doc.rust-lang.org/std/io/struct.Error.html#method.raw_os_error - /// [`RawOsError`]: https://doc.rust-lang.org/std/io/type.RawOsError.html - #[inline] - pub fn raw_os_error(self) -> Option<RawOsError> { - let code = self.0.get(); - - // note: in this method we need to cover only backends which rely on - // `Error::{from_error_code, from_errno, from_uefi_code}` methods, - // on all other backends this method always returns `None`. - - #[cfg(target_os = "uefi")] - { - if code & UEFI_ERROR_FLAG != 0 { - Some(code) - } else { - None - } - } - - #[cfg(not(target_os = "uefi"))] - { - // On most targets `std` expects positive error codes while retrieving error strings: - // - `libc`-based targets use `strerror_r` which expects positive error codes. - // - Hermit relies on the `hermit-abi` crate, which expects positive error codes: - // https://docs.rs/hermit-abi/0.4.0/src/hermit_abi/errno.rs.html#400-532 - // - WASIp1 uses the same conventions as `libc`: - // https://github.com/rust-lang/rust/blob/1.85.0/library/std/src/sys/pal/wasi/os.rs#L57-L67 - // - // The only exception is Solid, `std` expects negative system error codes, see: - // https://github.com/rust-lang/rust/blob/1.85.0/library/std/src/sys/pal/solid/error.rs#L5-L31 - if code >= 0 { - None - } else if cfg!(not(target_os = "solid_asp3")) { - code.checked_neg() - } else { - Some(code) - } - } - } - - /// Creates a new instance of an `Error` from a particular custom error code. - pub const fn new_custom(n: u16) -> Error { - // SAFETY: code > 0 as CUSTOM_START > 0 and adding `n` won't overflow `RawOsError`. - let code = Error::CUSTOM_START + (n as RawOsError); - Error(unsafe { NonZeroRawOsError::new_unchecked(code) }) - } - - /// Creates a new instance of an `Error` from a particular internal error code. - pub(crate) const fn new_internal(n: u16) -> Error { - // SAFETY: code > 0 as INTERNAL_START > 0 and adding `n` won't overflow `RawOsError`. - let code = Error::INTERNAL_START + (n as RawOsError); - Error(unsafe { NonZeroRawOsError::new_unchecked(code) }) - } - - fn internal_desc(&self) -> Option<&'static str> { - let desc = match *self { - Error::UNSUPPORTED => "getrandom: this target is not supported", - Error::ERRNO_NOT_POSITIVE => "errno: did not return a positive value", - Error::UNEXPECTED => "unexpected situation", - #[cfg(any( - target_os = "ios", - target_os = "visionos", - target_os = "watchos", - target_os = "tvos", - ))] - Error::IOS_RANDOM_GEN => "SecRandomCopyBytes: iOS Security framework failure", - #[cfg(all(windows, target_vendor = "win7"))] - Error::WINDOWS_RTL_GEN_RANDOM => "RtlGenRandom: Windows system function failure", - #[cfg(all(feature = "wasm_js", getrandom_backend = "wasm_js"))] - Error::WEB_CRYPTO => "Web Crypto API is unavailable", - #[cfg(target_os = "vxworks")] - Error::VXWORKS_RAND_SECURE => "randSecure: VxWorks RNG module is not initialized", - - #[cfg(any( - getrandom_backend = "rdrand", - all(target_arch = "x86_64", target_env = "sgx") - ))] - Error::FAILED_RDRAND => "RDRAND: failed multiple times: CPU issue likely", - #[cfg(any( - getrandom_backend = "rdrand", - all(target_arch = "x86_64", target_env = "sgx") - ))] - Error::NO_RDRAND => "RDRAND: instruction not supported", - - #[cfg(getrandom_backend = "rndr")] - Error::RNDR_FAILURE => "RNDR: Could not generate a random number", - #[cfg(getrandom_backend = "rndr")] - Error::RNDR_NOT_AVAILABLE => "RNDR: Register not supported", - _ => return None, - }; - Some(desc) - } -} - -impl fmt::Debug for Error { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let mut dbg = f.debug_struct("Error"); - if let Some(errno) = self.raw_os_error() { - dbg.field("os_error", &errno); - #[cfg(feature = "std")] - dbg.field("description", &std::io::Error::from_raw_os_error(errno)); - } else if let Some(desc) = self.internal_desc() { - dbg.field("internal_code", &self.0.get()); - dbg.field("description", &desc); - } else { - dbg.field("unknown_code", &self.0.get()); - } - dbg.finish() - } -} - -impl fmt::Display for Error { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - if let Some(errno) = self.raw_os_error() { - cfg_if! { - if #[cfg(feature = "std")] { - std::io::Error::from_raw_os_error(errno).fmt(f) - } else { - write!(f, "OS Error: {}", errno) - } - } - } else if let Some(desc) = self.internal_desc() { - f.write_str(desc) - } else { - write!(f, "Unknown Error: {}", self.0.get()) - } - } -} diff --git a/vendor/getrandom/src/error_std_impls.rs b/vendor/getrandom/src/error_std_impls.rs deleted file mode 100644 index 2c326012..00000000 --- a/vendor/getrandom/src/error_std_impls.rs +++ /dev/null @@ -1,15 +0,0 @@ -extern crate std; - -use crate::Error; -use std::io; - -impl From<Error> for io::Error { - fn from(err: Error) -> Self { - match err.raw_os_error() { - Some(errno) => io::Error::from_raw_os_error(errno), - None => io::Error::new(io::ErrorKind::Other, err), - } - } -} - -impl std::error::Error for Error {} diff --git a/vendor/getrandom/src/lazy.rs b/vendor/getrandom/src/lazy.rs deleted file mode 100644 index b191aa6d..00000000 --- a/vendor/getrandom/src/lazy.rs +++ /dev/null @@ -1,64 +0,0 @@ -//! Helpers built around pointer-sized atomics. -use core::sync::atomic::{AtomicUsize, Ordering}; - -// This structure represents a lazily initialized static usize value. Useful -// when it is preferable to just rerun initialization instead of locking. -// unsync_init will invoke an init() function until it succeeds, then return the -// cached value for future calls. -// -// unsync_init supports init() "failing". If the init() method returns UNINIT, -// that value will be returned as normal, but will not be cached. -// -// Users should only depend on the _value_ returned by init() functions. -// Specifically, for the following init() function: -// fn init() -> usize { -// a(); -// let v = b(); -// c(); -// v -// } -// the effects of c() or writes to shared memory will not necessarily be -// observed and additional synchronization methods may be needed. -struct LazyUsize(AtomicUsize); - -impl LazyUsize { - // The initialization is not completed. - const UNINIT: usize = usize::MAX; - - const fn new() -> Self { - Self(AtomicUsize::new(Self::UNINIT)) - } - - // Runs the init() function at most once, returning the value of some run of - // init(). Multiple callers can run their init() functions in parallel. - // init() should always return the same value, if it succeeds. - fn unsync_init(&self, init: impl FnOnce() -> usize) -> usize { - #[cold] - fn do_init(this: &LazyUsize, init: impl FnOnce() -> usize) -> usize { - let val = init(); - this.0.store(val, Ordering::Relaxed); - val - } - - // Relaxed ordering is fine, as we only have a single atomic variable. - let val = self.0.load(Ordering::Relaxed); - if val != Self::UNINIT { - val - } else { - do_init(self, init) - } - } -} - -// Identical to LazyUsize except with bool instead of usize. -pub(crate) struct LazyBool(LazyUsize); - -impl LazyBool { - pub const fn new() -> Self { - Self(LazyUsize::new()) - } - - pub fn unsync_init(&self, init: impl FnOnce() -> bool) -> bool { - self.0.unsync_init(|| usize::from(init())) != 0 - } -} diff --git a/vendor/getrandom/src/lib.rs b/vendor/getrandom/src/lib.rs deleted file mode 100644 index 51c494e1..00000000 --- a/vendor/getrandom/src/lib.rs +++ /dev/null @@ -1,143 +0,0 @@ -// Overwrite links to crate items with intra-crate links -//! [`Error::UNEXPECTED`]: Error::UNEXPECTED -//! [`fill_uninit`]: fill_uninit - -#![no_std] -#![doc( - html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk.png", - html_favicon_url = "https://www.rust-lang.org/favicon.ico" -)] -#![doc = include_str!("../README.md")] -#![warn(rust_2018_idioms, unused_lifetimes, missing_docs)] -#![cfg_attr(docsrs, feature(doc_auto_cfg))] -#![cfg_attr(getrandom_backend = "efi_rng", feature(uefi_std))] -#![deny( - clippy::cast_lossless, - clippy::cast_possible_truncation, - clippy::cast_possible_wrap, - clippy::cast_precision_loss, - clippy::cast_ptr_alignment, - clippy::cast_sign_loss, - clippy::char_lit_as_u8, - clippy::checked_conversions, - clippy::fn_to_numeric_cast, - clippy::fn_to_numeric_cast_with_truncation, - clippy::ptr_as_ptr, - clippy::unnecessary_cast, - clippy::useless_conversion -)] - -#[macro_use] -extern crate cfg_if; - -use core::mem::MaybeUninit; - -mod backends; -mod error; -mod util; - -#[cfg(feature = "std")] -mod error_std_impls; - -pub use crate::error::Error; - -/// Fill `dest` with random bytes from the system's preferred random number source. -/// -/// This function returns an error on any failure, including partial reads. We -/// make no guarantees regarding the contents of `dest` on error. If `dest` is -/// empty, `getrandom` immediately returns success, making no calls to the -/// underlying operating system. -/// -/// Blocking is possible, at least during early boot; see module documentation. -/// -/// In general, `getrandom` will be fast enough for interactive usage, though -/// significantly slower than a user-space CSPRNG; for the latter consider -/// [`rand::thread_rng`](https://docs.rs/rand/*/rand/fn.thread_rng.html). -/// -/// # Examples -/// -/// ``` -/// # fn main() -> Result<(), getrandom::Error> { -/// let mut buf = [0u8; 32]; -/// getrandom::fill(&mut buf)?; -/// # Ok(()) } -/// ``` -#[inline] -pub fn fill(dest: &mut [u8]) -> Result<(), Error> { - // SAFETY: The `&mut MaybeUninit<_>` reference doesn't escape, - // and `fill_uninit` guarantees it will never de-initialize - // any part of `dest`. - fill_uninit(unsafe { util::slice_as_uninit_mut(dest) })?; - Ok(()) -} - -/// Fill potentially uninitialized buffer `dest` with random bytes from -/// the system's preferred random number source and return a mutable -/// reference to those bytes. -/// -/// On successful completion this function is guaranteed to return a slice -/// which points to the same memory as `dest` and has the same length. -/// In other words, it's safe to assume that `dest` is initialized after -/// this function has returned `Ok`. -/// -/// No part of `dest` will ever be de-initialized at any point, regardless -/// of what is returned. -/// -/// # Examples -/// -/// ```ignore -/// # // We ignore this test since `uninit_array` is unstable. -/// #![feature(maybe_uninit_uninit_array)] -/// # fn main() -> Result<(), getrandom::Error> { -/// let mut buf = core::mem::MaybeUninit::uninit_array::<1024>(); -/// let buf: &mut [u8] = getrandom::fill_uninit(&mut buf)?; -/// # Ok(()) } -/// ``` -#[inline] -pub fn fill_uninit(dest: &mut [MaybeUninit<u8>]) -> Result<&mut [u8], Error> { - if !dest.is_empty() { - backends::fill_inner(dest)?; - } - - #[cfg(getrandom_msan)] - extern "C" { - fn __msan_unpoison(a: *mut core::ffi::c_void, size: usize); - } - - // SAFETY: `dest` has been fully initialized by `imp::fill_inner` - // since it returned `Ok`. - Ok(unsafe { - #[cfg(getrandom_msan)] - __msan_unpoison(dest.as_mut_ptr().cast(), dest.len()); - - util::slice_assume_init_mut(dest) - }) -} - -/// Get random `u32` from the system's preferred random number source. -/// -/// # Examples -/// -/// ``` -/// # fn main() -> Result<(), getrandom::Error> { -/// let rng_seed = getrandom::u32()?; -/// # Ok(()) } -/// ``` -#[inline] -pub fn u32() -> Result<u32, Error> { - backends::inner_u32() -} - -/// Get random `u64` from the system's preferred random number source. -/// -/// # Examples -/// -/// ``` -/// # fn main() -> Result<(), getrandom::Error> { -/// let rng_seed = getrandom::u64()?; -/// # Ok(()) } -/// ``` -#[inline] -pub fn u64() -> Result<u64, Error> { - backends::inner_u64() -} diff --git a/vendor/getrandom/src/util.rs b/vendor/getrandom/src/util.rs deleted file mode 100644 index d42c26e7..00000000 --- a/vendor/getrandom/src/util.rs +++ /dev/null @@ -1,84 +0,0 @@ -#![allow(dead_code)] -use crate::Error; -use core::{mem::MaybeUninit, ptr, slice}; - -/// Polyfill for `maybe_uninit_slice` feature's -/// `MaybeUninit::slice_assume_init_mut`. Every element of `slice` must have -/// been initialized. -#[inline(always)] -#[allow(unused_unsafe)] // TODO(MSRV 1.65): Remove this. -pub unsafe fn slice_assume_init_mut<T>(slice: &mut [MaybeUninit<T>]) -> &mut [T] { - let ptr = ptr_from_mut::<[MaybeUninit<T>]>(slice) as *mut [T]; - // SAFETY: `MaybeUninit<T>` is guaranteed to be layout-compatible with `T`. - unsafe { &mut *ptr } -} - -#[inline] -pub fn uninit_slice_fill_zero(slice: &mut [MaybeUninit<u8>]) -> &mut [u8] { - unsafe { ptr::write_bytes(slice.as_mut_ptr(), 0, slice.len()) }; - unsafe { slice_assume_init_mut(slice) } -} - -#[inline(always)] -pub fn slice_as_uninit<T>(slice: &[T]) -> &[MaybeUninit<T>] { - let ptr = ptr_from_ref::<[T]>(slice) as *const [MaybeUninit<T>]; - // SAFETY: `MaybeUninit<T>` is guaranteed to be layout-compatible with `T`. - unsafe { &*ptr } -} - -/// View an mutable initialized array as potentially-uninitialized. -/// -/// This is unsafe because it allows assigning uninitialized values into -/// `slice`, which would be undefined behavior. -#[inline(always)] -#[allow(unused_unsafe)] // TODO(MSRV 1.65): Remove this. -pub unsafe fn slice_as_uninit_mut<T>(slice: &mut [T]) -> &mut [MaybeUninit<T>] { - let ptr = ptr_from_mut::<[T]>(slice) as *mut [MaybeUninit<T>]; - // SAFETY: `MaybeUninit<T>` is guaranteed to be layout-compatible with `T`. - unsafe { &mut *ptr } -} - -// TODO: MSRV(1.76.0): Replace with `core::ptr::from_mut`. -fn ptr_from_mut<T: ?Sized>(r: &mut T) -> *mut T { - r -} - -// TODO: MSRV(1.76.0): Replace with `core::ptr::from_ref`. -fn ptr_from_ref<T: ?Sized>(r: &T) -> *const T { - r -} - -/// Default implementation of `inner_u32` on top of `fill_uninit` -#[inline] -pub fn inner_u32() -> Result<u32, Error> { - let mut res = MaybeUninit::<u32>::uninit(); - // SAFETY: the created slice has the same size as `res` - let dst = unsafe { - let p: *mut MaybeUninit<u8> = res.as_mut_ptr().cast(); - slice::from_raw_parts_mut(p, core::mem::size_of::<u32>()) - }; - crate::fill_uninit(dst)?; - // SAFETY: `dst` has been fully initialized by `imp::fill_inner` - // since it returned `Ok`. - Ok(unsafe { res.assume_init() }) -} - -/// Default implementation of `inner_u64` on top of `fill_uninit` -#[inline] -pub fn inner_u64() -> Result<u64, Error> { - let mut res = MaybeUninit::<u64>::uninit(); - // SAFETY: the created slice has the same size as `res` - let dst = unsafe { - let p: *mut MaybeUninit<u8> = res.as_mut_ptr().cast(); - slice::from_raw_parts_mut(p, core::mem::size_of::<u64>()) - }; - crate::fill_uninit(dst)?; - // SAFETY: `dst` has been fully initialized by `imp::fill_inner` - // since it returned `Ok`. - Ok(unsafe { res.assume_init() }) -} - -/// Truncates `u64` and returns the lower 32 bits as `u32` -pub(crate) fn truncate(val: u64) -> u32 { - u32::try_from(val & u64::from(u32::MAX)).expect("The higher 32 bits are masked") -} diff --git a/vendor/getrandom/src/util_libc.rs b/vendor/getrandom/src/util_libc.rs deleted file mode 100644 index 24c53c0c..00000000 --- a/vendor/getrandom/src/util_libc.rs +++ /dev/null @@ -1,81 +0,0 @@ -use crate::Error; -use core::mem::MaybeUninit; - -cfg_if! { - if #[cfg(any(target_os = "netbsd", target_os = "openbsd", target_os = "android", target_os = "cygwin"))] { - use libc::__errno as errno_location; - } else if #[cfg(any(target_os = "linux", target_os = "emscripten", target_os = "hurd", target_os = "redox", target_os = "dragonfly"))] { - use libc::__errno_location as errno_location; - } else if #[cfg(any(target_os = "solaris", target_os = "illumos"))] { - use libc::___errno as errno_location; - } else if #[cfg(any(target_os = "macos", target_os = "freebsd"))] { - use libc::__error as errno_location; - } else if #[cfg(target_os = "haiku")] { - use libc::_errnop as errno_location; - } else if #[cfg(target_os = "nto")] { - use libc::__get_errno_ptr as errno_location; - } else if #[cfg(any(all(target_os = "horizon", target_arch = "arm"), target_os = "vita"))] { - extern "C" { - // Not provided by libc: https://github.com/rust-lang/libc/issues/1995 - fn __errno() -> *mut libc::c_int; - } - use __errno as errno_location; - } else if #[cfg(target_os = "aix")] { - use libc::_Errno as errno_location; - } -} - -cfg_if! { - if #[cfg(target_os = "vxworks")] { - use libc::errnoGet as get_errno; - } else { - unsafe fn get_errno() -> libc::c_int { *errno_location() } - } -} - -pub(crate) fn last_os_error() -> Error { - // We assume that on all targets which use the `util_libc` module `c_int` is equal to `i32` - let errno: i32 = unsafe { get_errno() }; - - if errno > 0 { - let code = errno - .checked_neg() - .expect("Positive number can be always negated"); - Error::from_neg_error_code(code) - } else { - Error::ERRNO_NOT_POSITIVE - } -} - -/// Fill a buffer by repeatedly invoking `sys_fill`. -/// -/// The `sys_fill` function: -/// - should return -1 and set errno on failure -/// - should return the number of bytes written on success -#[allow(dead_code)] -pub(crate) fn sys_fill_exact( - mut buf: &mut [MaybeUninit<u8>], - sys_fill: impl Fn(&mut [MaybeUninit<u8>]) -> libc::ssize_t, -) -> Result<(), Error> { - while !buf.is_empty() { - let res = sys_fill(buf); - match res { - res if res > 0 => { - let len = usize::try_from(res).map_err(|_| Error::UNEXPECTED)?; - buf = buf.get_mut(len..).ok_or(Error::UNEXPECTED)?; - } - -1 => { - let err = last_os_error(); - // We should try again if the call was interrupted. - if err.raw_os_error() != Some(libc::EINTR) { - return Err(err); - } - } - // Negative return codes not equal to -1 should be impossible. - // EOF (ret = 0) should be impossible, as the data we are reading - // should be an infinite stream of random bytes. - _ => return Err(Error::UNEXPECTED), - } - } - Ok(()) -} diff --git a/vendor/getrandom/tests/mod.rs b/vendor/getrandom/tests/mod.rs deleted file mode 100644 index 9f1e6338..00000000 --- a/vendor/getrandom/tests/mod.rs +++ /dev/null @@ -1,297 +0,0 @@ -use core::mem::MaybeUninit; -use getrandom::{fill, fill_uninit}; - -#[cfg(all(feature = "wasm_js", target_arch = "wasm32", target_os = "unknown"))] -use wasm_bindgen_test::wasm_bindgen_test as test; - -#[test] -fn test_zero() { - // Test that APIs are happy with zero-length requests - fill(&mut [0u8; 0]).unwrap(); - let res = fill_uninit(&mut []).unwrap(); - assert!(res.is_empty()); -} - -trait DiffBits: Sized { - fn diff_bits(ab: (&Self, &Self)) -> usize; -} - -impl DiffBits for u8 { - fn diff_bits((a, b): (&Self, &Self)) -> usize { - (a ^ b).count_ones() as usize - } -} - -impl DiffBits for u32 { - fn diff_bits((a, b): (&Self, &Self)) -> usize { - (a ^ b).count_ones() as usize - } -} - -impl DiffBits for u64 { - fn diff_bits((a, b): (&Self, &Self)) -> usize { - (a ^ b).count_ones() as usize - } -} - -// Return the number of bits in which s1 and s2 differ -fn num_diff_bits<T: DiffBits>(s1: &[T], s2: &[T]) -> usize { - assert_eq!(s1.len(), s2.len()); - s1.iter().zip(s2.iter()).map(T::diff_bits).sum() -} - -// TODO: use `[const { MaybeUninit::uninit() }; N]` after MSRV is bumped to 1.79+ -// or `MaybeUninit::uninit_array` -fn uninit_vec(n: usize) -> Vec<MaybeUninit<u8>> { - vec![MaybeUninit::uninit(); n] -} - -// Tests the quality of calling getrandom on two large buffers -#[test] -fn test_diff() { - const N: usize = 1000; - let mut v1 = [0u8; N]; - let mut v2 = [0u8; N]; - fill(&mut v1).unwrap(); - fill(&mut v2).unwrap(); - - let mut t1 = uninit_vec(N); - let mut t2 = uninit_vec(N); - let r1 = fill_uninit(&mut t1).unwrap(); - let r2 = fill_uninit(&mut t2).unwrap(); - assert_eq!(r1.len(), N); - assert_eq!(r2.len(), N); - - // Between 3.5 and 4.5 bits per byte should differ. Probability of failure: - // ~ 2^(-94) = 2 * CDF[BinomialDistribution[8000, 0.5], 3500] - let d1 = num_diff_bits(&v1, &v2); - assert!(d1 > 3500); - assert!(d1 < 4500); - let d2 = num_diff_bits(r1, r2); - assert!(d2 > 3500); - assert!(d2 < 4500); -} - -#[test] -fn test_diff_u32() { - const N: usize = 1000 / 4; - let mut v1 = [0u32; N]; - let mut v2 = [0u32; N]; - for v in v1.iter_mut() { - *v = getrandom::u32().unwrap(); - } - for v in v2.iter_mut() { - *v = getrandom::u32().unwrap(); - } - - // Between 3.5 and 4.5 bits per byte should differ. Probability of failure: - // ~ 2^(-94) = 2 * CDF[BinomialDistribution[8000, 0.5], 3500] - let d1 = num_diff_bits(&v1, &v2); - assert!(d1 > 3500); - assert!(d1 < 4500); -} - -#[test] -fn test_diff_u64() { - const N: usize = 1000 / 8; - let mut v1 = [0u64; N]; - let mut v2 = [0u64; N]; - for v in v1.iter_mut() { - *v = getrandom::u64().unwrap(); - } - for v in v2.iter_mut() { - *v = getrandom::u64().unwrap(); - } - - // Between 3.5 and 4.5 bits per byte should differ. Probability of failure: - // ~ 2^(-94) = 2 * CDF[BinomialDistribution[8000, 0.5], 3500] - let d1 = num_diff_bits(&v1, &v2); - assert!(d1 > 3500); - assert!(d1 < 4500); -} - -#[test] -fn test_small() { - const N: usize = 64; - // For each buffer size, get at least 256 bytes and check that between - // 3 and 5 bits per byte differ. Probability of failure: - // ~ 2^(-91) = 64 * 2 * CDF[BinomialDistribution[8*256, 0.5], 3*256] - for size in 1..=N { - let mut num_bytes = 0; - let mut diff_bits = 0; - while num_bytes < 256 { - let mut buf1 = [0u8; N]; - let mut buf2 = [0u8; N]; - - let s1 = &mut buf1[..size]; - let s2 = &mut buf2[..size]; - - fill(s1).unwrap(); - fill(s2).unwrap(); - - num_bytes += size; - diff_bits += num_diff_bits(s1, s2); - } - assert!(diff_bits > 3 * num_bytes); - assert!(diff_bits < 5 * num_bytes); - } -} - -// Tests the quality of calling getrandom repeatedly on small buffers -#[test] -fn test_small_uninit() { - const N: usize = 64; - // For each buffer size, get at least 256 bytes and check that between - // 3 and 5 bits per byte differ. Probability of failure: - // ~ 2^(-91) = 64 * 2 * CDF[BinomialDistribution[8*256, 0.5], 3*256] - for size in 1..=N { - let mut num_bytes = 0; - let mut diff_bits = 0; - while num_bytes < 256 { - let mut buf1 = uninit_vec(N); - let mut buf2 = uninit_vec(N); - - let s1 = &mut buf1[..size]; - let s2 = &mut buf2[..size]; - - let r1 = fill_uninit(s1).unwrap(); - let r2 = fill_uninit(s2).unwrap(); - assert_eq!(r1.len(), size); - assert_eq!(r2.len(), size); - - num_bytes += size; - diff_bits += num_diff_bits(r1, r2); - } - assert!(diff_bits > 3 * num_bytes); - assert!(diff_bits < 5 * num_bytes); - } -} - -#[test] -fn test_huge() { - let mut huge = [0u8; 100_000]; - fill(&mut huge).unwrap(); -} - -#[test] -fn test_huge_uninit() { - const N: usize = 100_000; - let mut huge = uninit_vec(N); - let res = fill_uninit(&mut huge).unwrap(); - assert_eq!(res.len(), N); -} - -#[test] -#[cfg_attr( - target_arch = "wasm32", - ignore = "The thread API always fails/panics on WASM" -)] -fn test_multithreading() { - extern crate std; - use std::{sync::mpsc::channel, thread, vec}; - - let mut txs = vec![]; - for _ in 0..20 { - let (tx, rx) = channel(); - txs.push(tx); - - thread::spawn(move || { - // wait until all the tasks are ready to go. - rx.recv().unwrap(); - let mut v = [0u8; 1000]; - - for _ in 0..100 { - fill(&mut v).unwrap(); - thread::yield_now(); - } - }); - } - - // start all the tasks - for tx in txs.iter() { - tx.send(()).unwrap(); - } -} - -#[cfg(getrandom_backend = "custom")] -mod custom { - use getrandom::Error; - - struct Xoshiro128PlusPlus { - s: [u32; 4], - } - - impl Xoshiro128PlusPlus { - fn new(mut seed: u64) -> Self { - const PHI: u64 = 0x9e3779b97f4a7c15; - let mut s = [0u32; 4]; - for val in s.iter_mut() { - seed = seed.wrapping_add(PHI); - let mut z = seed; - z = (z ^ (z >> 30)).wrapping_mul(0xbf58476d1ce4e5b9); - z = (z ^ (z >> 27)).wrapping_mul(0x94d049bb133111eb); - z = z ^ (z >> 31); - *val = z as u32; - } - Self { s } - } - - fn next_u32(&mut self) -> u32 { - let res = self.s[0] - .wrapping_add(self.s[3]) - .rotate_left(7) - .wrapping_add(self.s[0]); - - let t = self.s[1] << 9; - - self.s[2] ^= self.s[0]; - self.s[3] ^= self.s[1]; - self.s[1] ^= self.s[2]; - self.s[0] ^= self.s[3]; - - self.s[2] ^= t; - - self.s[3] = self.s[3].rotate_left(11); - - res - } - } - - // This implementation uses current timestamp as a PRNG seed. - // - // WARNING: this custom implementation is for testing purposes ONLY! - #[no_mangle] - unsafe extern "Rust" fn __getrandom_v03_custom(dest: *mut u8, len: usize) -> Result<(), Error> { - use std::time::{SystemTime, UNIX_EPOCH}; - - assert_ne!(len, 0); - - if len == 142 { - return Err(Error::new_custom(142)); - } - - let dest_u32 = dest.cast::<u32>(); - let ts = SystemTime::now().duration_since(UNIX_EPOCH).unwrap(); - let mut rng = Xoshiro128PlusPlus::new(ts.as_nanos() as u64); - for i in 0..len / 4 { - let val = rng.next_u32(); - core::ptr::write_unaligned(dest_u32.add(i), val); - } - if len % 4 != 0 { - let start = 4 * (len / 4); - for i in start..len { - let val = rng.next_u32(); - core::ptr::write_unaligned(dest.add(i), val as u8); - } - } - Ok(()) - } - - // Test that enabling the custom feature indeed uses the custom implementation - #[test] - fn test_custom() { - let mut buf = [0u8; 142]; - let res = getrandom::fill(&mut buf); - assert!(res.is_err()); - } -} |