summaryrefslogtreecommitdiffstats
path: root/vendor/getrandom
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/getrandom')
-rw-r--r--vendor/getrandom/.cargo-checksum.json1
-rw-r--r--vendor/getrandom/CHANGELOG.md318
-rw-r--r--vendor/getrandom/Cargo.toml59
-rw-r--r--vendor/getrandom/LICENSE-APACHE201
-rw-r--r--vendor/getrandom/LICENSE-MIT26
-rw-r--r--vendor/getrandom/README.md64
-rw-r--r--vendor/getrandom/benches/mod.rs22
-rw-r--r--vendor/getrandom/src/3ds.rs17
-rw-r--r--vendor/getrandom/src/bsd_arandom.rs52
-rw-r--r--vendor/getrandom/src/custom.rs102
-rw-r--r--vendor/getrandom/src/dragonfly.rs26
-rw-r--r--vendor/getrandom/src/error.rs191
-rw-r--r--vendor/getrandom/src/error_impls.rs24
-rw-r--r--vendor/getrandom/src/espidf.rs26
-rw-r--r--vendor/getrandom/src/fuchsia.rs20
-rw-r--r--vendor/getrandom/src/ios.rs27
-rw-r--r--vendor/getrandom/src/js.rs129
-rw-r--r--vendor/getrandom/src/lib.rs263
-rw-r--r--vendor/getrandom/src/linux_android.rs46
-rw-r--r--vendor/getrandom/src/macos.rs35
-rw-r--r--vendor/getrandom/src/openbsd.rs20
-rw-r--r--vendor/getrandom/src/rdrand.rs97
-rw-r--r--vendor/getrandom/src/solaris_illumos.rs47
-rw-r--r--vendor/getrandom/src/solid.rs26
-rw-r--r--vendor/getrandom/src/use_file.rs139
-rw-r--r--vendor/getrandom/src/util.rs64
-rw-r--r--vendor/getrandom/src/util_libc.rs127
-rw-r--r--vendor/getrandom/src/vxworks.rs34
-rw-r--r--vendor/getrandom/src/wasi.rs23
-rw-r--r--vendor/getrandom/src/windows.rs48
-rw-r--r--vendor/getrandom/tests/common/mod.rs66
-rw-r--r--vendor/getrandom/tests/custom.rs50
-rw-r--r--vendor/getrandom/tests/normal.rs11
-rw-r--r--vendor/getrandom/tests/rdrand.rs15
34 files changed, 2416 insertions, 0 deletions
diff --git a/vendor/getrandom/.cargo-checksum.json b/vendor/getrandom/.cargo-checksum.json
new file mode 100644
index 000000000..7bdcc1bc4
--- /dev/null
+++ b/vendor/getrandom/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CHANGELOG.md":"e972a70c9a4729acbd6bd81ca0c3e03944cab242743b308d124d64b3552f8e63","Cargo.toml":"66283df4cc6406f65b46dded3469d23f9d1c6372a0385af8cdcde9da1b6cf5d9","LICENSE-APACHE":"aaff376532ea30a0cd5330b9502ad4a4c8bf769c539c87ffe78819d188a18ebf","LICENSE-MIT":"209fbbe0ad52d9235e37badf9cadfe4dbdc87203179c0899e738b39ade42177b","README.md":"7ae74633326a22fd6298d7f209fb14884277bd98049795f444945acbb2b0dfbd","benches/mod.rs":"5495735ff210a50cab23c2cc84191ed910af7c30395a3d9d6095b722765b3864","src/3ds.rs":"0f48fc15f89b518fb92e06aaa4838b62dc073598e8f288df56ad1e5a9251af1e","src/bsd_arandom.rs":"d2ee195acd80c7d1364a369ad0d2dad46f5f9f973f9d3960367413fd87acfcd6","src/custom.rs":"b363ee77664203d141985402433afd6808b72cc50bff586b3034d303eccfc281","src/dragonfly.rs":"28f3f7ac4f093dfb6cd2c8e7e0714f16d0f03f8c658e56caa8fe9bd03b1ff39b","src/error.rs":"110ffe8a2c6b0fa46a4e317e837efe617b343f250fedac61bcabc3c5250e7432","src/error_impls.rs":"9c34832ebb99cd5e31bc5c8ffc5beb5b3fa6f7ff0226aaa1cdf8e10e6d64b324","src/espidf.rs":"19f101486584fde6dad962f4d9792de168658047312106641a5caf6866a5bbcf","src/fuchsia.rs":"470d8509deb5b06fa6417f294c0a49e0e35a580249a5d8944c3be5aa746f64ea","src/ios.rs":"4bad4f5c096a50338b86aeac91a937c18bc55b9555e6f34806ad13732e64523d","src/js.rs":"04c750491ba3bcdad3609265938410ee09928c5d6dfd0d33d826a9884d13ac4c","src/lib.rs":"674af2d277b66ecf2e49e1059638abd58db089df095b8b65d9e347782e4bb1e0","src/linux_android.rs":"39cb80999c8534145240a350976d261b8924436bf9a4563960c7bd8c2c83c773","src/macos.rs":"b692f2fcc2319a5195f47751d5bd7dd87c7c24a61d14fa4e3dbc992ae66212b7","src/openbsd.rs":"066b2dd395c190444a658bb0b52a052eabbd68ea5a534fb729c7e5373abc0a6a","src/rdrand.rs":"79d23183b1905d61bd9df9729dc798505a2ed750d3339e342ab144e1709827e4","src/solaris_illumos.rs":"9c7004446fabe5a7a21c73d5a65d7e2115b5bd1d1dbb735c984cab3dba239785","src/solid.rs":"997035d54c9762d22a5a14f54e7fbed4dd266cdeacbdf6aab7d8aee05537e8ba","src/use_file.rs":"16e42eb0a56e375c330c1ca8eb58c444e82ef3ad35230b961fdba96a02a68804","src/util.rs":"da6964dc1523f1cb8d26365fa6a8ece46360587e6974931624b271f0c72cda8b","src/util_libc.rs":"9fd636b23121a86630f0c7891a310444f5b1bb29b0013290e130b79ed1e1f79e","src/vxworks.rs":"a5aa0e40f890e0f35626458bb656a3340b8af3111e4bacd2e12505a8d50a3505","src/wasi.rs":"02b3a75613dc80444847675ecfea59f390c2597ce1d3334612a8dba71f6082de","src/windows.rs":"e3c8f033d5d2a6b8abc5c92b005232f5aca8ce941bd94964a0f58f2436af9990","tests/common/mod.rs":"b6beee8f535d2d094a65711fe0af91a6fc220aa09729ed7269fe33cafdc9177f","tests/custom.rs":"9f2c0193193f6bcf641116ca0b3653b33d2015e0e98ce107ee1d1f60c5eeae3a","tests/normal.rs":"9e1c4b1e468a09ed0225370dfb6608f8b8135e0fabb09bbc1a718105164aade6","tests/rdrand.rs":"4474ccebf9d33c89288862a7e367018405968dddc55c7c6f97e21b5fe2264601"},"package":"9be70c98951c83b8d2f8f60d7065fa6d5146873094452a1008da8c2f1e4205ad"} \ No newline at end of file
diff --git a/vendor/getrandom/CHANGELOG.md b/vendor/getrandom/CHANGELOG.md
new file mode 100644
index 000000000..4ab267ae0
--- /dev/null
+++ b/vendor/getrandom/CHANGELOG.md
@@ -0,0 +1,318 @@
+# 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.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-dependend 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` isntead 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.2.5]: 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.15...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.toml b/vendor/getrandom/Cargo.toml
new file mode 100644
index 000000000..0a664244e
--- /dev/null
+++ b/vendor/getrandom/Cargo.toml
@@ -0,0 +1,59 @@
+# 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 = "2018"
+name = "getrandom"
+version = "0.2.6"
+authors = ["The Rand Project Developers"]
+exclude = [".*"]
+description = "A small cross-platform library for retrieving random data from system source"
+documentation = "https://docs.rs/getrandom"
+categories = ["os", "no-std"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/rust-random/getrandom"
+[package.metadata.docs.rs]
+features = ["std", "custom"]
+rustdoc-args = ["--cfg", "docsrs"]
+[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"
+
+[features]
+custom = []
+js = ["wasm-bindgen", "js-sys"]
+rdrand = []
+rustc-dep-of-std = ["compiler_builtins", "core", "libc/rustc-dep-of-std", "wasi/rustc-dep-of-std"]
+std = []
+test-in-browser = []
+[target."cfg(all(target_arch = \"wasm32\", target_os = \"unknown\"))".dependencies.js-sys]
+version = "0.3"
+optional = true
+
+[target."cfg(all(target_arch = \"wasm32\", target_os = \"unknown\"))".dependencies.wasm-bindgen]
+version = "0.2.62"
+optional = true
+default-features = false
+[target."cfg(all(target_arch = \"wasm32\", target_os = \"unknown\"))".dev-dependencies.wasm-bindgen-test]
+version = "0.3.18"
+[target."cfg(target_os = \"wasi\")".dependencies.wasi]
+version = "0.10"
+[target."cfg(unix)".dependencies.libc]
+version = "0.2.120"
+default-features = false
diff --git a/vendor/getrandom/LICENSE-APACHE b/vendor/getrandom/LICENSE-APACHE
new file mode 100644
index 000000000..17d74680f
--- /dev/null
+++ b/vendor/getrandom/LICENSE-APACHE
@@ -0,0 +1,201 @@
+ 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
new file mode 100644
index 000000000..d93b5baf3
--- /dev/null
+++ b/vendor/getrandom/LICENSE-MIT
@@ -0,0 +1,26 @@
+Copyright 2018 Developers of the Rand project
+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
new file mode 100644
index 000000000..df2307b9c
--- /dev/null
+++ b/vendor/getrandom/README.md
@@ -0,0 +1,64 @@
+# getrandom
+
+[![Build Status]][GitHub Actions] [![Crate]][crates.io] [![Documentation]][docs.rs] [![Dependency Status]][deps.rs] [![Downloads]][crates.io] [![License]][LICENSE-MIT]
+
+[GitHub Actions]: https://github.com/rust-random/getrandom/actions?query=workflow:Tests+branch:master
+[Build Status]: https://github.com/rust-random/getrandom/workflows/Tests/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-MIT]: https://raw.githubusercontent.com/rust-random/getrandom/master/LICENSE-MIT
+[License]: https://img.shields.io/crates/l/getrandom
+
+
+A Rust library for retrieving random data from (operating) system source. It is
+assumed that system always provides high-quality cryptographically secure random
+data, ideally backed by hardware entropy sources. This crate derives its name
+from Linux's `getrandom` function, but is cross platform, roughly supporting
+the same set of platforms as Rust's `std` lib.
+
+This is a low-level API. Most users should prefer using high-level random-number
+library like [`rand`].
+
+[`rand`]: https://crates.io/crates/rand
+
+## Usage
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+getrandom = "0.2"
+```
+
+Then invoke the `getrandom` function:
+
+```rust
+fn get_random_buf() -> Result<[u8; 32], getrandom::Error> {
+ let mut buf = [0u8; 32];
+ getrandom::getrandom(&mut buf)?;
+ Ok(buf)
+}
+```
+
+For more information about supported targets, entropy sources, `no_std` targets,
+crate features, WASM support and Custom RNGs see the
+[`getrandom` documentation](https://docs.rs/getrandom/latest) and
+[`getrandom::Error` documentation](https://docs.rs/getrandom/latest/getrandom/struct.Error.html).
+
+## Minimum Supported Rust Version
+
+This crate requires Rust 1.34.0 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.
diff --git a/vendor/getrandom/benches/mod.rs b/vendor/getrandom/benches/mod.rs
new file mode 100644
index 000000000..a93e72064
--- /dev/null
+++ b/vendor/getrandom/benches/mod.rs
@@ -0,0 +1,22 @@
+#![feature(test)]
+extern crate test;
+
+#[bench]
+fn bench_64(b: &mut test::Bencher) {
+ let mut buf = [0u8; 64];
+ b.iter(|| {
+ getrandom::getrandom(&mut buf[..]).unwrap();
+ test::black_box(&buf);
+ });
+ b.bytes = buf.len() as u64;
+}
+
+#[bench]
+fn bench_65536(b: &mut test::Bencher) {
+ let mut buf = [0u8; 65536];
+ b.iter(|| {
+ getrandom::getrandom(&mut buf[..]).unwrap();
+ test::black_box(&buf);
+ });
+ b.bytes = buf.len() as u64;
+}
diff --git a/vendor/getrandom/src/3ds.rs b/vendor/getrandom/src/3ds.rs
new file mode 100644
index 000000000..60305127e
--- /dev/null
+++ b/vendor/getrandom/src/3ds.rs
@@ -0,0 +1,17 @@
+// Copyright 2021 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementation for Nintendo 3DS
+use crate::util_libc::sys_fill_exact;
+use crate::Error;
+
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+ sys_fill_exact(dest, |buf| unsafe {
+ libc::getrandom(buf.as_mut_ptr() as *mut libc::c_void, buf.len(), 0)
+ })
+}
diff --git a/vendor/getrandom/src/bsd_arandom.rs b/vendor/getrandom/src/bsd_arandom.rs
new file mode 100644
index 000000000..f26f2609c
--- /dev/null
+++ b/vendor/getrandom/src/bsd_arandom.rs
@@ -0,0 +1,52 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementation for FreeBSD and NetBSD
+use crate::{util_libc::sys_fill_exact, Error};
+use core::ptr;
+
+fn kern_arnd(buf: &mut [u8]) -> libc::ssize_t {
+ static MIB: [libc::c_int; 2] = [libc::CTL_KERN, libc::KERN_ARND];
+ let mut len = buf.len();
+ let ret = unsafe {
+ libc::sysctl(
+ MIB.as_ptr(),
+ MIB.len() as libc::c_uint,
+ buf.as_mut_ptr() as *mut _,
+ &mut len,
+ ptr::null(),
+ 0,
+ )
+ };
+ if ret == -1 {
+ -1
+ } else {
+ len as libc::ssize_t
+ }
+}
+
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+ #[cfg(target_os = "freebsd")]
+ {
+ use crate::util_libc::Weak;
+ static GETRANDOM: Weak = unsafe { Weak::new("getrandom\0") };
+ type GetRandomFn =
+ unsafe extern "C" fn(*mut u8, libc::size_t, libc::c_uint) -> libc::ssize_t;
+
+ if let Some(fptr) = GETRANDOM.ptr() {
+ let func: GetRandomFn = unsafe { core::mem::transmute(fptr) };
+ return sys_fill_exact(dest, |buf| unsafe { func(buf.as_mut_ptr(), buf.len(), 0) });
+ }
+ }
+ // Both FreeBSD and NetBSD will only return up to 256 bytes at a time, and
+ // older NetBSD kernels will fail on longer buffers.
+ for chunk in dest.chunks_mut(256) {
+ sys_fill_exact(chunk, kern_arnd)?
+ }
+ Ok(())
+}
diff --git a/vendor/getrandom/src/custom.rs b/vendor/getrandom/src/custom.rs
new file mode 100644
index 000000000..6110b0563
--- /dev/null
+++ b/vendor/getrandom/src/custom.rs
@@ -0,0 +1,102 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! An implementation which calls out to an externally defined function.
+use crate::Error;
+use core::num::NonZeroU32;
+
+/// Register a function to be invoked by `getrandom` on unsupported targets.
+///
+/// ## Writing a custom `getrandom` implementation
+///
+/// The function to register must have the same signature as
+/// [`getrandom::getrandom`](crate::getrandom). The function can be defined
+/// wherever you want, either in root crate or a dependent crate.
+///
+/// For example, if we wanted a `failure-getrandom` crate containing an
+/// implementation that always fails, we would first depend on `getrandom`
+/// (for the [`Error`] type) in `failure-getrandom/Cargo.toml`:
+/// ```toml
+/// [dependencies]
+/// getrandom = "0.2"
+/// ```
+/// Note that the crate containing this function does **not** need to enable the
+/// `"custom"` Cargo feature.
+///
+/// Next, in `failure-getrandom/src/lib.rs`, we define our function:
+/// ```rust
+/// use core::num::NonZeroU32;
+/// use getrandom::Error;
+///
+/// // Some application-specific error code
+/// const MY_CUSTOM_ERROR_CODE: u32 = Error::CUSTOM_START + 42;
+/// pub fn always_fail(buf: &mut [u8]) -> Result<(), Error> {
+/// let code = NonZeroU32::new(MY_CUSTOM_ERROR_CODE).unwrap();
+/// Err(Error::from(code))
+/// }
+/// ```
+///
+/// ## Registering a custom `getrandom` implementation
+///
+/// Functions can only be registered in the root binary crate. Attempting to
+/// register a function in a non-root crate will result in a linker error.
+/// This is similar to
+/// [`#[panic_handler]`](https://doc.rust-lang.org/nomicon/panic-handler.html) or
+/// [`#[global_allocator]`](https://doc.rust-lang.org/edition-guide/rust-2018/platform-and-target-support/global-allocators.html),
+/// where helper crates define handlers/allocators but only the binary crate
+/// actually _uses_ the functionality.
+///
+/// To register the function, we first depend on `failure-getrandom` _and_
+/// `getrandom` in `Cargo.toml`:
+/// ```toml
+/// [dependencies]
+/// failure-getrandom = "0.1"
+/// getrandom = { version = "0.2", features = ["custom"] }
+/// ```
+///
+/// Then, we register the function in `src/main.rs`:
+/// ```rust
+/// # mod failure_getrandom { pub fn always_fail(_: &mut [u8]) -> Result<(), getrandom::Error> { unimplemented!() } }
+/// use failure_getrandom::always_fail;
+/// use getrandom::register_custom_getrandom;
+///
+/// register_custom_getrandom!(always_fail);
+/// ```
+///
+/// Now any user of `getrandom` (direct or indirect) on this target will use the
+/// registered function. As noted in the
+/// [top-level documentation](index.html#custom-implementations) this
+/// registration only has an effect on unsupported targets.
+#[macro_export]
+#[cfg_attr(docsrs, doc(cfg(feature = "custom")))]
+macro_rules! register_custom_getrandom {
+ ($path:path) => {
+ // We use an extern "C" function to get the guarantees of a stable ABI.
+ #[no_mangle]
+ extern "C" fn __getrandom_custom(dest: *mut u8, len: usize) -> u32 {
+ let f: fn(&mut [u8]) -> Result<(), ::getrandom::Error> = $path;
+ let slice = unsafe { ::core::slice::from_raw_parts_mut(dest, len) };
+ match f(slice) {
+ Ok(()) => 0,
+ Err(e) => e.code().get(),
+ }
+ }
+ };
+}
+
+#[allow(dead_code)]
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+ extern "C" {
+ fn __getrandom_custom(dest: *mut u8, len: usize) -> u32;
+ }
+ let ret = unsafe { __getrandom_custom(dest.as_mut_ptr(), dest.len()) };
+ match NonZeroU32::new(ret) {
+ None => Ok(()),
+ Some(code) => Err(Error::from(code)),
+ }
+}
diff --git a/vendor/getrandom/src/dragonfly.rs b/vendor/getrandom/src/dragonfly.rs
new file mode 100644
index 000000000..f27e90690
--- /dev/null
+++ b/vendor/getrandom/src/dragonfly.rs
@@ -0,0 +1,26 @@
+// Copyright 2021 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementation for DragonFly BSD
+use crate::{
+ use_file,
+ util_libc::{sys_fill_exact, Weak},
+ Error,
+};
+
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+ static GETRANDOM: Weak = unsafe { Weak::new("getrandom\0") };
+ type GetRandomFn = unsafe extern "C" fn(*mut u8, libc::size_t, libc::c_uint) -> libc::ssize_t;
+
+ if let Some(fptr) = GETRANDOM.ptr() {
+ let func: GetRandomFn = unsafe { core::mem::transmute(fptr) };
+ return sys_fill_exact(dest, |buf| unsafe { func(buf.as_mut_ptr(), buf.len(), 0) });
+ } else {
+ use_file::getrandom_inner(dest)
+ }
+}
diff --git a/vendor/getrandom/src/error.rs b/vendor/getrandom/src/error.rs
new file mode 100644
index 000000000..661575376
--- /dev/null
+++ b/vendor/getrandom/src/error.rs
@@ -0,0 +1,191 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+use core::{fmt, num::NonZeroU32};
+
+/// 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.
+///
+/// Internally this type is a NonZeroU32, with certain values reserved for
+/// certain purposes, see [`Error::INTERNAL_START`] and [`Error::CUSTOM_START`].
+///
+/// *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).
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub struct Error(NonZeroU32);
+
+const fn internal_error(n: u16) -> Error {
+ // SAFETY: code > 0 as INTERNAL_START > 0 and adding n won't overflow a u32.
+ let code = Error::INTERNAL_START + (n as u32);
+ Error(unsafe { NonZeroU32::new_unchecked(code) })
+}
+
+impl Error {
+ /// This target/platform is not supported by `getrandom`.
+ pub const UNSUPPORTED: Error = internal_error(0);
+ /// The platform-specific `errno` returned a non-positive value.
+ pub const ERRNO_NOT_POSITIVE: Error = internal_error(1);
+ /// Call to iOS [`SecRandomCopyBytes`](https://developer.apple.com/documentation/security/1399291-secrandomcopybytes) failed.
+ pub const IOS_SEC_RANDOM: Error = internal_error(3);
+ /// Call to Windows [`RtlGenRandom`](https://docs.microsoft.com/en-us/windows/win32/api/ntsecapi/nf-ntsecapi-rtlgenrandom) failed.
+ pub const WINDOWS_RTL_GEN_RANDOM: Error = internal_error(4);
+ /// RDRAND instruction failed due to a hardware issue.
+ pub const FAILED_RDRAND: Error = internal_error(5);
+ /// RDRAND instruction unsupported on this target.
+ pub const NO_RDRAND: Error = internal_error(6);
+ /// The browser does not have support for `self.crypto`.
+ pub const WEB_CRYPTO: Error = internal_error(7);
+ /// The browser does not have support for `crypto.getRandomValues`.
+ pub const WEB_GET_RANDOM_VALUES: Error = internal_error(8);
+ /// On VxWorks, call to `randSecure` failed (random number generator is not yet initialized).
+ pub const VXWORKS_RAND_SECURE: Error = internal_error(11);
+ /// NodeJS does not have support for the `crypto` module.
+ pub const NODE_CRYPTO: Error = internal_error(12);
+ /// NodeJS does not have support for `crypto.randomFillSync`.
+ pub const NODE_RANDOM_FILL_SYNC: Error = internal_error(13);
+
+ /// Codes below this point represent OS Errors (i.e. positive i32 values).
+ /// Codes at or above this point, but below [`Error::CUSTOM_START`] are
+ /// reserved for use by the `rand` and `getrandom` crates.
+ pub const INTERNAL_START: u32 = 1 << 31;
+
+ /// Codes at or above this point can be used by users to define their own
+ /// custom errors.
+ pub const CUSTOM_START: u32 = (1 << 31) + (1 << 30);
+
+ /// 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. 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
+ #[inline]
+ pub fn raw_os_error(self) -> Option<i32> {
+ if self.0.get() < Self::INTERNAL_START {
+ match () {
+ #[cfg(target_os = "solid_asp3")]
+ // On SOLID, negate the error code again to obtain the original
+ // error code.
+ () => Some(-(self.0.get() as i32)),
+ #[cfg(not(target_os = "solid_asp3"))]
+ () => Some(self.0.get() as i32),
+ }
+ } else {
+ None
+ }
+ }
+
+ /// Extract the bare error code.
+ ///
+ /// This code can either come from the underlying OS, or be a custom error.
+ /// Use [`Error::raw_os_error()`] to disambiguate.
+ #[inline]
+ pub const fn code(self) -> NonZeroU32 {
+ self.0
+ }
+}
+
+cfg_if! {
+ if #[cfg(unix)] {
+ fn os_err(errno: i32, buf: &mut [u8]) -> Option<&str> {
+ let buf_ptr = buf.as_mut_ptr() as *mut libc::c_char;
+ if unsafe { libc::strerror_r(errno, buf_ptr, buf.len()) } != 0 {
+ return None;
+ }
+
+ // Take up to trailing null byte
+ let n = buf.len();
+ let idx = buf.iter().position(|&b| b == 0).unwrap_or(n);
+ core::str::from_utf8(&buf[..idx]).ok()
+ }
+ } else if #[cfg(target_os = "wasi")] {
+ fn os_err(errno: i32, _buf: &mut [u8]) -> Option<wasi::Error> {
+ wasi::Error::from_raw_error(errno as _)
+ }
+ } else {
+ fn os_err(_errno: i32, _buf: &mut [u8]) -> Option<&str> {
+ None
+ }
+ }
+}
+
+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);
+ let mut buf = [0u8; 128];
+ if let Some(err) = os_err(errno, &mut buf) {
+ dbg.field("description", &err);
+ }
+ } else if let Some(desc) = internal_desc(*self) {
+ 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() {
+ let mut buf = [0u8; 128];
+ match os_err(errno, &mut buf) {
+ Some(err) => err.fmt(f),
+ None => write!(f, "OS Error: {}", errno),
+ }
+ } else if let Some(desc) = internal_desc(*self) {
+ f.write_str(desc)
+ } else {
+ write!(f, "Unknown Error: {}", self.0.get())
+ }
+ }
+}
+
+impl From<NonZeroU32> for Error {
+ fn from(code: NonZeroU32) -> Self {
+ Self(code)
+ }
+}
+
+fn internal_desc(error: Error) -> Option<&'static str> {
+ match error {
+ Error::UNSUPPORTED => Some("getrandom: this target is not supported"),
+ Error::ERRNO_NOT_POSITIVE => Some("errno: did not return a positive value"),
+ Error::IOS_SEC_RANDOM => Some("SecRandomCopyBytes: iOS Security framework failure"),
+ Error::WINDOWS_RTL_GEN_RANDOM => Some("RtlGenRandom: Windows system function failure"),
+ Error::FAILED_RDRAND => Some("RDRAND: failed multiple times: CPU issue likely"),
+ Error::NO_RDRAND => Some("RDRAND: instruction not supported"),
+ Error::WEB_CRYPTO => Some("Web Crypto API is unavailable"),
+ Error::WEB_GET_RANDOM_VALUES => Some("Web API crypto.getRandomValues is unavailable"),
+ Error::VXWORKS_RAND_SECURE => Some("randSecure: VxWorks RNG module is not initialized"),
+ Error::NODE_CRYPTO => Some("Node.js crypto module is unavailable"),
+ Error::NODE_RANDOM_FILL_SYNC => Some("Node.js API crypto.randomFillSync is unavailable"),
+ _ => None,
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::Error;
+ use core::mem::size_of;
+
+ #[test]
+ fn test_size() {
+ assert_eq!(size_of::<Error>(), 4);
+ assert_eq!(size_of::<Result<(), Error>>(), 4);
+ }
+}
diff --git a/vendor/getrandom/src/error_impls.rs b/vendor/getrandom/src/error_impls.rs
new file mode 100644
index 000000000..61f46d227
--- /dev/null
+++ b/vendor/getrandom/src/error_impls.rs
@@ -0,0 +1,24 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+#![cfg_attr(docsrs, doc(cfg(feature = "std")))]
+extern crate std;
+
+use crate::Error;
+use core::convert::From;
+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/espidf.rs b/vendor/getrandom/src/espidf.rs
new file mode 100644
index 000000000..dce8a2aa0
--- /dev/null
+++ b/vendor/getrandom/src/espidf.rs
@@ -0,0 +1,26 @@
+// Copyright 2021 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementation for ESP-IDF
+use crate::Error;
+use core::ffi::c_void;
+
+extern "C" {
+ fn esp_fill_random(buf: *mut c_void, len: usize) -> u32;
+}
+
+pub fn getrandom_inner(dest: &mut [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/fuchsia.rs b/vendor/getrandom/src/fuchsia.rs
new file mode 100644
index 000000000..572ff5344
--- /dev/null
+++ b/vendor/getrandom/src/fuchsia.rs
@@ -0,0 +1,20 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementation for Fuchsia Zircon
+use crate::Error;
+
+#[link(name = "zircon")]
+extern "C" {
+ fn zx_cprng_draw(buffer: *mut u8, length: usize);
+}
+
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+ unsafe { zx_cprng_draw(dest.as_mut_ptr(), dest.len()) }
+ Ok(())
+}
diff --git a/vendor/getrandom/src/ios.rs b/vendor/getrandom/src/ios.rs
new file mode 100644
index 000000000..226de16bd
--- /dev/null
+++ b/vendor/getrandom/src/ios.rs
@@ -0,0 +1,27 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementation for iOS
+use crate::Error;
+use core::{ffi::c_void, ptr::null};
+
+#[link(name = "Security", kind = "framework")]
+extern "C" {
+ fn SecRandomCopyBytes(rnd: *const c_void, count: usize, bytes: *mut u8) -> i32;
+}
+
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+ // Apple's documentation guarantees kSecRandomDefault is a synonym for NULL.
+ let ret = unsafe { SecRandomCopyBytes(null(), dest.len(), dest.as_mut_ptr()) };
+ // errSecSuccess (from SecBase.h) is always zero.
+ if ret != 0 {
+ Err(Error::IOS_SEC_RANDOM)
+ } else {
+ Ok(())
+ }
+}
diff --git a/vendor/getrandom/src/js.rs b/vendor/getrandom/src/js.rs
new file mode 100644
index 000000000..e910f2bc6
--- /dev/null
+++ b/vendor/getrandom/src/js.rs
@@ -0,0 +1,129 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+use crate::Error;
+
+extern crate std;
+use std::thread_local;
+
+use js_sys::{global, Uint8Array};
+use wasm_bindgen::{prelude::wasm_bindgen, JsCast, JsValue};
+
+// Maximum is 65536 bytes see https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
+const BROWSER_CRYPTO_BUFFER_SIZE: usize = 256;
+
+enum RngSource {
+ Node(NodeCrypto),
+ Browser(BrowserCrypto, Uint8Array),
+}
+
+// JsValues are always per-thread, so we initialize RngSource for each thread.
+// See: https://github.com/rustwasm/wasm-bindgen/pull/955
+thread_local!(
+ static RNG_SOURCE: Result<RngSource, Error> = getrandom_init();
+);
+
+pub(crate) fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+ RNG_SOURCE.with(|result| {
+ let source = result.as_ref().map_err(|&e| e)?;
+
+ match source {
+ RngSource::Node(n) => {
+ if n.random_fill_sync(dest).is_err() {
+ return Err(Error::NODE_RANDOM_FILL_SYNC);
+ }
+ }
+ RngSource::Browser(crypto, buf) => {
+ // getRandomValues does not work with all types of WASM memory,
+ // so we initially write to browser memory to avoid exceptions.
+ for chunk in dest.chunks_mut(BROWSER_CRYPTO_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 = buf.subarray(0, chunk.len() as u32);
+
+ if crypto.get_random_values(&sub_buf).is_err() {
+ return Err(Error::WEB_GET_RANDOM_VALUES);
+ }
+ sub_buf.copy_to(chunk);
+ }
+ }
+ };
+ Ok(())
+ })
+}
+
+fn getrandom_init() -> Result<RngSource, Error> {
+ let global: Global = global().unchecked_into();
+ if is_node(&global) {
+ let crypto = NODE_MODULE
+ .require("crypto")
+ .map_err(|_| Error::NODE_CRYPTO)?;
+ return Ok(RngSource::Node(crypto));
+ }
+
+ // Assume we are in some Web environment (browser or web worker). We get
+ // `self.crypto` (called `msCrypto` on IE), so we can call
+ // `crypto.getRandomValues`. If `crypto` isn't defined, we assume that
+ // we are in an older web browser and the OS RNG isn't available.
+ let crypto = match (global.crypto(), global.ms_crypto()) {
+ (c, _) if c.is_object() => c,
+ (_, c) if c.is_object() => c,
+ _ => return Err(Error::WEB_CRYPTO),
+ };
+
+ let buf = Uint8Array::new_with_length(BROWSER_CRYPTO_BUFFER_SIZE as u32);
+ Ok(RngSource::Browser(crypto, buf))
+}
+
+// Taken from https://www.npmjs.com/package/browser-or-node
+fn is_node(global: &Global) -> bool {
+ let process = global.process();
+ if process.is_object() {
+ let versions = process.versions();
+ if versions.is_object() {
+ return versions.node().is_string();
+ }
+ }
+ false
+}
+
+#[wasm_bindgen]
+extern "C" {
+ type Global; // Return type of js_sys::global()
+
+ // Web Crypto API (https://www.w3.org/TR/WebCryptoAPI/)
+ #[wasm_bindgen(method, getter, js_name = "msCrypto")]
+ fn ms_crypto(this: &Global) -> BrowserCrypto;
+ #[wasm_bindgen(method, getter)]
+ fn crypto(this: &Global) -> BrowserCrypto;
+ type BrowserCrypto;
+ #[wasm_bindgen(method, js_name = getRandomValues, catch)]
+ fn get_random_values(this: &BrowserCrypto, buf: &Uint8Array) -> Result<(), JsValue>;
+
+ // We use a "module" object here instead of just annotating require() with
+ // js_name = "module.require", so that Webpack doesn't give a warning. See:
+ // https://github.com/rust-random/getrandom/issues/224
+ type NodeModule;
+ #[wasm_bindgen(js_name = module)]
+ static NODE_MODULE: NodeModule;
+ // Node JS crypto module (https://nodejs.org/api/crypto.html)
+ #[wasm_bindgen(method, catch)]
+ fn require(this: &NodeModule, s: &str) -> Result<NodeCrypto, JsValue>;
+ type NodeCrypto;
+ #[wasm_bindgen(method, js_name = randomFillSync, catch)]
+ fn random_fill_sync(this: &NodeCrypto, buf: &mut [u8]) -> Result<(), JsValue>;
+
+ // Node JS process Object (https://nodejs.org/api/process.html)
+ #[wasm_bindgen(method, getter)]
+ fn process(this: &Global) -> Process;
+ type Process;
+ #[wasm_bindgen(method, getter)]
+ fn versions(this: &Process) -> Versions;
+ type Versions;
+ #[wasm_bindgen(method, getter)]
+ fn node(this: &Versions) -> JsValue;
+}
diff --git a/vendor/getrandom/src/lib.rs b/vendor/getrandom/src/lib.rs
new file mode 100644
index 000000000..888b9a510
--- /dev/null
+++ b/vendor/getrandom/src/lib.rs
@@ -0,0 +1,263 @@
+// Copyright 2019 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Interface to the operating system's random number generator.
+//!
+//! # 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 | `*‑windows‑*` | [`BCryptGenRandom`]
+//! | macOS | `*‑apple‑darwin` | [`getentropy`][3] if available, otherwise [`/dev/random`][4] (identical to `/dev/urandom`)
+//! | iOS | `*‑apple‑ios` | [`SecRandomCopyBytes`]
+//! | FreeBSD | `*‑freebsd` | [`getrandom`][5] if available, otherwise [`kern.arandom`][6]
+//! | OpenBSD | `*‑openbsd` | [`getentropy`][7]
+//! | NetBSD | `*‑netbsd` | [`kern.arandom`][8]
+//! | Dragonfly BSD | `*‑dragonfly` | [`getrandom`][9] if available, otherwise [`/dev/random`][10]
+//! | Solaris, illumos | `*‑solaris`, `*‑illumos` | [`getrandom`][11] if available, otherwise [`/dev/random`][12]
+//! | Fuchsia OS | `*‑fuchsia` | [`cprng_draw`]
+//! | Redox | `*‑redox` | `/dev/urandom`
+//! | Haiku | `*‑haiku` | `/dev/random` (identical to `/dev/urandom`)
+//! | Hermit | `x86_64-*-hermit` | [`RDRAND`]
+//! | SGX | `x86_64‑*‑sgx` | [`RDRAND`]
+//! | VxWorks | `*‑wrs‑vxworks‑*` | `randABytes` after checking entropy pool initialization with `randSecure`
+//! | ESP-IDF | `*‑espidf` | [`esp_fill_random`]
+//! | Emscripten | `*‑emscripten` | `/dev/random` (identical to `/dev/urandom`)
+//! | WASI | `wasm32‑wasi` | [`random_get`]
+//! | Web Browser | `wasm32‑*‑unknown` | [`Crypto.getRandomValues`], see [WebAssembly support]
+//! | Node.js | `wasm32‑*‑unknown` | [`crypto.randomBytes`], see [WebAssembly support]
+//! | SOLID | `*-kmc-solid_*` | `SOLID_RNG_SampleRandomBytes`
+//! | Nintendo 3DS | `armv6k-nintendo-3ds` | [`getrandom`][1]
+//!
+//! There is no blanket implementation on `unix` targets that reads from
+//! `/dev/urandom`. This ensures all supported targets are using the recommended
+//! interface and respect maximum buffer sizes.
+//!
+//! Pull Requests that add support for new targets to `getrandom` are always welcome.
+//!
+//! ## Unsupported targets
+//!
+//! By default, `getrandom` will not compile on unsupported targets, but certain
+//! features allow a user to select a "fallback" implementation if no supported
+//! implementation exists.
+//!
+//! All of the below mechanisms only affect unsupported
+//! targets. Supported targets will _always_ use their supported implementations.
+//! This prevents a crate from overriding a secure source of randomness
+//! (either accidentally or intentionally).
+//!
+//! ### RDRAND on x86
+//!
+//! *If the `rdrand` Cargo feature is enabled*, `getrandom` will fallback to using
+//! the [`RDRAND`] instruction to get randomness on `no_std` `x86`/`x86_64`
+//! targets. This feature has no effect on other CPU architectures.
+//!
+//! ### WebAssembly support
+//!
+//! This crate fully supports the
+//! [`wasm32-wasi`](https://github.com/CraneStation/wasi) and
+//! [`wasm32-unknown-emscripten`](https://www.hellorust.com/setup/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 is in use (or if JavaScript is available at all).
+//!
+//! Instead, *if the `js` Cargo feature is enabled*, this crate will assume
+//! that you are building for an environment containing JavaScript, and will
+//! call the appropriate methods. Both web browser (main window and Web Workers)
+//! and Node.js environments are supported, invoking the methods
+//! [described above](#supported-targets) using the
+//! [wasm-bindgen](https://github.com/rust-lang/rust-bindgen) toolchain.
+//!
+//! This feature has no effect on targets other than `wasm32-unknown-unknown`.
+//!
+//! ### Custom implementations
+//!
+//! The [`register_custom_getrandom!`] macro allows a user to mark their own
+//! function as the backing implementation for [`getrandom`]. See the macro's
+//! documentation for more information about writing and registering your own
+//! custom implementations.
+//!
+//! Note that registering a custom implementation only has an effect on targets
+//! that would otherwise not compile. Any supported targets (including those
+//! using `rdrand` and `js` Cargo features) continue using their normal
+//! implementations even if a function is registered.
+//!
+//! ### Indirect Dependencies
+//!
+//! If `getrandom` is not a direct dependency of your crate, you can still
+//! enable any of the above fallback behaviors by enabling the relevant
+//! feature in your root crate's `Cargo.toml`:
+//! ```toml
+//! [dependencies]
+//! getrandom = { version = "0.2", features = ["js"] }
+//! ```
+//!
+//! ## 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.
+//!
+//! ## Error handling
+//!
+//! We always choose failure over returning insecure "random" bytes. In general,
+//! on supported platforms, failure is highly unlikely, though not impossible.
+//! If an error does occur, then it is likely that it will occur on every call to
+//! `getrandom`, hence after the first successful call one can be reasonably
+//! confident that no errors will occur.
+//!
+//! [1]: http://man7.org/linux/man-pages/man2/getrandom.2.html
+//! [2]: http://man7.org/linux/man-pages/man4/urandom.4.html
+//! [3]: https://www.unix.com/man-page/mojave/2/getentropy/
+//! [4]: https://www.unix.com/man-page/mojave/4/random/
+//! [5]: https://www.freebsd.org/cgi/man.cgi?query=getrandom&manpath=FreeBSD+12.0-stable
+//! [6]: https://www.freebsd.org/cgi/man.cgi?query=random&sektion=4
+//! [7]: https://man.openbsd.org/getentropy.2
+//! [8]: https://man.netbsd.org/sysctl.7
+//! [9]: https://leaf.dragonflybsd.org/cgi/web-man?command=getrandom
+//! [10]: https://leaf.dragonflybsd.org/cgi/web-man?command=random&section=4
+//! [11]: https://docs.oracle.com/cd/E88353_01/html/E37841/getrandom-2.html
+//! [12]: https://docs.oracle.com/cd/E86824_01/html/E54777/random-7d.html
+//!
+//! [`BCryptGenRandom`]: https://docs.microsoft.com/en-us/windows/win32/api/bcrypt/nf-bcrypt-bcryptgenrandom
+//! [`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
+//! [`SecRandomCopyBytes`]: https://developer.apple.com/documentation/security/1399291-secrandomcopybytes?language=objc
+//! [`cprng_draw`]: https://fuchsia.dev/fuchsia-src/zircon/syscalls/cprng_draw
+//! [`crypto.randomBytes`]: https://nodejs.org/api/crypto.html#crypto_crypto_randombytes_size_callback
+//! [`esp_fill_random`]: https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/system/random.html#_CPPv415esp_fill_randomPv6size_t
+//! [`random_get`]: https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md#-random_getbuf-pointeru8-buf_len-size---errno
+//! [WebAssembly support]: #webassembly-support
+
+#![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",
+ html_root_url = "https://docs.rs/getrandom/0.2.6"
+)]
+#![no_std]
+#![warn(rust_2018_idioms, unused_lifetimes, missing_docs)]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+
+#[macro_use]
+extern crate cfg_if;
+
+mod error;
+mod util;
+// To prevent a breaking change when targets are added, we always export the
+// register_custom_getrandom macro, so old Custom RNG crates continue to build.
+#[cfg(feature = "custom")]
+mod custom;
+#[cfg(feature = "std")]
+mod error_impls;
+
+pub use crate::error::Error;
+
+// System-specific implementations.
+//
+// These should all provide getrandom_inner with the same signature as getrandom.
+cfg_if! {
+ if #[cfg(any(target_os = "emscripten", target_os = "haiku",
+ target_os = "redox"))] {
+ mod util_libc;
+ #[path = "use_file.rs"] mod imp;
+ } else if #[cfg(any(target_os = "android", target_os = "linux"))] {
+ mod util_libc;
+ mod use_file;
+ #[path = "linux_android.rs"] mod imp;
+ } else if #[cfg(any(target_os = "illumos", target_os = "solaris"))] {
+ mod util_libc;
+ mod use_file;
+ #[path = "solaris_illumos.rs"] mod imp;
+ } else if #[cfg(any(target_os = "freebsd", target_os = "netbsd"))] {
+ mod util_libc;
+ #[path = "bsd_arandom.rs"] mod imp;
+ } else if #[cfg(target_os = "dragonfly")] {
+ mod util_libc;
+ mod use_file;
+ #[path = "dragonfly.rs"] mod imp;
+ } else if #[cfg(target_os = "fuchsia")] {
+ #[path = "fuchsia.rs"] mod imp;
+ } else if #[cfg(target_os = "ios")] {
+ #[path = "ios.rs"] mod imp;
+ } else if #[cfg(target_os = "macos")] {
+ mod util_libc;
+ mod use_file;
+ #[path = "macos.rs"] mod imp;
+ } else if #[cfg(target_os = "openbsd")] {
+ mod util_libc;
+ #[path = "openbsd.rs"] mod imp;
+ } else if #[cfg(target_os = "wasi")] {
+ #[path = "wasi.rs"] mod imp;
+ } else if #[cfg(all(target_arch = "x86_64", target_os = "hermit"))] {
+ #[path = "rdrand.rs"] mod imp;
+ } else if #[cfg(target_os = "vxworks")] {
+ mod util_libc;
+ #[path = "vxworks.rs"] mod imp;
+ } else if #[cfg(target_os = "solid_asp3")] {
+ #[path = "solid.rs"] mod imp;
+ } else if #[cfg(target_os = "espidf")] {
+ #[path = "espidf.rs"] mod imp;
+ } else if #[cfg(windows)] {
+ #[path = "windows.rs"] mod imp;
+ } else if #[cfg(all(target_arch = "x86_64", target_env = "sgx"))] {
+ #[path = "rdrand.rs"] mod imp;
+ } else if #[cfg(all(feature = "rdrand",
+ any(target_arch = "x86_64", target_arch = "x86")))] {
+ #[path = "rdrand.rs"] mod imp;
+ } else if #[cfg(all(feature = "js",
+ target_arch = "wasm32", target_os = "unknown"))] {
+ #[path = "js.rs"] mod imp;
+ } else if #[cfg(all(target_os = "horizon", target_arch = "arm"))] {
+ // We check for target_arch = "arm" because the Nintendo Switch also
+ // uses Horizon OS (it is aarch64).
+ mod util_libc;
+ #[path = "3ds.rs"] mod imp;
+ } else if #[cfg(feature = "custom")] {
+ use custom as imp;
+ } else if #[cfg(all(target_arch = "wasm32", target_os = "unknown"))] {
+ compile_error!("the wasm32-unknown-unknown target is not supported by \
+ default, you may need to enable the \"js\" feature. \
+ For more information see: \
+ https://docs.rs/getrandom/#webassembly-support");
+ } else {
+ compile_error!("target is not supported, for more information see: \
+ https://docs.rs/getrandom/#unsupported-targets");
+ }
+}
+
+/// 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).
+pub fn getrandom(dest: &mut [u8]) -> Result<(), Error> {
+ if dest.is_empty() {
+ return Ok(());
+ }
+ imp::getrandom_inner(dest)
+}
diff --git a/vendor/getrandom/src/linux_android.rs b/vendor/getrandom/src/linux_android.rs
new file mode 100644
index 000000000..5508fdd06
--- /dev/null
+++ b/vendor/getrandom/src/linux_android.rs
@@ -0,0 +1,46 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementation for Linux / Android
+use crate::{
+ util::LazyBool,
+ util_libc::{last_os_error, sys_fill_exact},
+ {use_file, Error},
+};
+
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+ static HAS_GETRANDOM: LazyBool = LazyBool::new();
+ if HAS_GETRANDOM.unsync_init(is_getrandom_available) {
+ sys_fill_exact(dest, |buf| unsafe {
+ getrandom(buf.as_mut_ptr() as *mut libc::c_void, buf.len(), 0)
+ })
+ } else {
+ use_file::getrandom_inner(dest)
+ }
+}
+
+fn is_getrandom_available() -> bool {
+ let res = unsafe { getrandom(core::ptr::null_mut(), 0, libc::GRND_NONBLOCK) };
+ if res < 0 {
+ match last_os_error().raw_os_error() {
+ Some(libc::ENOSYS) => false, // No kernel support
+ Some(libc::EPERM) => false, // Blocked by seccomp
+ _ => true,
+ }
+ } else {
+ true
+ }
+}
+
+unsafe fn getrandom(
+ buf: *mut libc::c_void,
+ buflen: libc::size_t,
+ flags: libc::c_uint,
+) -> libc::ssize_t {
+ libc::syscall(libc::SYS_getrandom, buf, buflen, flags) as libc::ssize_t
+}
diff --git a/vendor/getrandom/src/macos.rs b/vendor/getrandom/src/macos.rs
new file mode 100644
index 000000000..585a35abd
--- /dev/null
+++ b/vendor/getrandom/src/macos.rs
@@ -0,0 +1,35 @@
+// Copyright 2019 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementation for macOS
+use crate::{
+ use_file,
+ util_libc::{last_os_error, Weak},
+ Error,
+};
+use core::mem;
+
+type GetEntropyFn = unsafe extern "C" fn(*mut u8, libc::size_t) -> libc::c_int;
+
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+ static GETENTROPY: Weak = unsafe { Weak::new("getentropy\0") };
+ if let Some(fptr) = GETENTROPY.ptr() {
+ let func: GetEntropyFn = unsafe { mem::transmute(fptr) };
+ for chunk in dest.chunks_mut(256) {
+ let ret = unsafe { func(chunk.as_mut_ptr(), chunk.len()) };
+ if ret != 0 {
+ return Err(last_os_error());
+ }
+ }
+ Ok(())
+ } else {
+ // We fallback to reading from /dev/random instead of SecRandomCopyBytes
+ // to avoid high startup costs and linking the Security framework.
+ use_file::getrandom_inner(dest)
+ }
+}
diff --git a/vendor/getrandom/src/openbsd.rs b/vendor/getrandom/src/openbsd.rs
new file mode 100644
index 000000000..c8d28b3d8
--- /dev/null
+++ b/vendor/getrandom/src/openbsd.rs
@@ -0,0 +1,20 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementation for OpenBSD
+use crate::{util_libc::last_os_error, Error};
+
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+ for chunk in dest.chunks_mut(256) {
+ let ret = unsafe { libc::getentropy(chunk.as_mut_ptr() as *mut libc::c_void, chunk.len()) };
+ if ret == -1 {
+ return Err(last_os_error());
+ }
+ }
+ Ok(())
+}
diff --git a/vendor/getrandom/src/rdrand.rs b/vendor/getrandom/src/rdrand.rs
new file mode 100644
index 000000000..1df21e5d9
--- /dev/null
+++ b/vendor/getrandom/src/rdrand.rs
@@ -0,0 +1,97 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementation for SGX using RDRAND instruction
+use crate::Error;
+use core::mem;
+
+cfg_if! {
+ if #[cfg(target_arch = "x86_64")] {
+ use core::arch::x86_64 as arch;
+ use arch::_rdrand64_step as rdrand_step;
+ } else if #[cfg(target_arch = "x86")] {
+ use core::arch::x86 as arch;
+ use arch::_rdrand32_step as rdrand_step;
+ }
+}
+
+// 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;
+const WORD_SIZE: usize = mem::size_of::<usize>();
+
+#[target_feature(enable = "rdrand")]
+unsafe fn rdrand() -> Result<[u8; WORD_SIZE], Error> {
+ for _ in 0..RETRY_LIMIT {
+ let mut el = mem::zeroed();
+ if rdrand_step(&mut el) == 1 {
+ // AMD CPUs from families 14h to 16h (pre Ryzen) sometimes fail to
+ // set CF on bogus random data, so we check these values explicitly.
+ // See https://github.com/systemd/systemd/issues/11810#issuecomment-489727505
+ // We perform this check regardless of target to guard against
+ // any implementation that incorrectly fails to set CF.
+ if el != 0 && el != !0 {
+ return Ok(el.to_ne_bytes());
+ }
+ // Keep looping in case this was a false positive.
+ }
+ }
+ Err(Error::FAILED_RDRAND)
+}
+
+// "rdrand" target feature requires "+rdrnd" 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=+rdrnd."
+);
+
+#[cfg(target_feature = "rdrand")]
+fn is_rdrand_supported() -> bool {
+ true
+}
+
+// TODO use is_x86_feature_detected!("rdrand") when that works in core. See:
+// https://github.com/rust-lang-nursery/stdsimd/issues/464
+#[cfg(not(target_feature = "rdrand"))]
+fn is_rdrand_supported() -> bool {
+ use crate::util::LazyBool;
+
+ // SAFETY: All Rust x86 targets are new enough to have CPUID, and if CPUID
+ // is supported, CPUID leaf 1 is always supported.
+ const FLAG: u32 = 1 << 30;
+ static HAS_RDRAND: LazyBool = LazyBool::new();
+ HAS_RDRAND.unsync_init(|| unsafe { (arch::__cpuid(1).ecx & FLAG) != 0 })
+}
+
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+ if !is_rdrand_supported() {
+ return Err(Error::NO_RDRAND);
+ }
+
+ // SAFETY: After this point, rdrand is supported, so calling the rdrand
+ // functions is not undefined behavior.
+ unsafe { rdrand_exact(dest) }
+}
+
+#[target_feature(enable = "rdrand")]
+unsafe fn rdrand_exact(dest: &mut [u8]) -> Result<(), Error> {
+ // 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(WORD_SIZE);
+ for chunk in chunks.by_ref() {
+ chunk.copy_from_slice(&rdrand()?);
+ }
+
+ let tail = chunks.into_remainder();
+ let n = tail.len();
+ if n > 0 {
+ tail.copy_from_slice(&rdrand()?[..n]);
+ }
+ Ok(())
+}
diff --git a/vendor/getrandom/src/solaris_illumos.rs b/vendor/getrandom/src/solaris_illumos.rs
new file mode 100644
index 000000000..2d1b767bb
--- /dev/null
+++ b/vendor/getrandom/src/solaris_illumos.rs
@@ -0,0 +1,47 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementation for the Solaris family
+//!
+//! Read from `/dev/random`, with chunks of limited size (256 bytes).
+//! `/dev/random` uses the Hash_DRBG with SHA512 algorithm from NIST SP 800-90A.
+//! `/dev/urandom` uses the FIPS 186-2 algorithm, which is considered less
+//! secure. We choose to read from `/dev/random`.
+//!
+//! Since Solaris 11.3 and mid-2015 illumos, the `getrandom` syscall is available.
+//! To make sure we can compile on both Solaris and its derivatives, as well as
+//! function, we check for the existence of getrandom(2) in libc by calling
+//! libc::dlsym.
+use crate::{
+ use_file,
+ util_libc::{sys_fill_exact, Weak},
+ Error,
+};
+use core::mem;
+
+#[cfg(target_os = "illumos")]
+type GetRandomFn = unsafe extern "C" fn(*mut u8, libc::size_t, libc::c_uint) -> libc::ssize_t;
+#[cfg(target_os = "solaris")]
+type GetRandomFn = unsafe extern "C" fn(*mut u8, libc::size_t, libc::c_uint) -> libc::c_int;
+
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+ static GETRANDOM: Weak = unsafe { Weak::new("getrandom\0") };
+ if let Some(fptr) = GETRANDOM.ptr() {
+ let func: GetRandomFn = unsafe { mem::transmute(fptr) };
+ // 256 bytes is the lowest common denominator across all the Solaris
+ // derived platforms for atomically obtaining random data.
+ for chunk in dest.chunks_mut(256) {
+ sys_fill_exact(chunk, |buf| unsafe {
+ func(buf.as_mut_ptr(), buf.len(), 0) as libc::ssize_t
+ })?
+ }
+ Ok(())
+ } else {
+ use_file::getrandom_inner(dest)
+ }
+}
diff --git a/vendor/getrandom/src/solid.rs b/vendor/getrandom/src/solid.rs
new file mode 100644
index 000000000..dc76aacbf
--- /dev/null
+++ b/vendor/getrandom/src/solid.rs
@@ -0,0 +1,26 @@
+// Copyright 2021 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementation for SOLID
+use crate::Error;
+use core::num::NonZeroU32;
+
+extern "C" {
+ pub fn SOLID_RNG_SampleRandomBytes(buffer: *mut u8, length: usize) -> i32;
+}
+
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+ let ret = unsafe { SOLID_RNG_SampleRandomBytes(dest.as_mut_ptr(), dest.len()) };
+ if ret >= 0 {
+ Ok(())
+ } else {
+ // ITRON error numbers are always negative, so we negate it so that it
+ // falls in the dedicated OS error range (1..INTERNAL_START).
+ Err(NonZeroU32::new((-ret) as u32).unwrap().into())
+ }
+}
diff --git a/vendor/getrandom/src/use_file.rs b/vendor/getrandom/src/use_file.rs
new file mode 100644
index 000000000..16c0216b6
--- /dev/null
+++ b/vendor/getrandom/src/use_file.rs
@@ -0,0 +1,139 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementations that just need to read from a file
+use crate::{
+ util::LazyUsize,
+ util_libc::{open_readonly, sys_fill_exact},
+ Error,
+};
+use core::{
+ cell::UnsafeCell,
+ sync::atomic::{AtomicUsize, Ordering::Relaxed},
+};
+
+#[cfg(any(
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "haiku",
+ target_os = "macos",
+ target_os = "solaris",
+ target_os = "illumos"
+))]
+const FILE_PATH: &str = "/dev/random\0";
+#[cfg(any(target_os = "android", target_os = "linux", target_os = "redox"))]
+const FILE_PATH: &str = "/dev/urandom\0";
+
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+ let fd = get_rng_fd()?;
+ let read = |buf: &mut [u8]| unsafe { libc::read(fd, buf.as_mut_ptr() as *mut _, buf.len()) };
+
+ if cfg!(target_os = "emscripten") {
+ // `Crypto.getRandomValues` documents `dest` should be at most 65536 bytes.
+ for chunk in dest.chunks_mut(65536) {
+ sys_fill_exact(chunk, read)?;
+ }
+ } else {
+ sys_fill_exact(dest, read)?;
+ }
+ Ok(())
+}
+
+// Returns the file descriptor for the device file used to retrieve random
+// bytes. The file will be opened exactly once. All subsequent calls will
+// return the same file descriptor. This file descriptor is never closed.
+fn get_rng_fd() -> Result<libc::c_int, Error> {
+ static FD: AtomicUsize = AtomicUsize::new(LazyUsize::UNINIT);
+ fn get_fd() -> Option<libc::c_int> {
+ match FD.load(Relaxed) {
+ LazyUsize::UNINIT => None,
+ val => Some(val as libc::c_int),
+ }
+ }
+
+ // Use double-checked locking to avoid acquiring the lock if possible.
+ if let Some(fd) = get_fd() {
+ return Ok(fd);
+ }
+
+ // SAFETY: We use the mutex only in this method, and we always unlock it
+ // before returning, making sure we don't violate the pthread_mutex_t API.
+ static MUTEX: Mutex = Mutex::new();
+ unsafe { MUTEX.lock() };
+ let _guard = DropGuard(|| unsafe { MUTEX.unlock() });
+
+ if let Some(fd) = get_fd() {
+ return Ok(fd);
+ }
+
+ // On Linux, /dev/urandom might return insecure values.
+ #[cfg(any(target_os = "android", target_os = "linux"))]
+ wait_until_rng_ready()?;
+
+ let fd = unsafe { open_readonly(FILE_PATH)? };
+ // The fd always fits in a usize without conflicting with UNINIT.
+ debug_assert!(fd >= 0 && (fd as usize) < LazyUsize::UNINIT);
+ FD.store(fd as usize, Relaxed);
+
+ Ok(fd)
+}
+
+// Succeeds once /dev/urandom is safe to read from
+#[cfg(any(target_os = "android", target_os = "linux"))]
+fn wait_until_rng_ready() -> Result<(), Error> {
+ // Poll /dev/random to make sure it is ok to read from /dev/urandom.
+ let fd = unsafe { open_readonly("/dev/random\0")? };
+ let mut pfd = libc::pollfd {
+ fd,
+ events: libc::POLLIN,
+ revents: 0,
+ };
+ let _guard = DropGuard(|| unsafe {
+ libc::close(fd);
+ });
+
+ loop {
+ // A negative timeout means an infinite timeout.
+ let res = unsafe { libc::poll(&mut pfd, 1, -1) };
+ if res >= 0 {
+ debug_assert_eq!(res, 1); // We only used one fd, and cannot timeout.
+ return Ok(());
+ }
+ let err = crate::util_libc::last_os_error();
+ match err.raw_os_error() {
+ Some(libc::EINTR) | Some(libc::EAGAIN) => continue,
+ _ => return Err(err),
+ }
+ }
+}
+
+struct Mutex(UnsafeCell<libc::pthread_mutex_t>);
+
+impl Mutex {
+ const fn new() -> Self {
+ Self(UnsafeCell::new(libc::PTHREAD_MUTEX_INITIALIZER))
+ }
+ unsafe fn lock(&self) {
+ let r = libc::pthread_mutex_lock(self.0.get());
+ debug_assert_eq!(r, 0);
+ }
+ unsafe fn unlock(&self) {
+ let r = libc::pthread_mutex_unlock(self.0.get());
+ debug_assert_eq!(r, 0);
+ }
+}
+
+unsafe impl Sync for Mutex {}
+
+struct DropGuard<F: FnMut()>(F);
+
+impl<F: FnMut()> Drop for DropGuard<F> {
+ fn drop(&mut self) {
+ self.0()
+ }
+}
diff --git a/vendor/getrandom/src/util.rs b/vendor/getrandom/src/util.rs
new file mode 100644
index 000000000..06e23c28c
--- /dev/null
+++ b/vendor/getrandom/src/util.rs
@@ -0,0 +1,64 @@
+// Copyright 2019 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+#![allow(dead_code)]
+use core::sync::atomic::{AtomicUsize, Ordering::Relaxed};
+
+// This structure represents a lazily initialized static usize value. Useful
+// when it is preferable to just rerun initialization instead of locking.
+// Both unsync_init and sync_init will invoke an init() function until it
+// succeeds, then return the cached value for future calls.
+//
+// Both methods support 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 with be needed.
+pub struct LazyUsize(AtomicUsize);
+
+impl LazyUsize {
+ pub const fn new() -> Self {
+ Self(AtomicUsize::new(Self::UNINIT))
+ }
+
+ // The initialization is not completed.
+ pub const UNINIT: usize = usize::max_value();
+
+ // Runs the init() function at least 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.
+ pub fn unsync_init(&self, init: impl FnOnce() -> usize) -> usize {
+ // Relaxed ordering is fine, as we only have a single atomic variable.
+ let mut val = self.0.load(Relaxed);
+ if val == Self::UNINIT {
+ val = init();
+ self.0.store(val, Relaxed);
+ }
+ val
+ }
+}
+
+// Identical to LazyUsize except with bool instead of usize.
+pub 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(|| init() as usize) != 0
+ }
+}
diff --git a/vendor/getrandom/src/util_libc.rs b/vendor/getrandom/src/util_libc.rs
new file mode 100644
index 000000000..6df1cd7da
--- /dev/null
+++ b/vendor/getrandom/src/util_libc.rs
@@ -0,0 +1,127 @@
+// Copyright 2019 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+#![allow(dead_code)]
+use crate::{util::LazyUsize, Error};
+use core::{num::NonZeroU32, ptr::NonNull};
+
+cfg_if! {
+ if #[cfg(any(target_os = "netbsd", target_os = "openbsd", target_os = "android"))] {
+ use libc::__errno as errno_location;
+ } else if #[cfg(any(target_os = "linux", target_os = "emscripten", target_os = "redox"))] {
+ 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(all(target_os = "horizon", target_arch = "arm"))] {
+ 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;
+ }
+}
+
+cfg_if! {
+ if #[cfg(target_os = "vxworks")] {
+ use libc::errnoGet as get_errno;
+ } else if #[cfg(target_os = "dragonfly")] {
+ // Until rust-lang/rust#29594 is stable, we cannot get the errno value
+ // on DragonFlyBSD. So we just return an out-of-range errno.
+ unsafe fn get_errno() -> libc::c_int { -1 }
+ } else {
+ unsafe fn get_errno() -> libc::c_int { *errno_location() }
+ }
+}
+
+pub fn last_os_error() -> Error {
+ let errno = unsafe { get_errno() };
+ if errno > 0 {
+ Error::from(NonZeroU32::new(errno as u32).unwrap())
+ } else {
+ Error::ERRNO_NOT_POSITIVE
+ }
+}
+
+// Fill a buffer by repeatedly invoking a system call. The `sys_fill` function:
+// - should return -1 and set errno on failure
+// - should return the number of bytes written on success
+pub fn sys_fill_exact(
+ mut buf: &mut [u8],
+ sys_fill: impl Fn(&mut [u8]) -> libc::ssize_t,
+) -> Result<(), Error> {
+ while !buf.is_empty() {
+ let res = sys_fill(buf);
+ if res < 0 {
+ 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);
+ }
+ } else {
+ // We don't check for EOF (ret = 0) as the data we are reading
+ // should be an infinite stream of random bytes.
+ buf = &mut buf[(res as usize)..];
+ }
+ }
+ Ok(())
+}
+
+// A "weak" binding to a C function that may or may not be present at runtime.
+// Used for supporting newer OS features while still building on older systems.
+// F must be a function pointer of type `unsafe extern "C" fn`. Based off of the
+// weak! macro in libstd.
+pub struct Weak {
+ name: &'static str,
+ addr: LazyUsize,
+}
+
+impl Weak {
+ // Construct a binding to a C function with a given name. This function is
+ // unsafe because `name` _must_ be null terminated.
+ pub const unsafe fn new(name: &'static str) -> Self {
+ Self {
+ name,
+ addr: LazyUsize::new(),
+ }
+ }
+
+ // Return a function pointer if present at runtime. Otherwise, return null.
+ pub fn ptr(&self) -> Option<NonNull<libc::c_void>> {
+ let addr = self.addr.unsync_init(|| unsafe {
+ libc::dlsym(libc::RTLD_DEFAULT, self.name.as_ptr() as *const _) as usize
+ });
+ NonNull::new(addr as *mut _)
+ }
+}
+
+cfg_if! {
+ if #[cfg(any(target_os = "linux", target_os = "emscripten"))] {
+ use libc::open64 as open;
+ } else {
+ use libc::open;
+ }
+}
+
+// SAFETY: path must be null terminated, FD must be manually closed.
+pub unsafe fn open_readonly(path: &str) -> Result<libc::c_int, Error> {
+ debug_assert_eq!(path.as_bytes().last(), Some(&0));
+ loop {
+ let fd = open(path.as_ptr() as *const _, libc::O_RDONLY | libc::O_CLOEXEC);
+ if fd >= 0 {
+ return Ok(fd);
+ }
+ let err = last_os_error();
+ // We should try again if open() was interrupted.
+ if err.raw_os_error() != Some(libc::EINTR) {
+ return Err(err);
+ }
+ }
+}
diff --git a/vendor/getrandom/src/vxworks.rs b/vendor/getrandom/src/vxworks.rs
new file mode 100644
index 000000000..6cb5d52fe
--- /dev/null
+++ b/vendor/getrandom/src/vxworks.rs
@@ -0,0 +1,34 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementation for VxWorks
+use crate::{util_libc::last_os_error, Error};
+use core::sync::atomic::{AtomicBool, Ordering::Relaxed};
+
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+ static RNG_INIT: AtomicBool = AtomicBool::new(false);
+ while !RNG_INIT.load(Relaxed) {
+ let ret = unsafe { libc::randSecure() };
+ if ret < 0 {
+ return Err(Error::VXWORKS_RAND_SECURE);
+ } else if ret > 0 {
+ RNG_INIT.store(true, Relaxed);
+ break;
+ }
+ unsafe { libc::usleep(10) };
+ }
+
+ // Prevent overflow of i32
+ for chunk in dest.chunks_mut(i32::max_value() as usize) {
+ let ret = unsafe { libc::randABytes(chunk.as_mut_ptr(), chunk.len() as i32) };
+ if ret != 0 {
+ return Err(last_os_error());
+ }
+ }
+ Ok(())
+}
diff --git a/vendor/getrandom/src/wasi.rs b/vendor/getrandom/src/wasi.rs
new file mode 100644
index 000000000..2d413e020
--- /dev/null
+++ b/vendor/getrandom/src/wasi.rs
@@ -0,0 +1,23 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementation for WASI
+use crate::Error;
+use core::num::NonZeroU32;
+use wasi::random_get;
+
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+ unsafe {
+ random_get(dest.as_mut_ptr(), dest.len()).map_err(|e: wasi::Error| {
+ // convert wasi's Error into getrandom's NonZeroU32 error
+ // SAFETY: `wasi::Error` is `NonZeroU16` internally, so `e.raw_error()`
+ // will never return 0
+ NonZeroU32::new_unchecked(e.raw_error() as u32).into()
+ })
+ }
+}
diff --git a/vendor/getrandom/src/windows.rs b/vendor/getrandom/src/windows.rs
new file mode 100644
index 000000000..643badd07
--- /dev/null
+++ b/vendor/getrandom/src/windows.rs
@@ -0,0 +1,48 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use crate::Error;
+use core::{ffi::c_void, num::NonZeroU32, ptr};
+
+const BCRYPT_USE_SYSTEM_PREFERRED_RNG: u32 = 0x00000002;
+
+#[link(name = "bcrypt")]
+extern "system" {
+ fn BCryptGenRandom(
+ hAlgorithm: *mut c_void,
+ pBuffer: *mut u8,
+ cbBuffer: u32,
+ dwFlags: u32,
+ ) -> u32;
+}
+
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+ // Prevent overflow of u32
+ for chunk in dest.chunks_mut(u32::max_value() as usize) {
+ let ret = unsafe {
+ BCryptGenRandom(
+ ptr::null_mut(),
+ chunk.as_mut_ptr(),
+ chunk.len() as u32,
+ BCRYPT_USE_SYSTEM_PREFERRED_RNG,
+ )
+ };
+ // NTSTATUS codes use the two highest bits for severity status.
+ if ret >> 30 == 0b11 {
+ // We zeroize the highest bit, so the error code will reside
+ // inside the range designated for OS codes.
+ let code = ret ^ (1 << 31);
+ // SAFETY: the second highest bit is always equal to one,
+ // so it's impossible to get zero. Unfortunately the type
+ // system does not have a way to express this yet.
+ let code = unsafe { NonZeroU32::new_unchecked(code) };
+ return Err(Error::from(code));
+ }
+ }
+ Ok(())
+}
diff --git a/vendor/getrandom/tests/common/mod.rs b/vendor/getrandom/tests/common/mod.rs
new file mode 100644
index 000000000..006f230d7
--- /dev/null
+++ b/vendor/getrandom/tests/common/mod.rs
@@ -0,0 +1,66 @@
+use super::getrandom_impl;
+
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+use wasm_bindgen_test::wasm_bindgen_test as test;
+
+#[cfg(feature = "test-in-browser")]
+wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
+
+#[test]
+fn test_zero() {
+ // Test that APIs are happy with zero-length requests
+ getrandom_impl(&mut [0u8; 0]).unwrap();
+}
+
+#[test]
+fn test_diff() {
+ let mut v1 = [0u8; 1000];
+ getrandom_impl(&mut v1).unwrap();
+
+ let mut v2 = [0u8; 1000];
+ getrandom_impl(&mut v2).unwrap();
+
+ let mut n_diff_bits = 0;
+ for i in 0..v1.len() {
+ n_diff_bits += (v1[i] ^ v2[i]).count_ones();
+ }
+
+ // Check at least 1 bit per byte differs. p(failure) < 1e-1000 with random input.
+ assert!(n_diff_bits >= v1.len() as u32);
+}
+
+#[test]
+fn test_huge() {
+ let mut huge = [0u8; 100_000];
+ getrandom_impl(&mut huge).unwrap();
+}
+
+// On WASM, the thread API always fails/panics
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+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 {
+ getrandom_impl(&mut v).unwrap();
+ thread::yield_now();
+ }
+ });
+ }
+
+ // start all the tasks
+ for tx in txs.iter() {
+ tx.send(()).unwrap();
+ }
+}
diff --git a/vendor/getrandom/tests/custom.rs b/vendor/getrandom/tests/custom.rs
new file mode 100644
index 000000000..62eae1d66
--- /dev/null
+++ b/vendor/getrandom/tests/custom.rs
@@ -0,0 +1,50 @@
+// Test that a custom handler works on wasm32-unknown-unknown
+#![cfg(all(
+ target_arch = "wasm32",
+ target_os = "unknown",
+ feature = "custom",
+ not(feature = "js")
+))]
+
+use wasm_bindgen_test::wasm_bindgen_test as test;
+#[cfg(feature = "test-in-browser")]
+wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
+
+use core::{
+ num::NonZeroU32,
+ sync::atomic::{AtomicU8, Ordering},
+};
+use getrandom::{getrandom, register_custom_getrandom, Error};
+
+fn len7_err() -> Error {
+ NonZeroU32::new(Error::INTERNAL_START + 7).unwrap().into()
+}
+
+fn super_insecure_rng(buf: &mut [u8]) -> Result<(), Error> {
+ // Length 7 buffers return a custom error
+ if buf.len() == 7 {
+ return Err(len7_err());
+ }
+ // Otherwise, increment an atomic counter
+ static COUNTER: AtomicU8 = AtomicU8::new(0);
+ for b in buf {
+ *b = COUNTER.fetch_add(1, Ordering::Relaxed);
+ }
+ Ok(())
+}
+
+register_custom_getrandom!(super_insecure_rng);
+
+#[test]
+fn custom_rng_output() {
+ let mut buf = [0u8; 4];
+ assert_eq!(getrandom(&mut buf), Ok(()));
+ assert_eq!(buf, [0, 1, 2, 3]);
+ assert_eq!(getrandom(&mut buf), Ok(()));
+ assert_eq!(buf, [4, 5, 6, 7]);
+}
+
+#[test]
+fn rng_err_output() {
+ assert_eq!(getrandom(&mut [0; 7]), Err(len7_err()));
+}
diff --git a/vendor/getrandom/tests/normal.rs b/vendor/getrandom/tests/normal.rs
new file mode 100644
index 000000000..5fff13b38
--- /dev/null
+++ b/vendor/getrandom/tests/normal.rs
@@ -0,0 +1,11 @@
+// Don't test on custom wasm32-unknown-unknown
+#![cfg(not(all(
+ target_arch = "wasm32",
+ target_os = "unknown",
+ feature = "custom",
+ not(feature = "js")
+)))]
+
+// Use the normal getrandom implementation on this architecture.
+use getrandom::getrandom as getrandom_impl;
+mod common;
diff --git a/vendor/getrandom/tests/rdrand.rs b/vendor/getrandom/tests/rdrand.rs
new file mode 100644
index 000000000..4ff85c47f
--- /dev/null
+++ b/vendor/getrandom/tests/rdrand.rs
@@ -0,0 +1,15 @@
+// We only test the RDRAND-based RNG source on supported architectures.
+#![cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+
+// rdrand.rs expects to be part of the getrandom main crate, so we need these
+// additional imports to get rdrand.rs to compile.
+use getrandom::Error;
+#[macro_use]
+extern crate cfg_if;
+#[path = "../src/rdrand.rs"]
+mod rdrand;
+#[path = "../src/util.rs"]
+mod util;
+
+use rdrand::getrandom_inner as getrandom_impl;
+mod common;