Skip to content

Commit be2999a

Browse files
apoelstraapoelstra
committed
Merge #608: change --cfg=fuzzing to --cfg=secp256k1_fuzzing
9bdab89 change --cfg=fuzzing to --cfg=secp256k1_fuzz (Andrew Poelstra) Pull request description: Companion PR to rust-bitcoin/rust-bitcoin#1821 ACKs for top commit: sanket1729: ACK 9bdab89 Tree-SHA512: 9ff5ce4cae99089f85a73a845cd5dca7b7d0ad9e73c0ee180e73fd9a55c6b92f21ad0192c8c0976e2e590be9d5d899b113b8b2006a3c53e0146a3ce5ba1450ec
2 parents 74e6ced + 9bdab89 commit be2999a

File tree

11 files changed

+91
-89
lines changed

11 files changed

+91
-89
lines changed

‎README.md

+4-2
Original file line numberDiff line numberDiff line change
@@ -54,7 +54,9 @@ If you want to fuzz this library, or any library which depends on it, you will
5454
probably want to disable the actual cryptography, since fuzzers are unable to
5555
forge signatures and therefore won't test many interesting codepaths. To instead
5656
use a trivially-broken but fuzzer-accessible signature scheme, compile with
57-
`--cfg=fuzzing` in your `RUSTFLAGS` variable.
57+
`--cfg=secp256k1_fuzz` in your `RUSTFLAGS` variable.
5858

59-
Note that `cargo hfuzz` sets this config flag automatically.
59+
Note that `cargo hfuzz` does **not** set this config flag automatically. In 0.27.0
60+
and earlier versions, we used the `--cfg=fuzzing` which honggfuzz does set, but we
61+
changed this because there was no way to override it.
6062

‎contrib/test.sh

+3-3
Original file line numberDiff line numberDiff line change
@@ -43,13 +43,13 @@ if [ "$DO_FEATURE_MATRIX" = true ]; then
4343
cargo test --all --no-default-features --features="std,$feature"
4444
done
4545
# Other combos
46-
RUSTFLAGS='--cfg=fuzzing' RUSTDOCFLAGS='--cfg=fuzzing' cargo test --all
47-
RUSTFLAGS='--cfg=fuzzing' RUSTDOCFLAGS='--cfg=fuzzing' cargo test --all --features="$FEATURES"
46+
RUSTFLAGS='--cfg=secp256k1_fuzz' RUSTDOCFLAGS='--cfg=secp256k1_fuzz' cargo test --all
47+
RUSTFLAGS='--cfg=secp256k1_fuzz' RUSTDOCFLAGS='--cfg=secp256k1_fuzz' cargo test --all --features="$FEATURES"
4848
cargo test --all --features="rand serde"
4949

5050
if [ "$NIGHTLY" = true ]; then
5151
cargo test --all --all-features
52-
RUSTFLAGS='--cfg=fuzzing' RUSTDOCFLAGS='--cfg=fuzzing' cargo test --all --all-features
52+
RUSTFLAGS='--cfg=secp256k1_fuzz' RUSTDOCFLAGS='--cfg=secp256k1_fuzz' cargo test --all --all-features
5353
fi
5454

5555
# Examples

‎secp256k1-sys/src/lib.rs

+28-28
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,7 @@ extern crate core;
2828
#[cfg(feature = "alloc")]
2929
extern crate alloc;
3030

31-
#[cfg(fuzzing)]
31+
#[cfg(secp256k1_fuzz)]
3232
const THIS_UNUSED_CONSTANT_IS_YOUR_WARNING_THAT_ALL_THE_CRYPTO_IN_THIS_LIB_IS_DISABLED_FOR_FUZZING: usize = 0;
3333

3434
mod macros;
@@ -133,7 +133,7 @@ impl SchnorrSigExtraParams {
133133
/// Library-internal representation of a Secp256k1 public key
134134
#[repr(C)]
135135
#[derive(Copy, Clone)]
136-
#[cfg_attr(fuzzing, derive(PartialEq, Eq, PartialOrd, Ord, Hash))]
136+
#[cfg_attr(secp256k1_fuzz, derive(PartialEq, Eq, PartialOrd, Ord, Hash))]
137137
pub struct PublicKey([c_uchar; 64]);
138138
impl_array_newtype!(PublicKey, c_uchar, 64);
139139
impl_raw_debug!(PublicKey);
@@ -190,14 +190,14 @@ impl PublicKey {
190190
}
191191
}
192192

193-
#[cfg(not(fuzzing))]
193+
#[cfg(not(secp256k1_fuzz))]
194194
impl PartialOrd for PublicKey {
195195
fn partial_cmp(&self, other: &PublicKey) -> Option<core::cmp::Ordering> {
196196
Some(self.cmp(other))
197197
}
198198
}
199199

