milksad
/
rust-bitcoin-unsafe-fast
14
0
Fork 0
Code Issues Pull Requests Activity

hashes: reformat 

Essentially this just adds indentation after the previous commit.
This commit is contained in:
Andrew Poelstra 2025-05-05 16:55:15 +00:00
parent aadd7df266
commit 0aeff359f5
No known key found for this signature in database
GPG Key ID: C588D63CE41B97C1
8 changed files with 124 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
hashes/src/hash160/mod.rs
View File

@ -15,17 +15,16 @@ crate::internal_macros::general_hash_type! {
"Output of the Bitcoin HASH160 hash function. (RIPEMD160(SHA256))" "Output of the Bitcoin HASH160 hash function. (RIPEMD160(SHA256))"
} }
impl Hash { impl Hash {
/// Finalize a hash engine to produce a hash. /// Finalize a hash engine to produce a hash.
pub fn from_engine(e: HashEngine) -> Self { pub fn from_engine(e: HashEngine) -> Self {
let sha2 = sha256::Hash::from_engine(e.0); let sha2 = sha256::Hash::from_engine(e.0);
let rmd = ripemd160::Hash::hash(sha2.as_byte_array()); let rmd = ripemd160::Hash::hash(sha2.as_byte_array());
let mut ret = [0; 20]; let mut ret = [0; 20];
ret.copy_from_slice(rmd.as_byte_array()); ret.copy_from_slice(rmd.as_byte_array());
Hash(ret) Hash(ret)
} }
} }
/// Engine to compute HASH160 hash function. /// Engine to compute HASH160 hash function.

51
hashes/src/ripemd160/mod.rs
View File

@ -20,36 +20,35 @@ crate::internal_macros::general_hash_type! {
"Output of the RIPEMD160 hash function." "Output of the RIPEMD160 hash function."
} }
impl Hash { impl Hash {
/// Finalize a hash engine to produce a hash. /// Finalize a hash engine to produce a hash.
#[cfg(not(hashes_fuzz))] #[cfg(not(hashes_fuzz))]
pub fn from_engine(mut e: HashEngine) -> Self { pub fn from_engine(mut e: HashEngine) -> Self {
// pad buffer with a single 1-bit then all 0s, until there are exactly 8 bytes remaining // pad buffer with a single 1-bit then all 0s, until there are exactly 8 bytes remaining
let n_bytes_hashed = e.bytes_hashed; let n_bytes_hashed = e.bytes_hashed;
let zeroes = [0; BLOCK_SIZE - 8]; let zeroes = [0; BLOCK_SIZE - 8];
e.input(&[0x80]); e.input(&[0x80]);
if crate::incomplete_block_len(&e) > zeroes.len() { if crate::incomplete_block_len(&e) > zeroes.len() {
e.input(&zeroes); e.input(&zeroes);
}
let pad_length = zeroes.len() - incomplete_block_len(&e);
e.input(&zeroes[..pad_length]);
debug_assert_eq!(incomplete_block_len(&e), zeroes.len());
e.input(&(8 * n_bytes_hashed).to_le_bytes());
debug_assert_eq!(incomplete_block_len(&e), 0);
Hash(e.midstate())
} }
let pad_length = zeroes.len() - incomplete_block_len(&e);
e.input(&zeroes[..pad_length]);
debug_assert_eq!(incomplete_block_len(&e), zeroes.len());
e.input(&(8 * n_bytes_hashed).to_le_bytes()); /// Finalize a hash engine to produce a hash.
debug_assert_eq!(incomplete_block_len(&e), 0); #[cfg(hashes_fuzz)]
pub fn from_engine(e: HashEngine) -> Self {
Hash(e.midstate()) let mut res = e.midstate();
} res[0] ^= (e.bytes_hashed & 0xff) as u8;
Hash(res)
/// Finalize a hash engine to produce a hash. }
#[cfg(hashes_fuzz)]
pub fn from_engine(e: HashEngine) -> Self {
let mut res = e.midstate();
res[0] ^= (e.bytes_hashed & 0xff) as u8;
Hash(res)
}
} }
const BLOCK_SIZE: usize = 64; const BLOCK_SIZE: usize = 64;

34
hashes/src/sha1/mod.rs
View File

@ -21,25 +21,25 @@ crate::internal_macros::general_hash_type! {
} }
impl Hash { impl Hash {
/// Finalize a hash engine to produce a hash. /// Finalize a hash engine to produce a hash.
pub fn from_engine(mut e: HashEngine) -> Self { pub fn from_engine(mut e: HashEngine) -> Self {
// pad buffer with a single 1-bit then all 0s, until there are exactly 8 bytes remaining // pad buffer with a single 1-bit then all 0s, until there are exactly 8 bytes remaining
let n_bytes_hashed = e.bytes_hashed; let n_bytes_hashed = e.bytes_hashed;
let zeroes = [0; BLOCK_SIZE - 8]; let zeroes = [0; BLOCK_SIZE - 8];
e.input(&[0x80]); e.input(&[0x80]);
if incomplete_block_len(&e) > zeroes.len() { if incomplete_block_len(&e) > zeroes.len() {
e.input(&zeroes); e.input(&zeroes);
}
let pad_length = zeroes.len() - incomplete_block_len(&e);
e.input(&zeroes[..pad_length]);
debug_assert_eq!(incomplete_block_len(&e), zeroes.len());
e.input(&(8 * n_bytes_hashed).to_be_bytes());
debug_assert_eq!(incomplete_block_len(&e), 0);
Hash(e.midstate())
} }
let pad_length = zeroes.len() - incomplete_block_len(&e);
e.input(&zeroes[..pad_length]);
debug_assert_eq!(incomplete_block_len(&e), zeroes.len());
e.input(&(8 * n_bytes_hashed).to_be_bytes());
debug_assert_eq!(incomplete_block_len(&e), 0);
Hash(e.midstate())
}
} }
const BLOCK_SIZE: usize = 64; const BLOCK_SIZE: usize = 64;

