Skip to content

Commit de3b93d

Browse files
liamaharonliamaharon
committed
Use Into<Message> in signing api
fix: release test
1 parent 36be55f commit de3b93d

File tree

7 files changed

+99
-96
lines changed

7 files changed

+99
-96
lines changed

‎examples/sign_verify.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ fn verify<C: Verification>(
1515
let sig = ecdsa::Signature::from_compact(&sig)?;
1616
let pubkey = PublicKey::from_slice(&pubkey)?;
1717

18-
Ok(secp.verify_ecdsa(&msg, &sig, &pubkey).is_ok())
18+
Ok(secp.verify_ecdsa(msg, &sig, &pubkey).is_ok())
1919
}
2020

2121
fn sign<C: Signing>(
@@ -26,7 +26,7 @@ fn sign<C: Signing>(
2626
let msg = sha256::Hash::hash(msg);
2727
let msg = Message::from_digest_slice(msg.as_ref())?;
2828
let seckey = SecretKey::from_slice(&seckey)?;
29-
Ok(secp.sign_ecdsa(&msg, &seckey))
29+
Ok(secp.sign_ecdsa(msg, &seckey))
3030
}
3131

3232
fn main() {

‎examples/sign_verify_recovery.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ fn recover<C: Verification>(
1515
let id = ecdsa::RecoveryId::try_from(i32::from(recovery_id))?;
1616
let sig = ecdsa::RecoverableSignature::from_compact(&sig, id)?;
1717

18-
secp.recover_ecdsa(&msg, &sig)
18+
secp.recover_ecdsa(msg, &sig)
1919
}
2020

2121
fn sign_recovery<C: Signing>(
@@ -26,7 +26,7 @@ fn sign_recovery<C: Signing>(
2626
let msg = sha256::Hash::hash(msg);
2727
let msg = Message::from_digest_slice(msg.as_ref())?;
2828
let seckey = SecretKey::from_slice(&seckey)?;
29-
Ok(secp.sign_ecdsa_recoverable(&msg, &seckey))
29+
Ok(secp.sign_ecdsa_recoverable(msg, &seckey))
3030
}
3131

3232
fn main() {

‎no_std_test/src/main.rs

+7-7
Original file line numberDiff line numberDiff line change
@@ -94,12 +94,12 @@ fn start(_argc: isize, _argv: *const *const u8) -> isize {
9494
let public_key = PublicKey::from_secret_key(&secp, &secret_key);
9595
let message = Message::from_digest_slice(&[0xab; 32]).expect("32 bytes");
9696

97-
let sig = secp.sign_ecdsa(&message, &secret_key);
98-
assert!(secp.verify_ecdsa(&message, &sig, &public_key).is_ok());
97+
let sig = secp.sign_ecdsa(message, &secret_key);
98+
assert!(secp.verify_ecdsa(message, &sig, &public_key).is_ok());
9999

100-
let rec_sig = secp.sign_ecdsa_recoverable(&message, &secret_key);
101-
assert!(secp.verify_ecdsa(&message, &rec_sig.to_standard(), &public_key).is_ok());
102-
assert_eq!(public_key, secp.recover_ecdsa(&message, &rec_sig).unwrap());
100+
let rec_sig = secp.sign_ecdsa_recoverable(message, &secret_key);
101+
assert!(secp.verify_ecdsa(message, &rec_sig.to_standard(), &public_key).is_ok());
102+
assert_eq!(public_key, secp.recover_ecdsa(message, &rec_sig).unwrap());
103103
let (rec_id, data) = rec_sig.serialize_compact();
104104
let new_rec_sig = ecdsa::RecoverableSignature::from_compact(&data, rec_id).unwrap();
105105
assert_eq!(rec_sig, new_rec_sig);
@@ -121,8 +121,8 @@ fn start(_argc: isize, _argv: *const *const u8) -> isize {
121121
let public_key = PublicKey::from_secret_key(&secp_alloc, &secret_key);
122122
let message = Message::from_digest_slice(&[0xab; 32]).expect("32 bytes");
123123

124-
let sig = secp_alloc.sign_ecdsa(&message, &secret_key);
125-
assert!(secp_alloc.verify_ecdsa(&message, &sig, &public_key).is_ok());
124+
let sig = secp_alloc.sign_ecdsa(message, &secret_key);
125+
assert!(secp_alloc.verify_ecdsa(message, &sig, &public_key).is_ok());
126126
unsafe { libc::printf("Verified alloc Successfully!\n\0".as_ptr() as _) };
127127
}
128128

‎src/ecdsa/mod.rs

+14-13
Original file line numberDiff line numberDiff line change
@@ -194,7 +194,7 @@ impl Signature {
194194
/// The signature must be normalized or verification will fail (see [`Signature::normalize_s`]).
195195
#[inline]
196196
#[cfg(feature = "global-context")]
197-
pub fn verify(&self, msg: &Message, pk: &PublicKey) -> Result<(), Error> {
197+
pub fn verify(&self, msg: impl Into<Message>, pk: &PublicKey) -> Result<(), Error> {
198198
SECP256K1.verify_ecdsa(msg, self, pk)
199199
}
200200
}
@@ -243,7 +243,7 @@ impl<'de> serde::Deserialize<'de> for Signature {
243243
impl<C: Signing> Secp256k1<C> {
244244
fn sign_ecdsa_with_noncedata_pointer(
245245
&self,
246-
msg: &Message,
246+
msg: impl Into<Message>,
247247
sk: &SecretKey,
248248
noncedata: Option<&[u8; 32]>,
249249
) -> Signature {
@@ -259,7 +259,7 @@ impl<C: Signing> Secp256k1<C> {
259259
ffi::secp256k1_ecdsa_sign(
260260
self.ctx.as_ptr(),
261261
&mut ret,
262-
msg.as_c_ptr(),
262+
msg.into().as_c_ptr(),
263263
sk.as_c_ptr(),
264264
ffi::secp256k1_nonce_function_rfc6979,
265265
noncedata_ptr
@@ -272,7 +272,7 @@ impl<C: Signing> Secp256k1<C> {
272272

273273
/// Constructs a signature for `msg` using the secret key `sk` and RFC6979 nonce
274274
/// Requires a signing-capable context.
275-
pub fn sign_ecdsa(&self, msg: &Message, sk: &SecretKey) -> Signature {
275+
pub fn sign_ecdsa(&self, msg: impl Into<Message>, sk: &SecretKey) -> Signature {
276276
self.sign_ecdsa_with_noncedata_pointer(msg, sk, None)
277277
}
278278

@@ -283,7 +283,7 @@ impl<C: Signing> Secp256k1<C> {
283283
/// Requires a signing-capable context.
284284
pub fn sign_ecdsa_with_noncedata(
285285
&self,
286-
msg: &Message,
286+
msg: impl Into<Message>,
287287
sk: &SecretKey,
288288
noncedata: &[u8; 32],
289289
) -> Signature {
@@ -292,13 +292,14 @@ impl<C: Signing> Secp256k1<C> {
292292

293293
fn sign_grind_with_check(
294294
&self,
295-
msg: &Message,
295+
msg: impl Into<Message>,
296296
sk: &SecretKey,
297297
check: impl Fn(&ffi::Signature) -> bool,
298298
) -> Signature {
299299
let mut entropy_p: *const ffi::types::c_void = ptr::null();
300300
let mut counter: u32 = 0;
301301
let mut extra_entropy = [0u8; 32];
302+
let msg = msg.into();
302303
loop {
303304
unsafe {
304305
let mut ret = ffi::Signature::new();
@@ -338,7 +339,7 @@ impl<C: Signing> Secp256k1<C> {
338339
/// Requires a signing capable context.
339340
pub fn sign_ecdsa_grind_r(
340341
&self,
341-
msg: &Message,
342+
msg: impl Into<Message>,
342343
sk: &SecretKey,
343344
bytes_to_grind: usize,
344345
) -> Signature {
@@ -352,7 +353,7 @@ impl<C: Signing> Secp256k1<C> {
352353
/// signature implementation of bitcoin core. In average, this function
353354
/// will perform two signing operations.
354355
/// Requires a signing capable context.
355-
pub fn sign_ecdsa_low_r(&self, msg: &Message, sk: &SecretKey) -> Signature {
356+
pub fn sign_ecdsa_low_r(&self, msg: impl Into<Message>, sk: &SecretKey) -> Signature {
356357
self.sign_grind_with_check(msg, sk, compact_sig_has_zero_first_bit)
357358
}
358359
}
@@ -372,25 +373,25 @@ impl<C: Verification> Secp256k1<C> {
372373
/// # let (secret_key, public_key) = secp.generate_keypair(&mut rand::thread_rng());
373374
/// #
374375
/// let message = Message::from_digest_slice(&[0xab; 32]).expect("32 bytes");
375-
/// let sig = secp.sign_ecdsa(&message, &secret_key);
376-
/// assert_eq!(secp.verify_ecdsa(&message, &sig, &public_key), Ok(()));
376+
/// let sig = secp.sign_ecdsa(message, &secret_key);
377+
/// assert_eq!(secp.verify_ecdsa(message, &sig, &public_key), Ok(()));
377378
///
378379
/// let message = Message::from_digest_slice(&[0xcd; 32]).expect("32 bytes");
379-
/// assert_eq!(secp.verify_ecdsa(&message, &sig, &public_key), Err(Error::IncorrectSignature));
380+
/// assert_eq!(secp.verify_ecdsa(message, &sig, &public_key), Err(Error::IncorrectSignature));
380381
/// # }
381382
/// ```
382383
#[inline]
383384
pub fn verify_ecdsa(
384385
&self,
385-
msg: &Message,
386+
msg: impl Into<Message>,
386387
sig: &Signature,
387388
pk: &PublicKey,
388389
) -> Result<(), Error> {
389390
unsafe {
390391
if ffi::secp256k1_ecdsa_verify(
391392
self.ctx.as_ptr(),
392393
sig.as_c_ptr(),
393-
msg.as_c_ptr(),
394+
msg.into().as_c_ptr(),
394395
pk.as_c_ptr(),
395396
) == 0
396397
{

‎src/ecdsa/recovery.rs

+24-24
Original file line numberDiff line numberDiff line change
@@ -133,7 +133,7 @@ impl RecoverableSignature {
133133
/// verify-capable context.
134134
#[inline]
135135
#[cfg(feature = "global-context")]
136-
pub fn recover(&self, msg: &Message) -> Result<key::PublicKey, Error> {
136+
pub fn recover(&self, msg: impl Into<Message>) -> Result<key::PublicKey, Error> {
137137
crate::SECP256K1.recover_ecdsa(msg, self)
138138
}
139139
}
@@ -154,7 +154,7 @@ impl From<ffi::RecoverableSignature> for RecoverableSignature {
154154
impl<C: Signing> Secp256k1<C> {
155155
fn sign_ecdsa_recoverable_with_noncedata_pointer(
156156
&self,
157-
msg: &Message,
157+
msg: impl Into<Message>,
158158
sk: &key::SecretKey,
159159
noncedata_ptr: *const super_ffi::types::c_void,
160160
) -> RecoverableSignature {
@@ -166,7 +166,7 @@ impl<C: Signing> Secp256k1<C> {
166166
ffi::secp256k1_ecdsa_sign_recoverable(
167167
self.ctx.as_ptr(),
168168
&mut ret,
169-
msg.as_c_ptr(),
169+
msg.into().as_c_ptr(),
170170
sk.as_c_ptr(),
171171
super_ffi::secp256k1_nonce_function_rfc6979,
172172
noncedata_ptr
@@ -182,7 +182,7 @@ impl<C: Signing> Secp256k1<C> {
182182
/// Requires a signing-capable context.
183183
pub fn sign_ecdsa_recoverable(
184184
&self,
185-
msg: &Message,
185+
msg: impl Into<Message>,
186186
sk: &key::SecretKey,
187187
) -> RecoverableSignature {
188188
self.sign_ecdsa_recoverable_with_noncedata_pointer(msg, sk, ptr::null())
@@ -195,7 +195,7 @@ impl<C: Signing> Secp256k1<C> {
195195
/// Requires a signing-capable context.
196196
pub fn sign_ecdsa_recoverable_with_noncedata(
197197
&self,
198-
msg: &Message,
198+
msg: impl Into<Message>,
199199
sk: &key::SecretKey,
200200
noncedata: &[u8; 32],
201201
) -> RecoverableSignature {
@@ -209,7 +209,7 @@ impl<C: Verification> Secp256k1<C> {
209209
/// `msg`. Requires a verify-capable context.
210210
pub fn recover_ecdsa(
211211
&self,
212-
msg: &Message,
212+
msg: impl Into<Message>,
213213
sig: &RecoverableSignature,
214214
) -> Result<key::PublicKey, Error> {
215215
unsafe {
@@ -218,7 +218,7 @@ impl<C: Verification> Secp256k1<C> {
218218
self.ctx.as_ptr(),
219219
&mut pk,
220220
sig.as_c_ptr(),
221-
msg.as_c_ptr(),
221+
msg.into().as_c_ptr(),
222222
) != 1
223223
{
224224
return Err(Error::InvalidSignature);
@@ -252,15 +252,15 @@ mod tests {
252252
let (sk, pk) = full.generate_keypair(&mut rand::thread_rng());
253253

254254
// Try signing
255-
assert_eq!(sign.sign_ecdsa_recoverable(&msg, &sk), full.sign_ecdsa_recoverable(&msg, &sk));
256-
let sigr = full.sign_ecdsa_recoverable(&msg, &sk);
255+
assert_eq!(sign.sign_ecdsa_recoverable(msg, &sk), full.sign_ecdsa_recoverable(msg, &sk));
256+
let sigr = full.sign_ecdsa_recoverable(msg, &sk);
257257

258258
// Try pk recovery
259-
assert!(vrfy.recover_ecdsa(&msg, &sigr).is_ok());
260-
assert!(full.recover_ecdsa(&msg, &sigr).is_ok());
259+
assert!(vrfy.recover_ecdsa(msg, &sigr).is_ok());
260+
assert!(full.recover_ecdsa(msg, &sigr).is_ok());
261261

262-
assert_eq!(vrfy.recover_ecdsa(&msg, &sigr), full.recover_ecdsa(&msg, &sigr));
263-
assert_eq!(full.recover_ecdsa(&msg, &sigr), Ok(pk));
262+
assert_eq!(vrfy.recover_ecdsa(msg, &sigr), full.recover_ecdsa(msg, &sigr));
263+
assert_eq!(full.recover_ecdsa(msg, &sigr), Ok(pk));
264264
}
265265

266266
#[test]
@@ -280,7 +280,7 @@ mod tests {
280280
let sk = SecretKey::from_slice(&ONE).unwrap();
281281
let msg = Message::from_digest_slice(&ONE).unwrap();
282282

283-
let sig = s.sign_ecdsa_recoverable(&msg, &sk);
283+
let sig = s.sign_ecdsa_recoverable(msg, &sk);
284284

285285
assert_eq!(Ok(sig), RecoverableSignature::from_compact(&[
286286
0x66, 0x73, 0xff, 0xad, 0x21, 0x47, 0x74, 0x1f,
@@ -306,7 +306,7 @@ mod tests {
306306
let msg = Message::from_digest_slice(&ONE).unwrap();
307307
let noncedata = [42u8; 32];
308308

309-
let sig = s.sign_ecdsa_recoverable_with_noncedata(&msg, &sk, &noncedata);
309+
let sig = s.sign_ecdsa_recoverable_with_noncedata(msg, &sk, &noncedata);
310310

311311
assert_eq!(Ok(sig), RecoverableSignature::from_compact(&[
312312
0xb5, 0x0b, 0xb6, 0x79, 0x5f, 0x31, 0x74, 0x8a,
@@ -331,14 +331,14 @@ mod tests {
331331

332332
let (sk, pk) = s.generate_keypair(&mut rand::thread_rng());
333333

334-
let sigr = s.sign_ecdsa_recoverable(&msg, &sk);
334+
let sigr = s.sign_ecdsa_recoverable(msg, &sk);
335335
let sig = sigr.to_standard();
336336

337337
let msg = crate::random_32_bytes(&mut rand::thread_rng());
338338
let msg = Message::from_digest_slice(&msg).unwrap();
339-
assert_eq!(s.verify_ecdsa(&msg, &sig, &pk), Err(Error::IncorrectSignature));
339+
assert_eq!(s.verify_ecdsa(msg, &sig, &pk), Err(Error::IncorrectSignature));
340340

341-
let recovered_key = s.recover_ecdsa(&msg, &sigr).unwrap();
341+
let recovered_key = s.recover_ecdsa(msg, &sigr).unwrap();
342342
assert!(recovered_key != pk);
343343
}
344344

@@ -353,9 +353,9 @@ mod tests {
353353

354354
let (sk, pk) = s.generate_keypair(&mut rand::thread_rng());
355355

356-
let sig = s.sign_ecdsa_recoverable(&msg, &sk);
356+
let sig = s.sign_ecdsa_recoverable(msg, &sk);
357357

358-
assert_eq!(s.recover_ecdsa(&msg, &sig), Ok(pk));
358+
assert_eq!(s.recover_ecdsa(msg, &sig), Ok(pk));
359359
}
360360

361361
#[test]
@@ -371,9 +371,9 @@ mod tests {
371371

372372
let (sk, pk) = s.generate_keypair(&mut rand::thread_rng());
373373

374-
let sig = s.sign_ecdsa_recoverable_with_noncedata(&msg, &sk, &noncedata);
374+
let sig = s.sign_ecdsa_recoverable_with_noncedata(msg, &sk, &noncedata);
375375

376-
assert_eq!(s.recover_ecdsa(&msg, &sig), Ok(pk));
376+
assert_eq!(s.recover_ecdsa(msg, &sig), Ok(pk));
377377
}
378378

379379
#[test]
@@ -386,10 +386,10 @@ mod tests {
386386

387387
// Zero is not a valid sig
388388
let sig = RecoverableSignature::from_compact(&[0; 64], RecoveryId::Zero).unwrap();
389-
assert_eq!(s.recover_ecdsa(&msg, &sig), Err(Error::InvalidSignature));
389+
assert_eq!(s.recover_ecdsa(msg, &sig), Err(Error::InvalidSignature));
390390
// ...but 111..111 is
391391
let sig = RecoverableSignature::from_compact(&[1; 64], RecoveryId::Zero).unwrap();
392-
assert!(s.recover_ecdsa(&msg, &sig).is_ok());
392+
assert!(s.recover_ecdsa(msg, &sig).is_ok());
393393
}
394394

395395
#[test]

‎src/key.rs

+4-2
Original file line numberDiff line numberDiff line change
@@ -338,7 +338,9 @@ impl SecretKey {
338338
/// Constructs an ECDSA signature for `msg` using the global [`SECP256K1`] context.
339339
#[inline]
340340
#[cfg(feature = "global-context")]
341-
pub fn sign_ecdsa(&self, msg: Message) -> ecdsa::Signature { SECP256K1.sign_ecdsa(&msg, self) }
341+
pub fn sign_ecdsa(&self, msg: impl Into<Message>) -> ecdsa::Signature {
342+
SECP256K1.sign_ecdsa(msg, self)
343+
}
342344

343345
/// Returns the [`Keypair`] for this [`SecretKey`].
344346
///
@@ -737,7 +739,7 @@ impl PublicKey {
737739
pub fn verify<C: Verification>(
738740
&self,
739741
secp: &Secp256k1<C>,
740-
msg: &Message,
742+
msg: impl Into<Message>,
741743
sig: &ecdsa::Signature,
742744
) -> Result<(), Error> {
743745
secp.verify_ecdsa(msg, sig, self)

0 commit comments

Comments
 (0)