diff options
author | Ellie Huxtable <e@elm.sh> | 2021-05-17 19:51:09 +0100 |
---|---|---|
committer | Ellie Huxtable <e@elm.sh> | 2021-05-17 19:51:09 +0100 |
commit | d0215a937a7889a97e11778ee4b0f9a12de01278 (patch) | |
tree | 5a8fd5ad62e6b5a4c218746ff2d4bd97373a48de /vendor/digest-0.9.0 | |
parent | 802a2258cbd839c5b82d24f74d7aebe4a27d8dc5 (diff) |
Vendor dependenciesvendor
Just testing how CI works with this. I tend to prefer vendoring, as it
means that if you have a copy of the code *you can always build it*.
Even if you're 20 years in the future
This is the output of
```
cargo vendor --versioned-dirs
```
Diffstat (limited to 'vendor/digest-0.9.0')
-rw-r--r-- | vendor/digest-0.9.0/.cargo-checksum.json | 1 | ||||
-rw-r--r-- | vendor/digest-0.9.0/CHANGELOG.md | 78 | ||||
-rw-r--r-- | vendor/digest-0.9.0/Cargo.toml | 38 | ||||
-rw-r--r-- | vendor/digest-0.9.0/LICENSE-APACHE | 201 | ||||
-rw-r--r-- | vendor/digest-0.9.0/LICENSE-MIT | 25 | ||||
-rw-r--r-- | vendor/digest-0.9.0/README.md | 161 | ||||
-rw-r--r-- | vendor/digest-0.9.0/src/dev.rs | 247 | ||||
-rw-r--r-- | vendor/digest-0.9.0/src/digest.rs | 96 | ||||
-rw-r--r-- | vendor/digest-0.9.0/src/dyn_digest.rs | 64 | ||||
-rw-r--r-- | vendor/digest-0.9.0/src/errors.rs | 14 | ||||
-rw-r--r-- | vendor/digest-0.9.0/src/fixed.rs | 71 | ||||
-rw-r--r-- | vendor/digest-0.9.0/src/lib.rs | 110 | ||||
-rw-r--r-- | vendor/digest-0.9.0/src/variable.rs | 106 | ||||
-rw-r--r-- | vendor/digest-0.9.0/src/xof.rs | 102 |
14 files changed, 1314 insertions, 0 deletions
diff --git a/vendor/digest-0.9.0/.cargo-checksum.json b/vendor/digest-0.9.0/.cargo-checksum.json new file mode 100644 index 00000000..00bfd169 --- /dev/null +++ b/vendor/digest-0.9.0/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"CHANGELOG.md":"dc6fb3107d31625c783c08064beae3169506996d4a8680543d220f63b235dfed","Cargo.toml":"10e467adec4f2b31ef4d9b65aaf16e4724ccafcc9631660406e4ab225c15014d","LICENSE-APACHE":"a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5","LICENSE-MIT":"9e0dfd2dd4173a530e238cb6adb37aa78c34c6bc7444e0e10c1ab5d8881f63ba","README.md":"b09a5f742c7bbba7fa2ce9d38a4584ad88e9ff835b18563d27daedb234142667","src/dev.rs":"1a57f754b3fdaaef5f2f6f8b89cc4c426b16830d57398d4b2e170094304424a6","src/digest.rs":"3155f2b42578b759da226efb51c92acec99eeee4b293c33e83c63c4b62492f7c","src/dyn_digest.rs":"ce6100ee4af7c785dc257c86fd1c2f08a8d096d520164ee5a993500fc19dd211","src/errors.rs":"b8412605e73c8d75e128ced82bbd2b02691d40d93c5436271307a2e74c5cbf66","src/fixed.rs":"06d144dec57157ad89e7c36fbf9494d9a597eadcf98006cfbf4599ddd3ab9b08","src/lib.rs":"dc5fdf8ea8a5cfcb2c2fdbc412cd8bf9aec58af4f274e3788f86eea5f755688f","src/variable.rs":"6aaa3fd4409ca9aeada08246d0bb535c66d26bc09ce2ca6b7eddf460456e9157","src/xof.rs":"53032d946352b74b74e6a8f7b11df3e45985438701e7e7621fe563008eb3c627"},"package":"d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"}
\ No newline at end of file diff --git a/vendor/digest-0.9.0/CHANGELOG.md b/vendor/digest-0.9.0/CHANGELOG.md new file mode 100644 index 00000000..03f0ad38 --- /dev/null +++ b/vendor/digest-0.9.0/CHANGELOG.md @@ -0,0 +1,78 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## 0.9.0 (2020-06-09) +### Added +- `ExtendableOutputDirty` and `VariableOutputDirty` traits ([#183]) +- `FixedOutputDirty` trait + `finalize_into*` ([#180]) +- `XofReader::read_boxed` method ([#178], [#181], [#182]) +- `alloc` feature ([#163]) +- Re-export `typenum::consts` as `consts` ([#123]) +- `Output` type alias ([#115]) + +### Changed +- Rename `*result*` methods to `finalize` ala IUF ([#161]) +- Use `impl AsRef<[u8]>` instead of generic params on methods ([#112]) +- Rename `Input::input` to `Update::update` ala IUF ([#111]) +- Upgrade to Rust 2018 edition ([#109]) +- Bump `generic-array` to v0.14 ([#95]) + +[#183]: https://github.com/RustCrypto/traits/pull/183 +[#181]: https://github.com/RustCrypto/traits/pull/181 +[#182]: https://github.com/RustCrypto/traits/pull/182 +[#180]: https://github.com/RustCrypto/traits/pull/180 +[#178]: https://github.com/RustCrypto/traits/pull/178 +[#163]: https://github.com/RustCrypto/traits/pull/163 +[#161]: https://github.com/RustCrypto/traits/pull/161 +[#123]: https://github.com/RustCrypto/traits/pull/123 +[#115]: https://github.com/RustCrypto/traits/pull/115 +[#111]: https://github.com/RustCrypto/traits/pull/111 +[#112]: https://github.com/RustCrypto/traits/pull/112 +[#109]: https://github.com/RustCrypto/traits/pull/109 +[#95]: https://github.com/RustCrypto/traits/pull/95 + +## 0.8.1 (2019-06-30) + +## 0.8.0 (2018-10-01) + +## 0.7.6 (2018-09-21) + +## 0.7.5 (2018-07-13) + +## 0.7.4 (2018-06-21) + +## 0.7.3 (2018-06-20) + +## 0.7.2 (2017-11-17) + +## 0.7.1 (2017-11-15) + +## 0.7.0 (2017-11-14) + +## 0.6.2 (2017-07-24) + +## 0.6.1 (2017-06-18) + +## 0.6.0 (2017-06-12) + +## 0.5.2 (2017-05-02) + +## 0.5.1 (2017-05-02) + +## 0.5.0 (2017-04-06) + +## 0.4.0 (2016-12-24) + +## 0.3.1 (2016-12-16) + +## 0.3.0 (2016-11-17) + +## 0.2.1 (2016-10-14) + +## 0.2.0 (2016-10-14) + +## 0.1.0 (2016-10-06) diff --git a/vendor/digest-0.9.0/Cargo.toml b/vendor/digest-0.9.0/Cargo.toml new file mode 100644 index 00000000..83c818ce --- /dev/null +++ b/vendor/digest-0.9.0/Cargo.toml @@ -0,0 +1,38 @@ +# 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 believe there's an error in this file please file an +# issue against the rust-lang/cargo repository. If you're +# editing this file be aware that the upstream Cargo.toml +# will likely look very different (and much more reasonable) + +[package] +edition = "2018" +name = "digest" +version = "0.9.0" +authors = ["RustCrypto Developers"] +description = "Traits for cryptographic hash functions" +documentation = "https://docs.rs/digest" +readme = "README.md" +keywords = ["digest", "crypto", "hash"] +categories = ["cryptography", "no-std"] +license = "MIT OR Apache-2.0" +repository = "https://github.com/RustCrypto/traits" +[package.metadata.docs.rs] +all-features = true +rustdoc-args = ["--cfg", "docsrs"] +[dependencies.blobby] +version = "0.1" +optional = true + +[dependencies.generic-array] +version = "0.14" + +[features] +alloc = [] +dev = ["blobby"] +std = ["alloc"] diff --git a/vendor/digest-0.9.0/LICENSE-APACHE b/vendor/digest-0.9.0/LICENSE-APACHE new file mode 100644 index 00000000..78173fa2 --- /dev/null +++ b/vendor/digest-0.9.0/LICENSE-APACHE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://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 + + http://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/digest-0.9.0/LICENSE-MIT b/vendor/digest-0.9.0/LICENSE-MIT new file mode 100644 index 00000000..8dcb85b3 --- /dev/null +++ b/vendor/digest-0.9.0/LICENSE-MIT @@ -0,0 +1,25 @@ +Copyright (c) 2017 Artyom Pavlov + +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/digest-0.9.0/README.md b/vendor/digest-0.9.0/README.md new file mode 100644 index 00000000..e6863877 --- /dev/null +++ b/vendor/digest-0.9.0/README.md @@ -0,0 +1,161 @@ +# RustCrypto: Digest Algorithm Traits + +[![crate][crate-image]][crate-link] +[![Docs][docs-image]][docs-link] +![Apache2/MIT licensed][license-image] +![Rust Version][rustc-image] +[![Build Status][build-image]][build-link] + +Traits which describe functionality of [cryptographic hash functions][0], a.k.a. +digest algorithms. + +See [RustCrypto/hashes][1] for implementations which use this trait. + +[Documentation][docs-link] + +## Minimum Supported Rust Version + +Rust **1.41** or higher. + +Minimum supported Rust version can be changed in the future, but it will be +done with a minor version bump. + +## SemVer Policy + +- All on-by-default features of this library are covered by SemVer +- MSRV is considered exempt from SemVer as noted above + +## Usage + +Let us demonstrate how to use crates in this repository using BLAKE2b as an +example. + +First add `blake2` crate to your `Cargo.toml`: + +```toml +[dependencies] +blake2 = "0.8" +``` + +`blake2` and other crates re-export `digest` crate and `Digest` trait for +convenience, so you don't have to add `digest` crate as an explicit dependency. + +Now you can write the following code: + +```rust +use blake2::{Blake2b, Digest}; + +let mut hasher = Blake2b::new(); +let data = b"Hello world!"; +hasher.input(data); +// `input` can be called repeatedly and is generic over `AsRef<[u8]>` +hasher.input("String data"); +// Note that calling `finalize()` consumes hasher +let hash = hasher.finalize(); +println!("Result: {:x}", hash); +``` + +In this example `hash` has type [`GenericArray<u8, U64>`][2], which is a generic +alternative to `[u8; 64]`. + +Alternatively you can use chained approach, which is equivalent to the previous +example: + +```rust +let hash = Blake2b::new() + .chain(b"Hello world!") + .chain("String data") + .finalize(); + +println!("Result: {:x}", hash); +``` + +If the whole message is available you also can use convinience `digest` method: + +```rust +let hash = Blake2b::digest(b"my message"); +println!("Result: {:x}", hash); +``` + +### Hashing `Read`-able objects + +If you want to hash data from [`Read`][3] trait (e.g. from file) you can rely on +implementation of [`Write`][4] trait (requires enabled-by-default `std` feature): + +```rust +use blake2::{Blake2b, Digest}; +use std::{fs, io}; + +let mut file = fs::File::open(&path)?; +let mut hasher = Blake2b::new(); +let n = io::copy(&mut file, &mut hasher)?; +let hash = hasher.finalize(); + +println!("Path: {}", path); +println!("Bytes processed: {}", n); +println!("Hash value: {:x}", hash); +``` + +### Generic code + +You can write generic code over `Digest` (or other traits from `digest` crate) +trait which will work over different hash functions: + +```rust +use digest::Digest; + +// Toy example, do not use it in practice! +// Instead use crates from: https://github.com/RustCrypto/password-hashing +fn hash_password<D: Digest>(password: &str, salt: &str, output: &mut [u8]) { + let mut hasher = D::new(); + hasher.input(password.as_bytes()); + hasher.input(b"$"); + hasher.input(salt.as_bytes()); + output.copy_from_slice(hasher.finalize().as_slice()) +} + +use blake2::Blake2b; +use sha2::Sha256; + +hash_password::<Blake2b>("my_password", "abcd", &mut buf); +hash_password::<Sha256>("my_password", "abcd", &mut buf); +``` + +If you want to use hash functions with trait objects, use `digest::DynDigest` +trait. + +## License + +Licensed under either of: + + * [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0) + * [MIT license](http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in the work by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. + +[//]: # (badges) + +[crate-image]: https://img.shields.io/crates/v/digest.svg +[crate-link]: https://crates.io/crates/digest +[docs-image]: https://docs.rs/digest/badge.svg +[docs-link]: https://docs.rs/digest/ +[license-image]: https://img.shields.io/badge/license-Apache2.0/MIT-blue.svg +[rustc-image]: https://img.shields.io/badge/rustc-1.41+-blue.svg +[build-image]: https://github.com/RustCrypto/traits/workflows/digest/badge.svg?branch=master&event=push +[build-link]: https://github.com/RustCrypto/traits/actions?query=workflow%3Adigest + +[//]: # (general links) + +[0]: https://en.wikipedia.org/wiki/Cryptographic_hash_function +[1]: https://github.com/RustCrypto/hashes +[2]: https://docs.rs/generic-array +[3]: https://doc.rust-lang.org/std/io/trait.Read.html +[4]: https://doc.rust-lang.org/std/io/trait.Write.html +[5]: https://en.wikipedia.org/wiki/Hash-based_message_authentication_code +[6]: https://github.com/RustCrypto/MACs diff --git a/vendor/digest-0.9.0/src/dev.rs b/vendor/digest-0.9.0/src/dev.rs new file mode 100644 index 00000000..c205cab4 --- /dev/null +++ b/vendor/digest-0.9.0/src/dev.rs @@ -0,0 +1,247 @@ +//! Development-related functionality + +pub use blobby; + +use super::{ExtendableOutput, Reset, Update, VariableOutput, XofReader}; +use core::fmt::Debug; + +/// Define test +#[macro_export] +#[cfg_attr(docsrs, doc(cfg(feature = "dev")))] +macro_rules! new_test { + ($name:ident, $test_name:expr, $hasher:ty, $test_func:ident) => { + #[test] + fn $name() { + use digest::dev::blobby::Blob2Iterator; + let data = include_bytes!(concat!("data/", $test_name, ".blb")); + + for (i, row) in Blob2Iterator::new(data).unwrap().enumerate() { + let input = row[0]; + let output = row[1]; + if let Some(desc) = $test_func::<$hasher>(input, output) { + panic!( + "\n\ + Failed test â„–{}: {}\n\ + input:\t{:?}\n\ + output:\t{:?}\n", + i, desc, input, output, + ); + } + } + } + }; +} + +/// Module to separate Digest from other traits +mod foo { + use super::super::Digest; + use core::fmt::Debug; + + /// Digest test + pub fn digest_test<D>(input: &[u8], output: &[u8]) -> Option<&'static str> + where + D: Digest + Debug + Clone, + { + let mut hasher = D::new(); + // Test that it works when accepting the message all at once + hasher.update(input); + let mut hasher2 = hasher.clone(); + if hasher.finalize().as_slice() != output { + return Some("whole message"); + } + + // Test if reset works correctly + hasher2.reset(); + hasher2.update(input); + if hasher2.finalize().as_slice() != output { + return Some("whole message after reset"); + } + + // Test that it works when accepting the message in pieces + let mut hasher = D::new(); + let len = input.len(); + let mut left = len; + while left > 0 { + let take = (left + 1) / 2; + hasher.update(&input[len - left..take + len - left]); + left -= take; + } + if hasher.finalize().as_slice() != output { + return Some("message in pieces"); + } + + // Test processing byte-by-byte + let mut hasher = D::new(); + for chunk in input.chunks(1) { + hasher.update(chunk) + } + if hasher.finalize().as_slice() != output { + return Some("message byte-by-byte"); + } + None + } + + /// Compute digest of one million `a` bytes + pub fn one_million_a<D>(expected: &[u8]) + where + D: Digest + Debug + Clone, + { + let mut sh = D::new(); + for _ in 0..50_000 { + sh.update(&[b'a'; 10]); + } + sh.update(&[b'a'; 500_000][..]); + let out = sh.finalize(); + assert_eq!(out[..], expected[..]); + } +} + +pub use self::foo::{digest_test, one_million_a}; + +/// XOF test +pub fn xof_test<D>(input: &[u8], output: &[u8]) -> Option<&'static str> +where + D: Update + ExtendableOutput + Default + Debug + Reset + Clone, +{ + let mut hasher = D::default(); + let mut buf = [0u8; 1024]; + // Test that it works when accepting the message all at once + hasher.update(input); + + let mut hasher2 = hasher.clone(); + { + let out = &mut buf[..output.len()]; + hasher.finalize_xof().read(out); + + if out != output { + return Some("whole message"); + } + } + + // Test if hasher resets correctly + hasher2.reset(); + hasher2.update(input); + + { + let out = &mut buf[..output.len()]; + hasher2.finalize_xof().read(out); + + if out != output { + return Some("whole message after reset"); + } + } + + // Test if hasher accepts message in pieces correctly + let mut hasher = D::default(); + let len = input.len(); + let mut left = len; + while left > 0 { + let take = (left + 1) / 2; + hasher.update(&input[len - left..take + len - left]); + left -= take; + } + + { + let out = &mut buf[..output.len()]; + hasher.finalize_xof().read(out); + if out != output { + return Some("message in pieces"); + } + } + + // Test reading from reader byte by byte + let mut hasher = D::default(); + hasher.update(input); + + let mut reader = hasher.finalize_xof(); + let out = &mut buf[..output.len()]; + for chunk in out.chunks_mut(1) { + reader.read(chunk); + } + + if out != output { + return Some("message in pieces"); + } + None +} + +/// Variable-output digest test +pub fn variable_test<D>(input: &[u8], output: &[u8]) -> Option<&'static str> +where + D: Update + VariableOutput + Reset + Debug + Clone, +{ + let mut hasher = D::new(output.len()).unwrap(); + let mut buf = [0u8; 128]; + let buf = &mut buf[..output.len()]; + // Test that it works when accepting the message all at once + hasher.update(input); + let mut hasher2 = hasher.clone(); + hasher.finalize_variable(|res| buf.copy_from_slice(res)); + if buf != output { + return Some("whole message"); + } + + // Test if reset works correctly + hasher2.reset(); + hasher2.update(input); + hasher2.finalize_variable(|res| buf.copy_from_slice(res)); + if buf != output { + return Some("whole message after reset"); + } + + // Test that it works when accepting the message in pieces + let mut hasher = D::new(output.len()).unwrap(); + let len = input.len(); + let mut left = len; + while left > 0 { + let take = (left + 1) / 2; + hasher.update(&input[len - left..take + len - left]); + left -= take; + } + hasher.finalize_variable(|res| buf.copy_from_slice(res)); + if buf != output { + return Some("message in pieces"); + } + + // Test processing byte-by-byte + let mut hasher = D::new(output.len()).unwrap(); + for chunk in input.chunks(1) { + hasher.update(chunk) + } + hasher.finalize_variable(|res| buf.copy_from_slice(res)); + if buf != output { + return Some("message byte-by-byte"); + } + None +} + +/// Define benchmark +#[macro_export] +#[cfg_attr(docsrs, doc(cfg(feature = "dev")))] +macro_rules! bench { + ($name:ident, $engine:path, $bs:expr) => { + #[bench] + fn $name(b: &mut Bencher) { + let mut d = <$engine>::default(); + let data = [0; $bs]; + + b.iter(|| { + d.update(&data[..]); + }); + + b.bytes = $bs; + } + }; + + ($engine:path) => { + extern crate test; + + use digest::Digest; + use test::Bencher; + + $crate::bench!(bench1_10, $engine, 10); + $crate::bench!(bench2_100, $engine, 100); + $crate::bench!(bench3_1000, $engine, 1000); + $crate::bench!(bench4_10000, $engine, 10000); + }; +} diff --git a/vendor/digest-0.9.0/src/digest.rs b/vendor/digest-0.9.0/src/digest.rs new file mode 100644 index 00000000..ef72951d --- /dev/null +++ b/vendor/digest-0.9.0/src/digest.rs @@ -0,0 +1,96 @@ +use super::{FixedOutput, Reset, Update}; +use generic_array::typenum::Unsigned; +use generic_array::{ArrayLength, GenericArray}; + +/// The `Digest` trait specifies an interface common for digest functions. +/// +/// It's a convenience wrapper around [`Update`], [`FixedOutput`], [`Reset`], +/// [`Clone`], and [`Default`] traits. It also p |