Skip to content

Commit 41bb442

Browse files
apoelstraapoelstra
committed
key: add {from,to,as}_secret_bytes methods
Deprecate the from_byte_array method, which unfortunately we just added in 0.31.x. We may want to backport yet another deprecation.
1 parent 9b84072 commit 41bb442

File tree

11 files changed

+58
-91
lines changed

11 files changed

+58
-91
lines changed

‎examples/sign_verify.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -36,7 +36,7 @@ fn sign<C: Signing>(
3636
seckey: [u8; 32],
3737
) -> Result<ecdsa::Signature, Error> {
3838
let msg = Message::from_digest(msg_digest);
39-
let seckey = SecretKey::from_byte_array(seckey)?;
39+
let seckey = SecretKey::from_secret_bytes(seckey)?;
4040
Ok(secp.sign_ecdsa(msg, &seckey))
4141
}
4242

‎examples/sign_verify_recovery.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ fn sign_recovery(
1515
seckey: [u8; 32],
1616
) -> Result<ecdsa::RecoverableSignature, Error> {
1717
let msg = Message::from_digest(msg_digest);
18-
let seckey = SecretKey::from_byte_array(seckey)?;
18+
let seckey = SecretKey::from_secret_bytes(seckey)?;
1919
Ok(ecdsa::RecoverableSignature::sign_ecdsa_recoverable(msg, &seckey))
2020
}
2121

