Informational 15 Bitcoin Committed Feb 11, 2026 · 02:42 UTC

benches: fix hash benches to measure full hash

2e12407c View source ↗

Public commit record

What the developer wrote

Authored by jrakibi

76/100 · Adequate

benches: fix hash benches to measure full hash

The current hash benchmarks create the engine once and then repeatedly call
`engine.input()` on the same engine. This does not measure a full hash
operation per iteration (create engine -> `input()` -> `finalize()`).

The previous benchmark numbers are optimistic, especially for small
inputs, and does not reflect real cost of hashing.

I ran a before/after comparison for sha256:
On master:
- 10 bytes: 9.5514 ns
- 1024 bytes: 532.90 ns
- 65536 bytes: 34.533 us
This PR:
- 10 bytes: 51.360 ns
- 1024 bytes: 553.34 ns
- 65536 bytes: 33.796 us

On small inputs the old benchmark was around 5x too optimistic.
(for larger inputs the difference is small)

Discussed in https://github.com/rust-bitcoin/rust-bitcoin/pull/5604#issuecomment-3866577775

✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference

The short version

What changed, and why it matters

This change only fixes how hash performance is measured in benchmark tests. It does not change any real hashing code that users or applications rely on, so it has no security impact on the library itself.

Recommended action

No security action needed; this is a benchmark-only correctness improvement.

Security signals we found

No strong security signals were identified.

Technical analysis

Evidence from the diff

The commit modifies Criterion benchmark files under benches/hashes/ to move engine creation and finalization inside the measured loop, so each iteration measures a complete hash operation rather than only repeated input feeding. The actual hash engine implementations are untouched. No runtime behavior, API, or cryptographic logic changes.

Changed components

benches/hashes/hash160.rsbenches/hashes/hmac.rsbenches/hashes/ripemd160.rsbenches/hashes/sha1.rsbenches/hashes/sha256.rsbenches/hashes/sha384.rsbenches/hashes/sha3_256.rsbenches/hashes/sha512.rsbenches/hashes/sha512_256.rsbenches/hashes/siphash24.rs

Inspect captured patch +20 / −10