56
hashes/src/sha256/mod.rs
View File

@ -110,38 +110,38 @@ impl crate::HashEngine for HashEngine {
} }
impl Hash { impl Hash {
/// Finalize a hash engine to obtain a hash. /// Finalize a hash engine to obtain a hash.
#[cfg(not(hashes_fuzz))] #[cfg(not(hashes_fuzz))]
pub fn from_engine(mut e: HashEngine) -> Self { pub fn from_engine(mut e: HashEngine) -> Self {
// pad buffer with a single 1-bit then all 0s, until there are exactly 8 bytes remaining // pad buffer with a single 1-bit then all 0s, until there are exactly 8 bytes remaining
let n_bytes_hashed = e.bytes_hashed; let n_bytes_hashed = e.bytes_hashed;
let zeroes = [0; BLOCK_SIZE - 8]; let zeroes = [0; BLOCK_SIZE - 8];
e.input(&[0x80]); e.input(&[0x80]);
if incomplete_block_len(&e) > zeroes.len() { if incomplete_block_len(&e) > zeroes.len() {
e.input(&zeroes); e.input(&zeroes);
}
let pad_length = zeroes.len() - incomplete_block_len(&e);
e.input(&zeroes[..pad_length]);
debug_assert_eq!(incomplete_block_len(&e), zeroes.len());
e.input(&(8 * n_bytes_hashed).to_be_bytes());
debug_assert_eq!(incomplete_block_len(&e), 0);
Hash(e.midstate_unchecked().bytes)
} }
let pad_length = zeroes.len() - incomplete_block_len(&e);
e.input(&zeroes[..pad_length]);
debug_assert_eq!(incomplete_block_len(&e), zeroes.len());
e.input(&(8 * n_bytes_hashed).to_be_bytes()); /// Finalize a hash engine to obtain a hash.
debug_assert_eq!(incomplete_block_len(&e), 0); #[cfg(hashes_fuzz)]
pub fn from_engine(e: HashEngine) -> Self {
Hash(e.midstate_unchecked().bytes) let mut hash = e.midstate_unchecked().bytes;
} if hash == [0; 32] {
// Assume sha256 is secure and never generate 0-hashes (which represent invalid
/// Finalize a hash engine to obtain a hash. // secp256k1 secret keys, causing downstream application breakage).
#[cfg(hashes_fuzz)] hash[0] = 1;
pub fn from_engine(e: HashEngine) -> Self { }
let mut hash = e.midstate_unchecked().bytes; Hash(hash)
if hash == [0; 32] {
// Assume sha256 is secure and never generate 0-hashes (which represent invalid
// secp256k1 secret keys, causing downstream application breakage).
hash[0] = 1;
} }
Hash(hash)
}
/// Iterate the sha256 algorithm to turn a sha256 hash into a sha256d hash /// Iterate the sha256 algorithm to turn a sha256 hash into a sha256d hash
#[must_use] #[must_use]

16
hashes/src/sha256d/mod.rs
View File

@ -11,15 +11,15 @@ crate::internal_macros::general_hash_type! {
} }
impl Hash { impl Hash {
/// Finalize a hash engine to produce a hash. /// Finalize a hash engine to produce a hash.
pub fn from_engine(e: HashEngine) -> Self { pub fn from_engine(e: HashEngine) -> Self {
let sha2 = sha256::Hash::from_engine(e.0); let sha2 = sha256::Hash::from_engine(e.0);
let sha2d = sha256::Hash::hash(sha2.as_byte_array()); let sha2d = sha256::Hash::hash(sha2.as_byte_array());
let mut ret = [0; 32]; let mut ret = [0; 32];
ret.copy_from_slice(sha2d.as_byte_array()); ret.copy_from_slice(sha2d.as_byte_array());
Hash(ret) Hash(ret)
} }
} }
/// Engine to compute SHA256d hash function. /// Engine to compute SHA256d hash function.

12
hashes/src/sha384/mod.rs
View File

@ -11,12 +11,12 @@ crate::internal_macros::general_hash_type! {
} }
impl Hash { impl Hash {
/// Finalize a hash engine to produce a hash. /// Finalize a hash engine to produce a hash.
pub fn from_engine(e: HashEngine) -> Self { pub fn from_engine(e: HashEngine) -> Self {
let mut ret = [0; 48]; let mut ret = [0; 48];
ret.copy_from_slice(&sha512::Hash::from_engine(e.0).as_byte_array()[..48]); ret.copy_from_slice(&sha512::Hash::from_engine(e.0).as_byte_array()[..48]);
Hash(ret) Hash(ret)
} }
} }
/// Engine to compute SHA384 hash function. /// Engine to compute SHA384 hash function.

