Package: rust-sha-1 Version: 0.8.1-2 Severity: normal Tags: patch pending Dear maintainer,
I've prepared an NMU for rust-sha-1 (versioned as 0.8.1-2.1) and uploaded it without delay, due to current package being completely broken. Regards, - Jonas diff -Nru rust-sha-1-0.8.1/debian/changelog rust-sha-1-0.8.1/debian/changelog --- rust-sha-1-0.8.1/debian/changelog 2019-08-06 18:25:40.000000000 +0200 +++ rust-sha-1-0.8.1/debian/changelog 2022-04-07 15:48:54.000000000 +0200 @@ -1,3 +1,16 @@ +rust-sha-1 (0.8.1-2.1) unstable; urgency=medium + + * Non-maintainer upload. + * fix unsatisfiable dependencies and failure to build from source: + + add patches and bump dependencies to link against + librust-block-buffer-0.9+default-dev + librust-digest-0.9+default-dev + librust-opaque-debug-0.3+default-dev + (not older versions gone since 2020-03-31) + * add autopkgtest + + -- Jonas Smedegaard <d...@jones.dk> Thu, 07 Apr 2022 15:48:54 +0200 + rust-sha-1 (0.8.1-2) unstable; urgency=medium * Team upload. diff -Nru rust-sha-1-0.8.1/debian/control rust-sha-1-0.8.1/debian/control --- rust-sha-1-0.8.1/debian/control 2019-08-06 18:25:40.000000000 +0200 +++ rust-sha-1-0.8.1/debian/control 2022-04-07 15:27:17.000000000 +0200 @@ -6,11 +6,10 @@ cargo:native <!nocheck>, rustc:native <!nocheck>, libstd-rust-dev <!nocheck>, - librust-block-buffer-0.7+default-dev <!nocheck>, - librust-digest-0.8+default-dev <!nocheck>, - librust-digest-0.8+std-dev <!nocheck>, - librust-fake-simd-0.1+default-dev <!nocheck>, - librust-opaque-debug-0.2+default-dev <!nocheck> + librust-block-buffer-0.9+default-dev <!nocheck>, + librust-digest-0.9+default-dev <!nocheck>, + librust-digest-0.9+std-dev <!nocheck>, + librust-opaque-debug-0.3+default-dev <!nocheck> Maintainer: Debian Rust Maintainers <pkg-rust-maintain...@alioth-lists.debian.net> Uploaders: kpcyrd <g...@rxv.cc> @@ -23,10 +22,9 @@ Multi-Arch: same Depends: ${misc:Depends}, - librust-block-buffer-0.7+default-dev, - librust-digest-0.8+default-dev, - librust-fake-simd-0.1+default-dev, - librust-opaque-debug-0.2+default-dev + librust-block-buffer-0.9+default-dev, + librust-digest-0.9+default-dev, + librust-opaque-debug-0.3+default-dev Recommends: librust-sha-1+std-dev (= ${binary:Version}) Suggests: @@ -76,7 +74,7 @@ Depends: ${misc:Depends}, librust-sha-1-dev (= ${binary:Version}), - librust-digest-0.8+std-dev + librust-digest-0.9+std-dev Provides: librust-sha-1+default-dev (= ${binary:Version}), librust-sha-1-0+std-dev (= ${binary:Version}), diff -Nru rust-sha-1-0.8.1/debian/patches/020200527~c43d34c.patch rust-sha-1-0.8.1/debian/patches/020200527~c43d34c.patch --- rust-sha-1-0.8.1/debian/patches/020200527~c43d34c.patch 1970-01-01 01:00:00.000000000 +0100 +++ rust-sha-1-0.8.1/debian/patches/020200527~c43d34c.patch 2022-04-07 15:38:04.000000000 +0200 @@ -0,0 +1,79 @@ +commit c43d34c12755b2e380d73c8e84b018abe8bc0b15 +Author: Tony Arcieri <basc...@gmail.com> +Date: Wed May 27 20:12:05 2020 -0700 + + sha1: 2018 edition and `digest` crate upgrade + + Upgrades to Rust 2018 edition and the (now 2018 edition) + `digest` v0.9.0-pre crate. + +--- a/Cargo.toml ++++ b/Cargo.toml +@@ -27,7 +27,7 @@ + version = "0.7" + + [dependencies.digest] +-version = "0.8" ++version = "0.9" + + [dependencies.fake-simd] + version = "0.1" +@@ -39,7 +39,7 @@ + version = "0.4" + optional = true + [dev-dependencies.digest] +-version = "0.8" ++version = "0.9" + features = ["dev"] + + [dev-dependencies.hex-literal] +--- a/benches/lib.rs ++++ b/benches/lib.rs +@@ -4,4 +4,5 @@ + extern crate digest; + extern crate sha1; + ++use digest::bench; + bench!(sha1::Sha1); +--- a/examples/sha1sum.rs ++++ b/examples/sha1sum.rs +@@ -25,7 +25,7 @@ + Ok(n) => n, + Err(_) => return, + }; +- sh.input(&buffer[..n]); ++ sh.update(&buffer[..n]); + if n == 0 || n < BUFFER_SIZE { + break; + } +--- a/src/lib.rs ++++ b/src/lib.rs +@@ -12,7 +12,7 @@ + //! let mut hasher = Sha1::new(); + //! + //! // process input message +-//! hasher.input(b"hello world"); ++//! hasher.update(b"hello world"); + //! + //! // acquire hash digest in the form of GenericArray, + //! // which in this case is equivalent to [u8; 20] +@@ -51,7 +51,7 @@ + use utils::compress; + + pub use digest::Digest; +-use digest::{Input, BlockInput, FixedOutput, Reset}; ++use digest::{Update, BlockInput, FixedOutput, Reset}; + use digest::generic_array::GenericArray; + use digest::generic_array::typenum::{U20, U64}; + use block_buffer::BlockBuffer; +@@ -78,8 +78,8 @@ + type BlockSize = U64; + } + +-impl Input for Sha1 { +- fn input<B: AsRef<[u8]>>(&mut self, input: B) { ++impl Update for Sha1 { ++ fn update(&mut self, input: impl AsRef<[u8]>) { + let input = input.as_ref(); + // Assumes that `length_bits<<3` will not overflow + self.len += input.len() as u64; diff -Nru rust-sha-1-0.8.1/debian/patches/020200602~d749cb0.patch rust-sha-1-0.8.1/debian/patches/020200602~d749cb0.patch --- rust-sha-1-0.8.1/debian/patches/020200602~d749cb0.patch 1970-01-01 01:00:00.000000000 +0100 +++ rust-sha-1-0.8.1/debian/patches/020200602~d749cb0.patch 2022-04-07 15:44:01.000000000 +0200 @@ -0,0 +1,44 @@ +commit d749cb0fac719d46bd15302bba4adf4fba1d4ba6 +Author: Tony Arcieri <basc...@gmail.com> +Date: Tue Jun 2 12:35:57 2020 -0700 + + Rename `*result*` to `finalize` + + Implements the API changes from: + + https://github.com/RustCrypto/traits/pull/161 + + The `digest` crate now uses `update` and `finalize` nomenclature + ala the Initialize-Update-Finalize (IUF) interface naming scheme. + +--- a/examples/sha1sum.rs ++++ b/examples/sha1sum.rs +@@ -30,7 +30,7 @@ + break; + } + } +- print_result(&sh.result(), name); ++ print_result(&sh.finalize(), name); + } + + fn main() { +--- a/src/lib.rs ++++ b/src/lib.rs +@@ -16,7 +16,7 @@ + //! + //! // acquire hash digest in the form of GenericArray, + //! // which in this case is equivalent to [u8; 20] +-//! let result = hasher.result(); ++//! let result = hasher.finalize(); + //! assert_eq!(result[..], hex!("2aae6c35c94fcfb415dbe95f408b9ce91ee846ed")); + //! # } + //! ``` +@@ -91,7 +91,7 @@ + impl FixedOutput for Sha1 { + type OutputSize = U20; + +- fn fixed_result(mut self) -> GenericArray<u8, Self::OutputSize> { ++ fn finalize_fixed(mut self) -> GenericArray<u8, Self::OutputSize> { + { + let state = &mut self.h; + let l = self.len << 3; diff -Nru rust-sha-1-0.8.1/debian/patches/020200609~26bea13.patch rust-sha-1-0.8.1/debian/patches/020200609~26bea13.patch --- rust-sha-1-0.8.1/debian/patches/020200609~26bea13.patch 1970-01-01 01:00:00.000000000 +0100 +++ rust-sha-1-0.8.1/debian/patches/020200609~26bea13.patch 2022-04-07 15:44:35.000000000 +0200 @@ -0,0 +1,68 @@ +commit 26bea13186632a16e6cc2a1d096c01b2b9500beb +Author: Tony Arcieri <basc...@gmail.com> +Date: Tue Jun 9 16:22:33 2020 -0700 + + Use new `*Dirty` traits from the `digest` crate (#153) + + Updates all of the hash implementations in this repo to use the new + `*Dirty` traits which support blanket impls of the original traits, + which either consume the hasher instance or can be reset. + + This will also provide a marginal efficiency boost, at least until + placement return lands (which, as it were, may be soon). + +--- a/src/lib.rs ++++ b/src/lib.rs +@@ -51,15 +51,19 @@ + use utils::compress; + + pub use digest::Digest; +-use digest::{Update, BlockInput, FixedOutput, Reset}; +-use digest::generic_array::GenericArray; +-use digest::generic_array::typenum::{U20, U64}; +-use block_buffer::BlockBuffer; +-use block_buffer::byteorder::{BE, ByteOrder}; ++use digest::{Update, BlockInput, FixedOutputDirty, Reset}; ++use digest::consts::{U20, U64}; ++use block_buffer::{ ++ byteorder::{ByteOrder, BE}, ++ BlockBuffer, ++}; + + mod consts; + use consts::{STATE_LEN, H}; + ++#[cfg(feature = "asm")] ++use digest::generic_array::GenericArray; ++ + /// Structure representing the state of a SHA-1 computation + #[derive(Clone)] + pub struct Sha1 { +@@ -88,18 +92,17 @@ + } + } + +-impl FixedOutput for Sha1 { ++impl FixedOutputDirty for Sha1 { + type OutputSize = U20; + +- fn finalize_fixed(mut self) -> GenericArray<u8, Self::OutputSize> { +- { +- let state = &mut self.h; +- let l = self.len << 3; +- self.buffer.len64_padding::<BE, _>(l, |d| compress(state, d)); +- } +- let mut out = GenericArray::default(); +- BE::write_u32_into(&self.h,&mut out); +- out ++ fn finalize_into_dirty(&mut self, out: &mut digest::Output<Self>) { ++ let state = &mut self.h; ++ let l = self.len << 3; ++ ++ self.buffer ++ .len64_padding::<BE, _>(l, |d| compress(state, d)); ++ ++ BE::write_u32_into(&self.h, out); + } + } + diff -Nru rust-sha-1-0.8.1/debian/patches/020200610~d24f26b.patch rust-sha-1-0.8.1/debian/patches/020200610~d24f26b.patch --- rust-sha-1-0.8.1/debian/patches/020200610~d24f26b.patch 1970-01-01 01:00:00.000000000 +0100 +++ rust-sha-1-0.8.1/debian/patches/020200610~d24f26b.patch 2022-04-07 15:47:25.000000000 +0200 @@ -0,0 +1,296 @@ +commit d24f26b1650156b1da4fced389559cee17805910 +Author: Artyom Pavlov <newpav...@gmail.com> +Date: Wed Jun 10 20:11:36 2020 +0300 + + Update block-buffer to v0.9 (#164) + +--- a/Cargo.toml ++++ b/Cargo.toml +@@ -24,14 +24,11 @@ + [lib] + name = "sha1" + [dependencies.block-buffer] +-version = "0.7" ++version = "0.9" + + [dependencies.digest] + version = "0.9" + +-[dependencies.fake-simd] +-version = "0.1" +- + [dependencies.opaque-debug] + version = "0.2" + +--- a/src/lib.rs ++++ b/src/lib.rs +@@ -33,8 +33,6 @@ + #[macro_use] pub extern crate digest; + #[cfg(feature = "std")] + extern crate std; +-#[cfg(not(feature = "asm"))] +-extern crate fake_simd as simd; + + #[cfg(feature = "asm")] + extern crate sha1_asm; +@@ -53,10 +51,7 @@ + pub use digest::Digest; + use digest::{Update, BlockInput, FixedOutputDirty, Reset}; + use digest::consts::{U20, U64}; +-use block_buffer::{ +- byteorder::{ByteOrder, BE}, +- BlockBuffer, +-}; ++use block_buffer::BlockBuffer; + + mod consts; + use consts::{STATE_LEN, H}; +@@ -88,7 +83,7 @@ + // Assumes that `length_bits<<3` will not overflow + self.len += input.len() as u64; + let state = &mut self.h; +- self.buffer.input(input, |d| compress(state, d)); ++ self.buffer.input_block(input, |d| compress(state, d)); + } + } + +@@ -96,13 +91,12 @@ + type OutputSize = U20; + + fn finalize_into_dirty(&mut self, out: &mut digest::Output<Self>) { +- let state = &mut self.h; ++ let s = &mut self.h; + let l = self.len << 3; +- +- self.buffer +- .len64_padding::<BE, _>(l, |d| compress(state, d)); +- +- BE::write_u32_into(&self.h, out); ++ self.buffer.len64_padding_be(l, |d| compress(s, d)); ++ for (chunk, v) in out.chunks_exact_mut(4).zip(self.h.iter()) { ++ chunk.copy_from_slice(&v.to_be_bytes()); ++ } + } + } + +--- a/src/utils.rs ++++ b/src/utils.rs +@@ -1,80 +1,94 @@ + #![cfg_attr(feature = "cargo-clippy", allow(many_single_char_names))] + + use consts::{BLOCK_LEN, K0, K1, K2, K3}; +-use block_buffer::byteorder::{BE, ByteOrder}; +-use simd::u32x4; ++use core::convert::TryInto; + use digest::generic_array::GenericArray; + use digest::generic_array::typenum::U64; + + type Block = GenericArray<u8, U64>; + ++#[inline(always)] ++fn add(a: [u32; 4], b: [u32; 4]) -> [u32; 4] { ++ [ ++ a[0].wrapping_add(b[0]), ++ a[1].wrapping_add(b[1]), ++ a[2].wrapping_add(b[2]), ++ a[3].wrapping_add(b[3]), ++ ] ++} ++ ++#[inline(always)] ++fn xor(a: [u32; 4], b: [u32; 4]) -> [u32; 4] { ++ [a[0] ^ b[0], a[1] ^ b[1], a[2] ^ b[2], a[3] ^ b[3]] ++} ++ + /// Not an intrinsic, but gets the first element of a vector. + #[inline] +-pub fn sha1_first(w0: u32x4) -> u32 { +- w0.0 ++pub fn sha1_first(w0: [u32; 4]) -> u32 { ++ w0[0] + } + + /// Not an intrinsic, but adds a word to the first element of a vector. + #[inline] +-pub fn sha1_first_add(e: u32, w0: u32x4) -> u32x4 { +- let u32x4(a, b, c, d) = w0; +- u32x4(e.wrapping_add(a), b, c, d) ++pub fn sha1_first_add(e: u32, w0: [u32; 4]) -> [u32; 4] { ++ let [a, b, c, d] = w0; ++ [e.wrapping_add(a), b, c, d] + } + + /// Emulates `llvm.x86.sha1msg1` intrinsic. +-fn sha1msg1(a: u32x4, b: u32x4) -> u32x4 { +- let u32x4(_, _, w2, w3) = a; +- let u32x4(w4, w5, _, _) = b; +- a ^ u32x4(w2, w3, w4, w5) ++fn sha1msg1(a: [u32; 4], b: [u32; 4]) -> [u32; 4] { ++ let [_, _, w2, w3] = a; ++ let [w4, w5, _, _] = b; ++ [a[0] ^ w2, a[1] ^ w3, a[2] ^ w4, a[3] ^ w5] + } + + /// Emulates `llvm.x86.sha1msg2` intrinsic. +-fn sha1msg2(a: u32x4, b: u32x4) -> u32x4 { +- let u32x4(x0, x1, x2, x3) = a; +- let u32x4(_, w13, w14, w15) = b; ++fn sha1msg2(a: [u32; 4], b: [u32; 4]) -> [u32; 4] { ++ let [x0, x1, x2, x3] = a; ++ let [_, w13, w14, w15] = b; + + let w16 = (x0 ^ w13).rotate_left(1); + let w17 = (x1 ^ w14).rotate_left(1); + let w18 = (x2 ^ w15).rotate_left(1); + let w19 = (x3 ^ w16).rotate_left(1); + +- u32x4(w16, w17, w18, w19) ++ [w16, w17, w18, w19] + } + + /// Performs 4 rounds of the message schedule update. + /* +-pub fn sha1_schedule_x4(v0: u32x4, v1: u32x4, v2: u32x4, v3: u32x4) -> u32x4 { ++pub fn sha1_schedule_x4(v0: [u32; 4], v1: [u32; 4], v2: [u32; 4], v3: [u32; 4]) -> [u32; 4] { + sha1msg2(sha1msg1(v0, v1) ^ v2, v3) + } + */ + + /// Emulates `llvm.x86.sha1nexte` intrinsic. + #[inline] +-fn sha1_first_half(abcd: u32x4, msg: u32x4) -> u32x4 { ++fn sha1_first_half(abcd: [u32; 4], msg: [u32; 4]) -> [u32; 4] { + sha1_first_add(sha1_first(abcd).rotate_left(30), msg) + } + + /// Emulates `llvm.x86.sha1rnds4` intrinsic. + /// Performs 4 rounds of the message block digest. +-fn sha1_digest_round_x4(abcd: u32x4, work: u32x4, i: i8) -> u32x4 { +- const K0V: u32x4 = u32x4(K0, K0, K0, K0); +- const K1V: u32x4 = u32x4(K1, K1, K1, K1); +- const K2V: u32x4 = u32x4(K2, K2, K2, K2); +- const K3V: u32x4 = u32x4(K3, K3, K3, K3); ++fn sha1_digest_round_x4(abcd: [u32; 4], work: [u32; 4], i: i8) -> [u32; 4] { ++ const K0V: [u32; 4] = [K0, K0, K0, K0]; ++ const K1V: [u32; 4] = [K1, K1, K1, K1]; ++ const K2V: [u32; 4] = [K2, K2, K2, K2]; ++ const K3V: [u32; 4] = [K3, K3, K3, K3]; + + match i { +- 0 => sha1rnds4c(abcd, work + K0V), +- 1 => sha1rnds4p(abcd, work + K1V), +- 2 => sha1rnds4m(abcd, work + K2V), +- 3 => sha1rnds4p(abcd, work + K3V), ++ 0 => sha1rnds4c(abcd, add(work, K0V)), ++ 1 => sha1rnds4p(abcd, add(work, K1V)), ++ 2 => sha1rnds4m(abcd, add(work, K2V)), ++ 3 => sha1rnds4p(abcd, add(work, K3V)), + _ => unreachable!("unknown icosaround index"), + } + } + + /// Not an intrinsic, but helps emulate `llvm.x86.sha1rnds4` intrinsic. +-fn sha1rnds4c(abcd: u32x4, msg: u32x4) -> u32x4 { +- let u32x4(mut a, mut b, mut c, mut d) = abcd; +- let u32x4(t, u, v, w) = msg; ++fn sha1rnds4c(abcd: [u32; 4], msg: [u32; 4]) -> [u32; 4] { ++ let [mut a, mut b, mut c, mut d] = abcd; ++ let [t, u, v, w] = msg; + let mut e = 0u32; + + macro_rules! bool3ary_202 { +@@ -101,13 +115,13 @@ + .wrapping_add(w); + d = d.rotate_left(30); + +- u32x4(b, c, d, e) ++ [b, c, d, e] + } + + /// Not an intrinsic, but helps emulate `llvm.x86.sha1rnds4` intrinsic. +-fn sha1rnds4p(abcd: u32x4, msg: u32x4) -> u32x4 { +- let u32x4(mut a, mut b, mut c, mut d) = abcd; +- let u32x4(t, u, v, w) = msg; ++fn sha1rnds4p(abcd: [u32; 4], msg: [u32; 4]) -> [u32; 4] { ++ let [mut a, mut b, mut c, mut d] = abcd; ++ let [t, u, v, w] = msg; + let mut e = 0u32; + + macro_rules! bool3ary_150 { +@@ -134,13 +148,13 @@ + .wrapping_add(w); + d = d.rotate_left(30); + +- u32x4(b, c, d, e) ++ [b, c, d, e] + } + + /// Not an intrinsic, but helps emulate `llvm.x86.sha1rnds4` intrinsic. +-fn sha1rnds4m(abcd: u32x4, msg: u32x4) -> u32x4 { +- let u32x4(mut a, mut b, mut c, mut d) = abcd; +- let u32x4(t, u, v, w) = msg; ++fn sha1rnds4m(abcd: [u32; 4], msg: [u32; 4]) -> [u32; 4] { ++ let [mut a, mut b, mut c, mut d] = abcd; ++ let [t, u, v, w] = msg; + let mut e = 0u32; + + macro_rules! bool3ary_232 { +@@ -167,7 +181,7 @@ + .wrapping_add(w); + d = d.rotate_left(30); + +- u32x4(b, c, d, e) ++ [b, c, d, e] + } + + /// Process a block with the SHA-1 algorithm. +@@ -175,7 +189,7 @@ + + macro_rules! schedule { + ($v0:expr, $v1:expr, $v2:expr, $v3:expr) => ( +- sha1msg2(sha1msg1($v0, $v1) ^ $v2, $v3) ++ sha1msg2(xor(sha1msg1($v0, $v1), $v2), $v3) + ) + } + +@@ -186,15 +200,15 @@ + } + + // Rounds 0..20 +- // TODO: replace with `u32x4::load` +- let mut h0 = u32x4(state[0], state[1], state[2], state[3]); +- let mut w0 = u32x4(block[0], block[1], block[2], block[3]); ++ // TODO: replace with `[u32; 4]::load` ++ let mut h0 = [state[0], state[1], state[2], state[3]]; ++ let mut w0 = [block[0], block[1], block[2], block[3]]; + let mut h1 = sha1_digest_round_x4(h0, sha1_first_add(state[4], w0), 0); +- let mut w1 = u32x4(block[4], block[5], block[6], block[7]); ++ let mut w1 = [block[4], block[5], block[6], block[7]]; + h0 = rounds4!(h1, h0, w1, 0); +- let mut w2 = u32x4(block[8], block[9], block[10], block[11]); ++ let mut w2 = [block[8], block[9], block[10], block[11]]; + h1 = rounds4!(h0, h1, w2, 0); +- let mut w3 = u32x4(block[12], block[13], block[14], block[15]); ++ let mut w3 = [block[12], block[13], block[14], block[15]]; + h0 = rounds4!(h1, h0, w3, 0); + let mut w4 = schedule!(w0, w1, w2, w3); + h1 = rounds4!(h0, h1, w4, 0); +@@ -236,7 +250,7 @@ + h0 = rounds4!(h1, h0, w4, 3); + + let e = sha1_first(h1).rotate_left(30); +- let u32x4(a, b, c, d) = h0; ++ let [a, b, c, d] = h0; + + state[0] = state[0].wrapping_add(a); + state[1] = state[1].wrapping_add(b); +@@ -295,6 +309,8 @@ + /// + pub fn compress(state: &mut [u32; 5], block: &Block) { + let mut block_u32 = [0u32; BLOCK_LEN]; +- BE::read_u32_into(block, &mut block_u32[..]); ++ for (o, chunk) in block_u32.iter_mut().zip(block.chunks_exact(4)) { ++ *o = u32::from_be_bytes(chunk.try_into().unwrap()); ++ } + sha1_digest_block_u32(state, &block_u32); + } diff -Nru rust-sha-1-0.8.1/debian/patches/020200611~15c3060.patch rust-sha-1-0.8.1/debian/patches/020200611~15c3060.patch --- rust-sha-1-0.8.1/debian/patches/020200611~15c3060.patch 1970-01-01 01:00:00.000000000 +0100 +++ rust-sha-1-0.8.1/debian/patches/020200611~15c3060.patch 2022-04-07 15:31:40.000000000 +0200 @@ -0,0 +1,35 @@ +commit 15c30606298e40a76d1a125723ce819aba3760e9 +Author: Artyom Pavlov <newpav...@gmail.com> +Date: Thu Jun 11 17:55:10 2020 +0300 + + Bump opaque-debug to v0.3.0 (#168) + +--- a/Cargo.toml ++++ b/Cargo.toml +@@ -30,7 +30,7 @@ + version = "0.9" + + [dependencies.opaque-debug] +-version = "0.2" ++version = "0.3" + + [dependencies.sha1-asm] + version = "0.4" +--- a/src/lib.rs ++++ b/src/lib.rs +@@ -29,7 +29,6 @@ + #![doc(html_logo_url = + "https://raw.githubusercontent.com/RustCrypto/meta/master/logo_small.png")] + extern crate block_buffer; +-#[macro_use] extern crate opaque_debug; + #[macro_use] pub extern crate digest; + #[cfg(feature = "std")] + extern crate std; +@@ -108,5 +107,5 @@ + } + } + +-impl_opaque_debug!(Sha1); +-impl_write!(Sha1); ++opaque_debug::implement!(Sha1); ++digest::impl_write!(Sha1); diff -Nru rust-sha-1-0.8.1/debian/patches/series rust-sha-1-0.8.1/debian/patches/series --- rust-sha-1-0.8.1/debian/patches/series 1970-01-01 01:00:00.000000000 +0100 +++ rust-sha-1-0.8.1/debian/patches/series 2022-04-07 15:10:26.000000000 +0200 @@ -0,0 +1,5 @@ +020200527~c43d34c.patch +020200602~d749cb0.patch +020200609~26bea13.patch +020200610~d24f26b.patch +020200611~15c3060.patch diff -Nru rust-sha-1-0.8.1/debian/tests/control rust-sha-1-0.8.1/debian/tests/control --- rust-sha-1-0.8.1/debian/tests/control 1970-01-01 01:00:00.000000000 +0100 +++ rust-sha-1-0.8.1/debian/tests/control 2022-04-07 13:22:04.000000000 +0200 @@ -0,0 +1,24 @@ +Test-Command: /usr/share/cargo/bin/cargo-auto-test rust-sha-1 0.8.1 --all-targets --all-features +Features: test-name=rust-sha-1:@ +Depends: dh-cargo, @ +Restrictions: allow-stderr, skip-not-installable, flaky + +Test-Command: /usr/share/cargo/bin/cargo-auto-test rust-sha-1 0.8.1 --all-targets +Features: test-name=librust-sha-1-dev:default +Depends: dh-cargo, @ +Restrictions: allow-stderr, skip-not-installable, flaky + +Test-Command: /usr/share/cargo/bin/cargo-auto-test rust-sha-1 0.8.1 --all-targets --no-default-features --features asm +Features: test-name=librust-sha-1-dev:asm +Depends: dh-cargo, @ +Restrictions: allow-stderr, skip-not-installable, flaky + +Test-Command: /usr/share/cargo/bin/cargo-auto-test rust-sha-1 0.8.1 --all-targets --no-default-features --features std +Features: test-name=librust-sha-1-dev:std +Depends: dh-cargo, @ +Restrictions: allow-stderr, skip-not-installable, flaky + +Test-Command: /usr/share/cargo/bin/cargo-auto-test rust-sha-1 0.8.1 --all-targets --no-default-features +Features: test-name=librust-sha-1-dev: +Depends: dh-cargo, @ +Restrictions: allow-stderr, skip-not-installable, flaky