diff --git a/benches/hashes/hash160.rs b/benches/hashes/hash160.rs
index 452fd454..646e1e40 100644
--- a/benches/hashes/hash160.rs
+++ b/benches/hashes/hash160.rs
@@ -9,12 +9,13 @@ fn bench_hash160(c: &mut Criterion) {
     let mut g = c.benchmark_group("hash160");
 
     for &size in &[10usize, 1024, 65536] {
-        let mut engine = hash160::Hash::engine();
         let bytes = vec![1u8; size];
         g.throughput(Throughput::Bytes(size as u64));
         g.bench_function(BenchmarkId::new("engine_input", size), |b| {
             b.iter(|| {
+                let mut engine = hash160::Hash::engine();
                 engine.input(black_box(&bytes));
+                black_box(engine.finalize());
             });
         });
     }
diff --git a/benches/hashes/hmac.rs b/benches/hashes/hmac.rs
index adc90e51..16d4a365 100644
--- a/benches/hashes/hmac.rs
+++ b/benches/hashes/hmac.rs
@@ -9,12 +9,13 @@ fn bench_hmac(c: &mut Criterion) {
     let mut g = c.benchmark_group("hmac_sha256");
 
     for &size in &[10usize, 1024, 65536] {
-        let mut engine = HmacEngine::<sha256::HashEngine>::new(&[]);
         let bytes = vec![1u8; size];
         g.throughput(Throughput::Bytes(size as u64));
         g.bench_function(BenchmarkId::new("engine_input", size), |b| {
             b.iter(|| {
+                let mut engine = HmacEngine::<sha256::HashEngine>::new(&[]);
                 engine.input(black_box(&bytes));
+                black_box(engine.finalize());
             });
         });
     }
diff --git a/benches/hashes/ripemd160.rs b/benches/hashes/ripemd160.rs
index b786e77a..0d288919 100644
--- a/benches/hashes/ripemd160.rs
+++ b/benches/hashes/ripemd160.rs
@@ -9,12 +9,13 @@ fn bench_ripemd160(c: &mut Criterion) {
     let mut g = c.benchmark_group("ripemd160");
 
     for &size in &[10usize, 1024, 65536] {
-        let mut engine = ripemd160::Hash::engine();
         let bytes = vec![1u8; size];
         g.throughput(Throughput::Bytes(size as u64));
         g.bench_function(BenchmarkId::new("engine_input", size), |b| {
             b.iter(|| {
+                let mut engine = ripemd160::Hash::engine();
                 engine.input(black_box(&bytes));
+                black_box(engine.finalize());
             });
         });
     }
diff --git a/benches/hashes/sha1.rs b/benches/hashes/sha1.rs
index a63773f5..5211a356 100644
--- a/benches/hashes/sha1.rs
+++ b/benches/hashes/sha1.rs
@@ -9,12 +9,13 @@ fn bench_sha1(c: &mut Criterion) {
     let mut g = c.benchmark_group("sha1");
 
     for &size in &[10usize, 1024, 65536] {
-        let mut engine = sha1::Hash::engine();
         let bytes = vec![1u8; size];
         g.throughput(Throughput::Bytes(size as u64));
         g.bench_function(BenchmarkId::new("engine_input", size), |b| {
             b.iter(|| {
+                let mut engine = sha1::Hash::engine();
                 engine.input(black_box(&bytes));
+                black_box(engine.finalize());
             });
         });
     }
diff --git a/benches/hashes/sha256.rs b/benches/hashes/sha256.rs
index a8f2d104..01c269e6 100644
--- a/benches/hashes/sha256.rs
+++ b/benches/hashes/sha256.rs
@@ -9,12 +9,13 @@ fn bench_sha256(c: &mut Criterion) {
     let mut g = c.benchmark_group("sha256");
 
     for &size in &[10usize, 1024, 65536] {
-        let mut engine = sha256::Hash::engine();
         let bytes = vec![1u8; size];
         g.throughput(Throughput::Bytes(size as u64));
         g.bench_function(BenchmarkId::new("engine_input", size), |b| {
             b.iter(|| {
+                let mut engine = sha256::Hash::engine();
                 engine.input(black_box(&bytes));
+                black_box(engine.finalize());
             });
         });
     }
diff --git a/benches/hashes/sha384.rs b/benches/hashes/sha384.rs
index 77004ccf..69920129 100644
--- a/benches/hashes/sha384.rs
+++ b/benches/hashes/sha384.rs
@@ -9,12 +9,13 @@ fn bench_sha384(c: &mut Criterion) {
     let mut g = c.benchmark_group("sha384");
 
     for &size in &[10usize, 1024, 65536] {
-        let mut engine = sha384::Hash::engine();
         let bytes = vec![1u8; size];
         g.throughput(Throughput::Bytes(size as u64));
         g.bench_function(BenchmarkId::new("engine_input", size), |b| {
             b.iter(|| {
+                let mut engine = sha384::Hash::engine();
                 engine.input(black_box(&bytes));
+                black_box(engine.finalize());
             });
         });
     }
diff --git a/benches/hashes/sha3_256.rs b/benches/hashes/sha3_256.rs
index 2d4e1087..613110aa 100644
--- a/benches/hashes/sha3_256.rs
+++ b/benches/hashes/sha3_256.rs
@@ -9,12 +9,13 @@ fn bench_sha3_256(c: &mut Criterion) {
     let mut g = c.benchmark_group("sha3_256");
 
     for &size in &[10usize, 1024, 65536] {
-        let mut engine = sha3_256::Hash::engine();
         let bytes = vec![1u8; size];
         g.throughput(Throughput::Bytes(size as u64));
         g.bench_function(BenchmarkId::new("engine_input", size), |b| {
             b.iter(|| {
+                let mut engine = sha3_256::Hash::engine();
                 engine.input(black_box(&bytes));
+                black_box(engine.finalize());
             });
         });
     }
diff --git a/benches/hashes/sha512.rs b/benches/hashes/sha512.rs
index c72d9e61..db738384 100644
--- a/benches/hashes/sha512.rs
+++ b/benches/hashes/sha512.rs
@@ -9,12 +9,13 @@ fn bench_sha512(c: &mut Criterion) {
     let mut g = c.benchmark_group("sha512");
 
     for &size in &[10usize, 1024, 65536] {
-        let mut engine = sha512::Hash::engine();
         let bytes = vec![1u8; size];
         g.throughput(Throughput::Bytes(size as u64));
         g.bench_function(BenchmarkId::new("engine_input", size), |b| {
             b.iter(|| {
+                let mut engine = sha512::Hash::engine();
                 engine.input(black_box(&bytes));
+                black_box(engine.finalize());
             });
         });
     }
diff --git a/benches/hashes/sha512_256.rs b/benches/hashes/sha512_256.rs
index c4cc075d..4ff3cc42 100644
--- a/benches/hashes/sha512_256.rs
+++ b/benches/hashes/sha512_256.rs
@@ -9,12 +9,13 @@ fn bench_sha512_256(c: &mut Criterion) {
     let mut g = c.benchmark_group("sha512_256");
 
     for &size in &[10usize, 1024, 65536] {
-        let mut engine = sha512_256::Hash::engine();
         let bytes = vec![1u8; size];
         g.throughput(Throughput::Bytes(size as u64));
         g.bench_function(BenchmarkId::new("engine_input", size), |b| {
             b.iter(|| {
+                let mut engine = sha512_256::Hash::engine();
                 engine.input(black_box(&bytes));
+                black_box(engine.finalize());
             });
         });
     }
diff --git a/benches/hashes/siphash24.rs b/benches/hashes/siphash24.rs
index f25d6d66..de7c6cf2 100644
--- a/benches/hashes/siphash24.rs
+++ b/benches/hashes/siphash24.rs
@@ -9,12 +9,13 @@ fn bench_siphash24(c: &mut Criterion) {
     let mut g = c.benchmark_group("siphash24");
 
     for &size in &[1024usize, 65536] {
-        let mut engine = siphash24::HashEngine::with_keys(0, 0);
         let bytes = vec![1u8; size];
         g.throughput(Throughput::Bytes(size as u64));
         g.bench_function(BenchmarkId::new("engine_input", size), |b| {
             b.iter(|| {
+                let mut engine = siphash24::HashEngine::with_keys(0, 0);
                 engine.input(black_box(&bytes));
+                black_box(engine.finalize());
             });
         });
     }

Risk score

Why this scored 15/100

Our methodology →

Potential impact 0/30

Exploitability 0/25

Stealth signal 0/15

Affected reach 0/15

Confidence 10/10

Evidence quality 5/5

Human-validated context

Community notes

Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.

No validated notes yet.

The AI analysis stands alone for now. Submit a note if you can add evidence or important context.

What the developer wrote

What changed, and why it matters

Security signals we found

Evidence from the diff

Changed components

Why this scored 15/100

Community notes

Related watches

Merge rust-bitcoin/rust-bitcoin#6670: ci: fix labeller permissions

Merge rust-bitcoin/rust-bitcoin#6657: Release tracking PR: `base58ck 0.5.0`

Merge rust-bitcoin/rust-bitcoin#6440: base58: Introduce `decode_check_to_array` for alloc-less decoding