52
hashes/src/sha512/mod.rs
View File

@ -21,35 +21,35 @@ crate::internal_macros::general_hash_type! {
} }
impl Hash { impl Hash {
/// Finalize a hash engine to produce a hash. /// Finalize a hash engine to produce a hash.
#[cfg(not(hashes_fuzz))] #[cfg(not(hashes_fuzz))]
pub fn from_engine(mut e: HashEngine) -> Self { pub fn from_engine(mut e: HashEngine) -> Self {
// pad buffer with a single 1-bit then all 0s, until there are exactly 16 bytes remaining // pad buffer with a single 1-bit then all 0s, until there are exactly 16 bytes remaining
let n_bytes_hashed = e.bytes_hashed; let n_bytes_hashed = e.bytes_hashed;
let zeroes = [0; BLOCK_SIZE - 16]; let zeroes = [0; BLOCK_SIZE - 16];
e.input(&[0x80]); e.input(&[0x80]);
if incomplete_block_len(&e) > zeroes.len() { if incomplete_block_len(&e) > zeroes.len() {
e.input(&zeroes); e.input(&zeroes);
}
let pad_length = zeroes.len() - incomplete_block_len(&e);
e.input(&zeroes[..pad_length]);
debug_assert_eq!(incomplete_block_len(&e), zeroes.len());
e.input(&[0; 8]);
e.input(&(8 * n_bytes_hashed).to_be_bytes());
debug_assert_eq!(incomplete_block_len(&e), 0);
Hash(e.midstate())
} }
let pad_length = zeroes.len() - incomplete_block_len(&e);
e.input(&zeroes[..pad_length]);
debug_assert_eq!(incomplete_block_len(&e), zeroes.len());
e.input(&[0; 8]); /// Finalize a hash engine to produce a hash.
e.input(&(8 * n_bytes_hashed).to_be_bytes()); #[cfg(hashes_fuzz)]
debug_assert_eq!(incomplete_block_len(&e), 0); pub fn from_engine(e: HashEngine) -> Self {
let mut hash = e.midstate();
Hash(e.midstate()) hash[0] ^= 0xff; // Make this distinct from SHA-256
} Hash(hash)
}
/// Finalize a hash engine to produce a hash.
#[cfg(hashes_fuzz)]
pub fn from_engine(e: HashEngine) -> Self {
let mut hash = e.midstate();
hash[0] ^= 0xff; // Make this distinct from SHA-256
Hash(hash)
}
} }
pub(crate) const BLOCK_SIZE: usize = 128; pub(crate) const BLOCK_SIZE: usize = 128;

12
hashes/src/sha512_256/mod.rs
View File

@ -16,12 +16,12 @@ crate::internal_macros::general_hash_type! {
} }
impl Hash { impl Hash {
/// Finalize a hash engine to produce a hash. /// Finalize a hash engine to produce a hash.
pub fn from_engine(e: HashEngine) -> Self { pub fn from_engine(e: HashEngine) -> Self {
let mut ret = [0; 32]; let mut ret = [0; 32];
ret.copy_from_slice(&sha512::Hash::from_engine(e.0).as_byte_array()[..32]); ret.copy_from_slice(&sha512::Hash::from_engine(e.0).as_byte_array()[..32]);
Hash(ret) Hash(ret)
} }
} }
/// Engine to compute SHA512/256 hash function. /// Engine to compute SHA512/256 hash function.