‎src/ecdsa/recovery.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -170,7 +170,7 @@ impl RecoverableSignature {
170170
let mut ret = ffi::RecoverableSignature::new();
171171
// xor the secret key and message together to get a rerandomization seed
172172
// for timing analysis defense-in-depth
173-
let mut rerandomize = sk.secret_bytes();
173+
let mut rerandomize = sk.to_secret_bytes();
174174
for (rera, byte) in rerandomize.iter_mut().zip(msg[..].iter()) {
175175
*rera ^= *byte;
176176
}
@@ -272,7 +272,7 @@ mod tests {
272272
#[cfg(not(secp256k1_fuzz))] // fixed sig vectors can't work with fuzz-sigs
273273
#[rustfmt::skip]
274274
fn sign() {
275-
let sk = SecretKey::from_byte_array(ONE).unwrap();
275+
let sk = SecretKey::from_secret_bytes(ONE).unwrap();
276276
let msg = Message::from_digest(ONE);
277277
let sig = RecoverableSignature::sign_ecdsa_recoverable(msg, &sk);
278278

@@ -292,7 +292,7 @@ mod tests {
292292
#[cfg(not(secp256k1_fuzz))] // fixed sig vectors can't work with fuzz-sigs
293293
#[rustfmt::skip]
294294
fn sign_with_noncedata() {
295-
let sk = SecretKey::from_byte_array(ONE).unwrap();
295+
let sk = SecretKey::from_secret_bytes(ONE).unwrap();
296296
let noncedata = [42u8; 32];
297297
let msg = Message::from_digest(ONE);
298298

‎src/ellswift.rs‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -111,7 +111,7 @@ impl ElligatorSwift {
111111
/// # #[cfg(feature = "alloc")] {
112112
/// use secp256k1::{ellswift::ElligatorSwift, PublicKey, Secp256k1, SecretKey};
113113
/// let secp = Secp256k1::new();
114-
/// let sk = SecretKey::from_slice(&[1; 32]).unwrap();
114+
/// let sk = SecretKey::from_secret_bytes([1; 32]).unwrap();
115115
/// let es = ElligatorSwift::from_seckey(&secp, sk, None);
116116
/// # }
117117
/// ```
@@ -140,7 +140,7 @@ impl ElligatorSwift {
140140
/// # #[cfg(feature = "alloc")] {
141141
/// use secp256k1::{ellswift::ElligatorSwift, PublicKey, Secp256k1, SecretKey};
142142
/// let secp = Secp256k1::new();
143-
/// let sk = SecretKey::from_slice(&[1; 32]).unwrap();
143+
/// let sk = SecretKey::from_secret_bytes([1; 32]).unwrap();
144144
/// let pk = PublicKey::from_secret_key(&secp, &sk);
145145
/// let es = ElligatorSwift::from_pubkey(pk);
146146
/// # }
@@ -377,7 +377,7 @@ mod tests {
377377
// Test that we can round trip an ElligatorSwift encoding
378378
let secp = crate::Secp256k1::new();
379379
let public_key =
380-
PublicKey::from_secret_key(&secp, &SecretKey::from_byte_array([1u8; 32]).unwrap());
380+
PublicKey::from_secret_key(&secp, &SecretKey::from_secret_bytes([1u8; 32]).unwrap());
381381

382382
let ell = ElligatorSwift::from_pubkey(public_key);
383383
let pk = PublicKey::from_ellswift(ell);
@@ -391,10 +391,10 @@ mod tests {
391391
let rand32 = [1u8; 32];
392392
let priv32 = [1u8; 32];
393393
let ell =
394-
ElligatorSwift::from_seckey(&secp, SecretKey::from_byte_array(rand32).unwrap(), None);
394+
ElligatorSwift::from_seckey(&secp, SecretKey::from_secret_bytes(rand32).unwrap(), None);
395395
let pk = PublicKey::from_ellswift(ell);
396396
let expected =
397-
PublicKey::from_secret_key(&secp, &SecretKey::from_byte_array(priv32).unwrap());
397+
PublicKey::from_secret_key(&secp, &SecretKey::from_secret_bytes(priv32).unwrap());
398398

399399
assert_eq!(pk, expected);
400400
}
@@ -407,13 +407,13 @@ mod tests {
407407
let priv32 = [2u8; 32];
408408
let ell = ElligatorSwift::from_seckey(
409409
&secp,
410-
SecretKey::from_byte_array(rand32).unwrap(),
410+
SecretKey::from_secret_bytes(rand32).unwrap(),
411411
Some(rand32),
412412
);
413413
let pk = ElligatorSwift::shared_secret_with_hasher(
414414
ell,
415415
ell,
416-
SecretKey::from_byte_array(priv32).unwrap(),
416+
SecretKey::from_secret_bytes(priv32).unwrap(),
417417
Party::Initiator,
418418
|_, _, _| ElligatorSwiftSharedSecret([0xff; 32]),
419419
);
@@ -627,7 +627,7 @@ mod tests {
627627
ElligatorSwift::from_array(ellswift_theirs),
628628
)
629629
};
630-
let sec_key = SecretKey::from_byte_array(my_secret).unwrap();
630+
let sec_key = SecretKey::from_secret_bytes(my_secret).unwrap();
631631
let initiator = if initiator == 0 { Party::Responder } else { Party::Initiator };
632632

633633
let shared = ElligatorSwift::shared_secret(el_a, el_b, sec_key, initiator);

‎src/key/mod.rs‎

Lines changed: 12 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -721,7 +721,7 @@ impl Keypair {
721721
let sk = SecretKey::test_random();
722722
crate::with_global_context(
723723
|secp: &Secp256k1<crate::AllPreallocated>| Self::from_secret_key(secp, &sk),
724-
Some(&sk.secret_bytes()),
724+
Some(&sk.to_secret_bytes()),
725725
)
726726
}
727727
}
@@ -1347,7 +1347,7 @@ impl<'a> Arbitrary<'a> for SecretKey {
13471347
}
13481348
u.fill_buffer(&mut bytes[..])?;
13491349

1350-
if let Ok(sk) = SecretKey::from_byte_array(bytes) {
1350+
if let Ok(sk) = SecretKey::from_secret_bytes(bytes) {
13511351
return Ok(sk);
13521352
}
13531353
}
@@ -1391,16 +1391,6 @@ mod test {
13911391
use crate::Error::{InvalidPublicKey, InvalidSecretKey};
13921392
use crate::{constants, from_hex, to_hex, Scalar};
13931393

1394-
#[test]
1395-
#[allow(deprecated)]
1396-
fn skey_from_slice() {
1397-
let sk = SecretKey::from_slice(&[1; 31]);
1398-
assert_eq!(sk, Err(InvalidSecretKey));
1399-
1400-
let sk = SecretKey::from_slice(&[1; 32]);
1401-
assert!(sk.is_ok());
1402-
}
1403-
14041394
#[test]
14051395
fn pubkey_from_slice() {
14061396
assert_eq!(PublicKey::from_slice(&[]), Err(InvalidPublicKey));
@@ -1424,7 +1414,7 @@ mod test {
14241414
#[test]
14251415
fn keypair_slice_round_trip() {
14261416
let (sk1, pk1) = crate::test_random_keypair();
1427-
assert_eq!(SecretKey::from_byte_array(sk1.secret_bytes()), Ok(sk1));
1417+
assert_eq!(SecretKey::from_secret_bytes(sk1.to_secret_bytes()), Ok(sk1));
14281418
assert_eq!(PublicKey::from_slice(&pk1.serialize()[..]), Ok(pk1));
14291419
assert_eq!(PublicKey::from_slice(&pk1.serialize_uncompressed()[..]), Ok(pk1));
14301420
}
@@ -1443,22 +1433,22 @@ mod test {
14431433
#[rustfmt::skip]
14441434
fn invalid_secret_key() {
14451435
// Zero
1446-
assert_eq!(SecretKey::from_byte_array([0; 32]), Err(InvalidSecretKey));
1436+
assert_eq!(SecretKey::from_secret_bytes([0; 32]), Err(InvalidSecretKey));
14471437
assert_eq!(
14481438
SecretKey::from_str("0000000000000000000000000000000000000000000000000000000000000000"),
14491439
Err(InvalidSecretKey)
14501440
);
14511441
// -1
1452-
assert_eq!(SecretKey::from_byte_array([0xff; 32]), Err(InvalidSecretKey));
1442+
assert_eq!(SecretKey::from_secret_bytes([0xff; 32]), Err(InvalidSecretKey));
14531443
// Top of range
1454-
assert!(SecretKey::from_byte_array([
1444+
assert!(SecretKey::from_secret_bytes([
14551445
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
14561446
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
14571447
0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48, 0xA0, 0x3B,
14581448
0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41, 0x40,
14591449
]).is_ok());
14601450
// One past top of range
1461-
assert!(SecretKey::from_byte_array([
1451+
assert!(SecretKey::from_secret_bytes([
14621452
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
14631453
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
14641454
0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48, 0xA0, 0x3B,
@@ -1526,30 +1516,6 @@ mod test {
15261516
assert_eq!(PublicKey::from_slice(&[]), Err(InvalidPublicKey));
15271517
}
15281518

1529-
#[test]
1530-
#[allow(deprecated)]
1531-
fn test_seckey_from_bad_slice() {
1532-
// Bad sizes
1533-
assert_eq!(
1534-
SecretKey::from_slice(&[0; constants::SECRET_KEY_SIZE - 1]),
1535-
Err(InvalidSecretKey)
1536-
);
1537-
assert_eq!(
1538-
SecretKey::from_slice(&[0; constants::SECRET_KEY_SIZE + 1]),
1539-
Err(InvalidSecretKey)
1540-
);
1541-
// Bad parse
1542-
assert_eq!(
1543-
SecretKey::from_slice(&[0xff; constants::SECRET_KEY_SIZE]),
1544-
Err(InvalidSecretKey)
1545-
);
1546-
assert_eq!(
1547-
SecretKey::from_slice(&[0x00; constants::SECRET_KEY_SIZE]),
1548-
Err(InvalidSecretKey)
1549-
);
1550-
assert_eq!(SecretKey::from_slice(&[]), Err(InvalidSecretKey));
1551-
}
1552-
15531519
#[test]
15541520
#[cfg(all(feature = "rand", feature = "alloc"))]
15551521
fn test_debug_output() {
@@ -1578,7 +1544,7 @@ mod test {
15781544

15791545
#[cfg(not(secp256k1_fuzz))]
15801546
let s = Secp256k1::signing_only();
1581-
let sk = SecretKey::from_byte_array(SK_BYTES).expect("sk");
1547+
let sk = SecretKey::from_secret_bytes(SK_BYTES).expect("sk");
15821548

15831549
// In fuzzing mode secret->public key derivation is different, so
15841550
// hard-code the expected result.
@@ -1925,7 +1891,7 @@ mod test {
19251891

19261892
#[cfg(not(secp256k1_fuzz))]
19271893
let s = Secp256k1::new();
1928-
let sk = SecretKey::from_byte_array(SK_BYTES).unwrap();
1894+
let sk = SecretKey::from_secret_bytes(SK_BYTES).unwrap();
19291895

19301896
// In fuzzing mode secret->public key derivation is different, so
19311897
// hard-code the expected result.
@@ -2064,7 +2030,7 @@ mod test {
20642030
pk_bytes[0] = 0x02; // Use positive Y co-ordinate.
20652031
pk_bytes[1..].clone_from_slice(&PK_BYTES);
20662032

2067-
let sk = SecretKey::from_byte_array(SK_BYTES).expect("failed to parse sk bytes");
2033+
let sk = SecretKey::from_secret_bytes(SK_BYTES).expect("failed to parse sk bytes");
20682034
let pk = PublicKey::from_slice(&pk_bytes).expect("failed to create pk from iterator");
20692035
let kp = Keypair::from_secret_key(&secp, &sk);
20702036
let xonly =
@@ -2227,7 +2193,7 @@ mod test {
22272193
fn test_keypair_from_str() {
22282194
let keypair = Keypair::test_random();
22292195
let mut buf = [0_u8; constants::SECRET_KEY_SIZE * 2]; // Holds hex digits.
2230-
let s = to_hex(&keypair.secret_key().secret_bytes(), &mut buf).unwrap();
2196+
let s = to_hex(&keypair.secret_key().to_secret_bytes(), &mut buf).unwrap();
22312197
let parsed_key = Keypair::from_str(s).unwrap();
22322198
assert_eq!(parsed_key, keypair);
22332199
}
@@ -2240,7 +2206,7 @@ mod test {
22402206

22412207
serde_test::assert_tokens(&keypair.readable(), &[Token::String(sec_key_str)]);
22422208

2243-
let sec_key_bytes = keypair.secret_key().secret_bytes();
2209+
let sec_key_bytes = keypair.secret_key().to_secret_bytes();
22442210
let tokens = std::iter::once(Token::Tuple { len: 32 })
22452211
.chain(sec_key_bytes.iter().copied().map(Token::U8))
22462212
.chain(std::iter::once(Token::TupleEnd))

‎src/key/secret.rs‎

Lines changed: 18 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -107,7 +107,7 @@ impl str::FromStr for SecretKey {
107107
fn from_str(s: &str) -> Result<SecretKey, Error> {
108108
let mut res = [0u8; constants::SECRET_KEY_SIZE];
109109
match from_hex(s, &mut res) {
110-
Ok(constants::SECRET_KEY_SIZE) => SecretKey::from_byte_array(res),
110+
Ok(constants::SECRET_KEY_SIZE) => SecretKey::from_secret_bytes(res),
111111
_ => Err(Error::InvalidSecretKey),
112112
}
113113
}
@@ -140,21 +140,10 @@ impl SecretKey {
140140
SecretKey(data)
141141
}
142142

143-
/// Converts a 32-byte slice to a secret key.
144-
///
145-
/// # Examples
146-
///
147-
/// ```
148-
/// use secp256k1::SecretKey;
149-
/// let sk = SecretKey::from_slice(&[0xcd; 32]).expect("32 bytes, within curve order");
150-
/// ```
151-
#[deprecated(since = "0.31.0", note = "Use `from_byte_array` instead.")]
152-
#[inline]
153-
pub fn from_slice(data: &[u8]) -> Result<SecretKey, Error> {
154-
match <[u8; constants::SECRET_KEY_SIZE]>::try_from(data) {
155-
Ok(data) => Self::from_byte_array(data),
156-
Err(_) => Err(Error::InvalidSecretKey),
157-
}
143+
/// Converts a 32-byte array to a secret key.
144+
#[deprecated(since = "0.32.0", note = "use from_secret_bytes instead")]
145+
pub fn from_byte_array(data: [u8; constants::SECRET_KEY_SIZE]) -> Result<SecretKey, Error> {
146+
Self::from_secret_bytes(data)
158147
}
159148

160149
/// Converts a 32-byte array to a secret key.
@@ -163,10 +152,10 @@ impl SecretKey {
163152
///
164153
/// ```
165154
/// use secp256k1::SecretKey;
166-
/// let sk = SecretKey::from_byte_array([0xcd; 32]).expect("32 bytes, within curve order");
155+
/// let sk = SecretKey::from_secret_bytes([0xcd; 32]).expect("32 bytes, within curve order");
167156
/// ```
168157
#[inline]
169-
pub fn from_byte_array(data: [u8; constants::SECRET_KEY_SIZE]) -> Result<SecretKey, Error> {
158+
pub fn from_secret_bytes(data: [u8; constants::SECRET_KEY_SIZE]) -> Result<SecretKey, Error> {
170159
unsafe {
171160
if ffi::secp256k1_ec_seckey_verify(ffi::secp256k1_context_no_precomp, data.as_c_ptr())
172161
== 0
@@ -204,8 +193,17 @@ impl SecretKey {
204193
SecretKey(sk)
205194
}
206195

196+
/// Returns a reference to the secret key as a byte value.
197+
#[inline]
198+
pub fn as_secret_bytes(&self) -> &[u8; constants::SECRET_KEY_SIZE] { &self.0 }
199+
200+
/// Returns the secret key as a byte value.
201+
#[inline]
202+
pub fn to_secret_bytes(&self) -> [u8; constants::SECRET_KEY_SIZE] { self.0 }
203+
207204
/// Returns the secret key as a byte value.
208205
#[inline]
206+
#[deprecated(since = "0.32.0", note = "use to_secret_bytes instead")]
209207
pub fn secret_bytes(&self) -> [u8; constants::SECRET_KEY_SIZE] { self.0 }
210208

211209
/// Negates the secret key.
@@ -306,7 +304,7 @@ impl SecretKey {
306304
#[cfg(not(all(feature = "rand", feature = "std")))]
307305
pub fn test_random() -> Self {
308306
loop {
309-
if let Ok(ret) = Self::from_byte_array(crate::test_random_32_bytes()) {
307+
if let Ok(ret) = Self::from_secret_bytes(crate::test_random_32_bytes()) {
310308
return ret;
311309
}
312310
}
@@ -339,7 +337,7 @@ impl<'de> serde::Deserialize<'de> for SecretKey {
339337
} else {
340338
let visitor =
341339
crate::serde_util::Tuple32Visitor::new("raw 32 bytes SecretKey", |bytes| {
342-
SecretKey::from_byte_array(bytes)
340+
SecretKey::from_secret_bytes(bytes)
343341
});
344342
d.deserialize_tuple(constants::SECRET_KEY_SIZE, visitor)
345343
}

‎src/lib.rs‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -80,7 +80,7 @@
8080
//! # fn compute_hash(_: &[u8]) -> [u8; 32] { [0xab; 32] }
8181
//!
8282
//! let secp = Secp256k1::new();
83-
//! let secret_key = SecretKey::from_slice(&[0xcd; 32]).expect("32 bytes, within curve order");
83+
//! let secret_key = SecretKey::from_secret_bytes([0xcd; 32]).expect("32 bytes, within curve order");
8484
//! let public_key = PublicKey::from_secret_key(&secp, &secret_key);
8585
//! // If the supplied byte slice was *not* the output of a cryptographic hash function this would
8686
//! // be cryptographically broken. It has been trivially used in the past to execute attacks.
@@ -689,7 +689,7 @@ mod tests {
689689
// Check that we can produce keys from slices with no precomputation
690690
let pk_slice = &pk.serialize();
691691
let new_pk = PublicKey::from_slice(pk_slice).unwrap();
692-
let new_sk = SecretKey::from_byte_array(sk.secret_bytes()).unwrap();
692+
let new_sk = SecretKey::from_secret_bytes(sk.to_secret_bytes()).unwrap();
693693
assert_eq!(sk, new_sk);
694694
assert_eq!(pk, new_pk);
695695
}
@@ -839,7 +839,7 @@ mod tests {
839839
wild_keys[1][0] -= 1;
840840
wild_msgs[1][0] -= 1;
841841

842-
for key in wild_keys.iter().copied().map(SecretKey::from_byte_array).map(Result::unwrap) {
842+
for key in wild_keys.iter().copied().map(SecretKey::from_secret_bytes).map(Result::unwrap) {
843843
for msg in wild_msgs.into_iter().map(Message::from_digest) {
844844
let sig = s.sign_ecdsa(msg, &key);
845845
let low_r_sig = s.sign_ecdsa_low_r(msg, &key);
@@ -1011,7 +1011,7 @@ mod tests {
10111011
let s = Secp256k1::new();
10121012

10131013
let msg = Message::from_digest([1; 32]);
1014-
let sk = SecretKey::from_byte_array([2; 32]).unwrap();
1014+
let sk = SecretKey::from_secret_bytes([2; 32]).unwrap();
10151015
let sig = s.sign_ecdsa(msg, &sk);
10161016
static SIG_BYTES: [u8; 71] = [
10171017
48, 69, 2, 33, 0, 157, 11, 173, 87, 103, 25, 211, 42, 231, 107, 237, 179, 76, 119, 72,
@@ -1038,7 +1038,7 @@ mod tests {
10381038
fn test_global_context() {
10391039
use crate::SECP256K1;
10401040
let sk_data = hex!("e6dd32f8761625f105c39a39f19370b3521d845a12456d60ce44debd0a362641");
1041-
let sk = SecretKey::from_byte_array(sk_data).unwrap();
1041+
let sk = SecretKey::from_secret_bytes(sk_data).unwrap();
10421042
let msg_data = hex!("a4965ca63b7d8562736ceec36dfa5a11bf426eb65be8ea3f7a49ae363032da0d");
10431043
let msg = Message::from_digest(msg_data);
10441044

‎src/scalar.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -135,7 +135,7 @@ where
135135
}
136136

137137
impl From<crate::SecretKey> for Scalar {
138-
fn from(value: crate::SecretKey) -> Self { Scalar(value.secret_bytes()) }
138+
fn from(value: crate::SecretKey) -> Self { Scalar(value.to_secret_bytes()) }
139139
}
140140

141141
/// Error returned when the value of scalar is invalid - larger than the curve order.

0 commit comments

Comments
 (0)