200-
#[cfg(not(fuzzing))]
200+
#[cfg(not(secp256k1_fuzz))]
201201
impl Ord for PublicKey {
202202
fn cmp(&self, other: &PublicKey) -> core::cmp::Ordering {
203203
let ret = unsafe {
@@ -207,17 +207,17 @@ impl Ord for PublicKey {
207207
}
208208
}
209209

210-
#[cfg(not(fuzzing))]
210+
#[cfg(not(secp256k1_fuzz))]
211211
impl PartialEq for PublicKey {
212212
fn eq(&self, other: &Self) -> bool {
213213
self.cmp(other) == core::cmp::Ordering::Equal
214214
}
215215
}
216216

217-
#[cfg(not(fuzzing))]
217+
#[cfg(not(secp256k1_fuzz))]
218218
impl Eq for PublicKey {}
219219

220-
#[cfg(not(fuzzing))]
220+
#[cfg(not(secp256k1_fuzz))]
221221
impl core::hash::Hash for PublicKey {
222222
fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
223223
let ser = self.serialize();
@@ -228,7 +228,7 @@ impl core::hash::Hash for PublicKey {
228228
/// Library-internal representation of a Secp256k1 signature
229229
#[repr(C)]
230230
#[derive(Copy, Clone)]
231-
#[cfg_attr(fuzzing, derive(PartialEq, Eq, PartialOrd, Ord, Hash))]
231+
#[cfg_attr(secp256k1_fuzz, derive(PartialEq, Eq, PartialOrd, Ord, Hash))]
232232
pub struct Signature([c_uchar; 64]);
233233
impl_array_newtype!(Signature, c_uchar, 64);
234234
impl_raw_debug!(Signature);
@@ -281,14 +281,14 @@ impl Signature {
281281
}
282282
}
283283

284-
#[cfg(not(fuzzing))]
284+
#[cfg(not(secp256k1_fuzz))]
285285
impl PartialOrd for Signature {
286286
fn partial_cmp(&self, other: &Signature) -> Option<core::cmp::Ordering> {
287287
Some(self.cmp(other))
288288
}
289289
}
290290

291-
#[cfg(not(fuzzing))]
291+
#[cfg(not(secp256k1_fuzz))]
292292
impl Ord for Signature {
293293
fn cmp(&self, other: &Signature) -> core::cmp::Ordering {
294294
let this = self.serialize();
@@ -297,17 +297,17 @@ impl Ord for Signature {
297297
}
298298
}
299299

300-
#[cfg(not(fuzzing))]
300+
#[cfg(not(secp256k1_fuzz))]
301301
impl PartialEq for Signature {
302302
fn eq(&self, other: &Self) -> bool {
303303
self.cmp(other) == core::cmp::Ordering::Equal
304304
}
305305
}
306306

307-
#[cfg(not(fuzzing))]
307+
#[cfg(not(secp256k1_fuzz))]
308308
impl Eq for Signature {}
309309

310-
#[cfg(not(fuzzing))]
310+
#[cfg(not(secp256k1_fuzz))]
311311
impl core::hash::Hash for Signature {
312312
fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
313313
let ser = self.serialize();
@@ -317,7 +317,7 @@ impl core::hash::Hash for Signature {
317317

318318
#[repr(C)]
319319
#[derive(Copy, Clone)]
320-
#[cfg_attr(fuzzing, derive(PartialEq, Eq, PartialOrd, Ord, Hash))]
320+
#[cfg_attr(secp256k1_fuzz, derive(PartialEq, Eq, PartialOrd, Ord, Hash))]
321321
pub struct XOnlyPublicKey([c_uchar; 64]);
322322
impl_array_newtype!(XOnlyPublicKey, c_uchar, 64);
323323
impl_raw_debug!(XOnlyPublicKey);
@@ -370,14 +370,14 @@ impl XOnlyPublicKey {
370370
}
371371
}
372372

373-
#[cfg(not(fuzzing))]
373+
#[cfg(not(secp256k1_fuzz))]
374374
impl PartialOrd for XOnlyPublicKey {
375375
fn partial_cmp(&self, other: &XOnlyPublicKey) -> Option<core::cmp::Ordering> {
376376
Some(self.cmp(other))
377377
}
378378
}
379379

380-
#[cfg(not(fuzzing))]
380+
#[cfg(not(secp256k1_fuzz))]
381381
impl Ord for XOnlyPublicKey {
382382
fn cmp(&self, other: &XOnlyPublicKey) -> core::cmp::Ordering {
383383
let ret = unsafe {
@@ -387,17 +387,17 @@ impl Ord for XOnlyPublicKey {
387387
}
388388
}
389389

390-
#[cfg(not(fuzzing))]
390+
#[cfg(not(secp256k1_fuzz))]
391391
impl PartialEq for XOnlyPublicKey {
392392
fn eq(&self, other: &Self) -> bool {
393393
self.cmp(other) == core::cmp::Ordering::Equal
394394
}
395395
}
396396

397-
#[cfg(not(fuzzing))]
397+
#[cfg(not(secp256k1_fuzz))]
398398
impl Eq for XOnlyPublicKey {}
399399

400-
#[cfg(not(fuzzing))]
400+
#[cfg(not(secp256k1_fuzz))]
401401
impl core::hash::Hash for XOnlyPublicKey {
402402
fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
403403
let ser = self.serialize();
@@ -407,7 +407,7 @@ impl core::hash::Hash for XOnlyPublicKey {
407407

408408
#[repr(C)]
409409
#[derive(Copy, Clone)]
410-
#[cfg_attr(fuzzing, derive(PartialEq, Eq, PartialOrd, Ord, Hash))]
410+
#[cfg_attr(secp256k1_fuzz, derive(PartialEq, Eq, PartialOrd, Ord, Hash))]
411411
pub struct KeyPair([c_uchar; 96]);
412412
impl_array_newtype!(KeyPair, c_uchar, 96);
413413
impl_raw_debug!(KeyPair);
@@ -492,14 +492,14 @@ pub fn non_secure_erase_impl<T>(dst: &mut T, src: T) {
492492
atomic::compiler_fence(atomic::Ordering::SeqCst);
493493
}
494494

495-
#[cfg(not(fuzzing))]
495+
#[cfg(not(secp256k1_fuzz))]
496496
impl PartialOrd for KeyPair {
497497
fn partial_cmp(&self, other: &KeyPair) -> Option<core::cmp::Ordering> {
498498
Some(self.cmp(other))
499499
}
500500
}
501501

502-
#[cfg(not(fuzzing))]
502+
#[cfg(not(secp256k1_fuzz))]
503503
impl Ord for KeyPair {
504504
fn cmp(&self, other: &KeyPair) -> core::cmp::Ordering {
505505
let this = self.public_key();
@@ -508,17 +508,17 @@ impl Ord for KeyPair {
508508
}
509509
}
510510

511-
#[cfg(not(fuzzing))]
511+
#[cfg(not(secp256k1_fuzz))]
512512
impl PartialEq for KeyPair {
513513
fn eq(&self, other: &Self) -> bool {
514514
self.cmp(other) == core::cmp::Ordering::Equal
515515
}
516516
}
517517

518-
#[cfg(not(fuzzing))]
518+
#[cfg(not(secp256k1_fuzz))]
519519
impl Eq for KeyPair {}
520520

521-
#[cfg(not(fuzzing))]
521+
#[cfg(not(secp256k1_fuzz))]
522522
impl core::hash::Hash for KeyPair {
523523
fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
524524
// To hash the key pair we just hash the serialized public key. Since any change to the
@@ -615,7 +615,7 @@ extern "C" {
615615
-> c_int;
616616
}
617617

618-
#[cfg(not(fuzzing))]
618+
#[cfg(not(secp256k1_fuzz))]
619619
extern "C" {
620620
// Contexts
621621
#[cfg_attr(not(rust_secp_no_symbol_renaming), link_name = "rustsecp256k1_v0_8_1_context_preallocated_size")]
@@ -996,7 +996,7 @@ impl<T> CPtr for [T] {
996996
}
997997
}
998998

999-
#[cfg(fuzzing)]
999+
#[cfg(secp256k1_fuzz)]
10001000
mod fuzz_dummy {
10011001
use super::*;
10021002
use core::sync::atomic::{AtomicUsize, Ordering};
@@ -1482,7 +1482,7 @@ mod fuzz_dummy {
14821482
}
14831483
}
14841484

1485-
#[cfg(fuzzing)]
1485+
#[cfg(secp256k1_fuzz)]
14861486
pub use self::fuzz_dummy::*;
14871487

14881488
#[cfg(test)]

‎secp256k1-sys/src/recovery.rs

+9-9
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@ use core::fmt;
2222
/// Library-internal representation of a Secp256k1 signature + recovery ID
2323
#[repr(C)]
2424
#[derive(Copy, Clone)]
25-
#[cfg_attr(fuzzing, derive(PartialEq, Eq, PartialOrd, Ord, Hash))]
25+
#[cfg_attr(secp256k1_fuzz, derive(PartialEq, Eq, PartialOrd, Ord, Hash))]
2626
pub struct RecoverableSignature([c_uchar; 65]);
2727
impl_array_newtype!(RecoverableSignature, c_uchar, 65);
2828

@@ -78,14 +78,14 @@ impl fmt::Debug for RecoverableSignature {
7878
}
7979
}
8080

81-
#[cfg(not(fuzzing))]
81+
#[cfg(not(secp256k1_fuzz))]
8282
impl PartialOrd for RecoverableSignature {
8383
fn partial_cmp(&self, other: &RecoverableSignature) -> Option<core::cmp::Ordering> {
8484
Some(self.cmp(other))
8585
}
8686
}
8787

88-
#[cfg(not(fuzzing))]
88+
#[cfg(not(secp256k1_fuzz))]
8989
impl Ord for RecoverableSignature {
9090
fn cmp(&self, other: &RecoverableSignature) -> core::cmp::Ordering {
9191
let this = self.serialize();
@@ -94,17 +94,17 @@ impl Ord for RecoverableSignature {
9494
}
9595
}
9696

97-
#[cfg(not(fuzzing))]
97+
#[cfg(not(secp256k1_fuzz))]
9898
impl PartialEq for RecoverableSignature {
9999
fn eq(&self, other: &Self) -> bool {
100100
self.cmp(other) == core::cmp::Ordering::Equal
101101
}
102102
}
103103

104-
#[cfg(not(fuzzing))]
104+
#[cfg(not(secp256k1_fuzz))]
105105
impl Eq for RecoverableSignature {}
106106

107-
#[cfg(not(fuzzing))]
107+
#[cfg(not(secp256k1_fuzz))]
108108
impl core::hash::Hash for RecoverableSignature {
109109
fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
110110
let ser = self.serialize();
@@ -129,7 +129,7 @@ extern "C" {
129129
-> c_int;
130130
}
131131

132-
#[cfg(not(fuzzing))]
132+
#[cfg(not(secp256k1_fuzz))]
133133
extern "C" {
134134
#[cfg_attr(not(rust_secp_no_symbol_renaming), link_name = "rustsecp256k1_v0_8_1_ecdsa_sign_recoverable")]
135135
pub fn secp256k1_ecdsa_sign_recoverable(cx: *const Context,
@@ -149,7 +149,7 @@ extern "C" {
149149
}
150150

151151

152-
#[cfg(fuzzing)]
152+
#[cfg(secp256k1_fuzz)]
153153
mod fuzz_dummy {
154154
use core::slice;
155155

@@ -221,5 +221,5 @@ mod fuzz_dummy {
221221
}
222222
}
223223

224-
#[cfg(fuzzing)]
224+
#[cfg(secp256k1_fuzz)]
225225
pub use self::fuzz_dummy::*;

‎src/ecdh.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -238,7 +238,7 @@ mod tests {
238238
}
239239

240240
#[test]
241-
#[cfg(not(fuzzing))]
241+
#[cfg(not(secp256k1_fuzz))]
242242
#[cfg(all(feature = "bitcoin-hashes-std", feature = "rand-std"))]
243243
fn bitcoin_hashes_and_sys_generate_same_secret() {
244244
use bitcoin_hashes::{sha256, Hash, HashEngine};

‎src/ecdsa/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -326,7 +326,7 @@ impl<C: Signing> Secp256k1<C> {
326326
entropy_p = extra_entropy.as_c_ptr().cast::<ffi::types::c_void>();
327327

328328
// When fuzzing, these checks will usually spinloop forever, so just short-circuit them.
329-
#[cfg(fuzzing)]
329+
#[cfg(secp256k1_fuzz)]
330330
return Signature::from(ret);
331331
}
332332
}

‎src/ecdsa/recovery.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -264,7 +264,7 @@ mod tests {
264264
}
265265

266266
#[test]
267-
#[cfg(not(fuzzing))] // fixed sig vectors can't work with fuzz-sigs
267+
#[cfg(not(secp256k1_fuzz))] // fixed sig vectors can't work with fuzz-sigs
268268
#[cfg(feature = "rand-std")]
269269
#[rustfmt::skip]
270270
fn sign() {
@@ -289,7 +289,7 @@ mod tests {
289289
}
290290

291291
#[test]
292-
#[cfg(not(fuzzing))] // fixed sig vectors can't work with fuzz-sigs
292+
#[cfg(not(secp256k1_fuzz))] // fixed sig vectors can't work with fuzz-sigs
293293
#[cfg(feature = "rand-std")]
294294
#[rustfmt::skip]
295295
fn sign_with_noncedata() {

0 commit comments

Comments
 (0)