Skip to content

Commit e74e054

Browse files
LLFournLLFourn
committed
[libsecp_compat_0_28] Update compatibility to rust-libsecp256k1 v0.28
1 parent 4f2b86f commit e74e054

File tree

11 files changed

+190
-29
lines changed

11 files changed

+190
-29
lines changed

‎CHANGELOG.md

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@
44
## Unreleased
55

66
- Change `Scalar::from_bytes` to work for `Scalar<_, NonZero>` as well.
7+
- Updated compatibility to `rust-secp256k1` v0.28.0
78
- Bumped MSRV to 1.63.0 to reduce friction
89
- Added `share_backup` module in `schnorr_fun`
910
- Added `arithmetic_macros` to make `g!` and `s!` macros into procedural macros

‎ecdsa_fun/Cargo.toml

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -34,8 +34,9 @@ required-features = ["libsecp_compat"]
3434

3535
[features]
3636
default = ["std"]
37-
libsecp_compat = ["secp256kfun/libsecp_compat", "libsecp_compat_0_27"]
37+
libsecp_compat = ["secp256kfun/libsecp_compat", "libsecp_compat_0_28"]
3838
libsecp_compat_0_27 = ["secp256kfun/libsecp_compat_0_27"]
39+
libsecp_compat_0_28 = ["secp256kfun/libsecp_compat_0_28"]
3940
std = ["alloc"]
4041
alloc = ["secp256kfun/alloc", "sigma_fun?/alloc" ]
4142
serde = ["secp256kfun/serde","sigma_fun?/serde"]

‎ecdsa_fun/src/libsecp_compat.rs

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -14,3 +14,20 @@ mod v0_27 {
1414
}
1515
}
1616
}
17+
18+
#[cfg(feature = "libsecp_compat_0_28")]
19+
mod v0_28 {
20+
use crate::{fun::secp256k1_0_28::ecdsa, Signature};
21+
22+
impl From<Signature> for ecdsa::Signature {
23+
fn from(sig: Signature) -> Self {
24+
ecdsa::Signature::from_compact(sig.to_bytes().as_ref()).unwrap()
25+
}
26+
}
27+
28+
impl From<ecdsa::Signature> for Signature {
29+
fn from(sig: ecdsa::Signature) -> Self {
30+
Signature::from_bytes(sig.serialize_compact()).unwrap()
31+
}
32+
}
33+
}

‎ecdsa_fun/tests/against_c_lib.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,7 @@ fn ecdsa_sign() {
2828
let c_public_key = PublicKey::from(public_key);
2929
let message = rand_32_bytes();
3030
let signature = ecdsa.sign(&secret_key, &message);
31-
let c_message = Message::from_slice(&message[..]).unwrap();
31+
let c_message = Message::from_digest_slice(&message[..]).unwrap();
3232
let c_siganture = ecdsa::Signature::from_compact(&signature.to_bytes()).unwrap();
3333
assert!(secp
3434
.verify_ecdsa(&c_message, &c_siganture, &c_public_key)
@@ -48,7 +48,7 @@ fn ecdsa_verify() {
4848
let c_public_key = PublicKey::from_secret_key(&secp, &c_secret_key);
4949
let public_key = Point::from(c_public_key);
5050
let message = rand_32_bytes();
51-
let c_message = Message::from_slice(&message[..]).unwrap();
51+
let c_message = Message::from_digest_slice(&message[..]).unwrap();
5252
let c_signature = secp.sign_ecdsa(&c_message, &c_secret_key);
5353
let signature = ecdsa_fun::Signature::from(c_signature);
5454
assert!(ecdsa.verify(&public_key, &message, &signature));
@@ -66,7 +66,7 @@ fn ecdsa_verify_high_message() {
6666
let message =
6767
hex::decode_array("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")
6868
.unwrap();
69-
let c_message = Message::from_slice(&message[..]).unwrap();
69+
let c_message = Message::from_digest_slice(&message[..]).unwrap();
7070
let c_signature = secp.sign_ecdsa(&c_message, &c_secret_key);
7171
let signature = ecdsa_fun::Signature::from_bytes(c_signature.serialize_compact()).unwrap();
7272

@@ -86,7 +86,7 @@ fn ecdsa_sign_high_message() {
8686
hex::decode_array("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")
8787
.unwrap();
8888
let signature = ecdsa.sign(&secret_key, &message);
89-
let c_message = Message::from_slice(&message[..]).unwrap();
89+
let c_message = Message::from_digest_slice(&message[..]).unwrap();
9090
let c_siganture = ecdsa::Signature::from_compact(&signature.to_bytes()).unwrap();
9191
assert!(secp
9292
.verify_ecdsa(&c_message, &c_siganture, &c_public_key)

‎schnorr_fun/Cargo.toml

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -42,8 +42,9 @@ alloc = ["secp256kfun/alloc" ]
4242
std = ["alloc", "secp256kfun/std"]
4343
bincode = ["secp256kfun/bincode"]
4444
serde = ["secp256kfun/serde"]
45-
libsecp_compat = ["secp256kfun/libsecp_compat", "libsecp_compat_0_27"]
45+
libsecp_compat = ["secp256kfun/libsecp_compat", "libsecp_compat_0_28"]
4646
libsecp_compat_0_27 = ["secp256kfun/libsecp_compat_0_27"]
47+
libsecp_compat_0_28 = ["secp256kfun/libsecp_compat_0_28"]
4748
proptest = ["secp256kfun/proptest"]
4849
share_backup = ["dep:bech32"]
4950

‎schnorr_fun/benches/bench_schnorr.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -25,10 +25,10 @@ fn sign_schnorr(c: &mut Criterion) {
2525
}
2626

2727
{
28-
use secp256k1::{KeyPair, Message, Secp256k1};
28+
use secp256k1::{Keypair, Message, Secp256k1};
2929
let secp = Secp256k1::new();
30-
let kp = KeyPair::from_secret_key(&secp, &(*SK).into());
31-
let msg = Message::from_slice(&MESSAGE[..]).unwrap();
30+
let kp = Keypair::from_secret_key(&secp, &(*SK).into());
31+
let msg = Message::from_digest_slice(&MESSAGE[..]).unwrap();
3232
group.bench_function("secp::schnorrsig_sign_no_aux_rand", |b| {
3333
b.iter(|| {
3434
secp.sign_schnorr_no_aux_rand(&msg, &kp);
@@ -57,11 +57,11 @@ fn verify_schnorr(c: &mut Criterion) {
5757
}
5858

5959
{
60-
use secp256k1::{KeyPair, Message, Secp256k1, XOnlyPublicKey};
60+
use secp256k1::{Keypair, Message, Secp256k1, XOnlyPublicKey};
6161
let secp = Secp256k1::new();
62-
let kp = KeyPair::from_secret_key(&secp, &(*SK).into());
62+
let kp = Keypair::from_secret_key(&secp, &(*SK).into());
6363
let pk = XOnlyPublicKey::from_keypair(&kp).0;
64-
let msg = Message::from_slice(&MESSAGE[..]).unwrap();
64+
let msg = Message::from_digest_slice(&MESSAGE[..]).unwrap();
6565
let sig = secp.sign_schnorr_no_aux_rand(&msg, &kp);
6666
group.bench_function("secp::schnorrsig_verify", |b| {
6767
b.iter(|| secp.verify_schnorr(&sig, &msg, &pk));

‎schnorr_fun/src/libsecp_compat.rs

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -14,3 +14,20 @@ mod v0_27 {
1414
}
1515
}
1616
}
17+
18+
#[cfg(feature = "libsecp_compat_0_28")]
19+
mod v0_28 {
20+
use secp256kfun::secp256k1_0_28::schnorr;
21+
22+
impl From<crate::Signature> for schnorr::Signature {
23+
fn from(sig: crate::Signature) -> Self {
24+
schnorr::Signature::from_slice(sig.to_bytes().as_ref()).unwrap()
25+
}
26+
}
27+
28+
impl From<schnorr::Signature> for crate::Signature {
29+
fn from(sig: schnorr::Signature) -> Self {
30+
crate::Signature::from_bytes(*sig.as_ref()).unwrap()
31+
}
32+
}
33+
}

‎schnorr_fun/tests/against_c_lib.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -63,8 +63,8 @@ proptest! {
6363
msg in any::<[u8;32]>(),
6464
) {
6565
let secp = &*SECP;
66-
let keypair = secp256k1::KeyPair::from_secret_key(secp, &key.into());
67-
let secp_msg = secp256k1::Message::from_slice(&msg).unwrap();
66+
let keypair = secp256k1::Keypair::from_secret_key(secp, &key.into());
67+
let secp_msg = secp256k1::Message::from_digest_slice(&msg).unwrap();
6868
let sig = secp.sign_schnorr_no_aux_rand(&secp_msg, &keypair);
6969
let schnorr = Schnorr::<Sha256,Bip340NoAux>::default();
7070
let fun_keypair = schnorr.new_keypair(key);
@@ -77,9 +77,9 @@ proptest! {
7777
#[test]
7878
fn verify_secp_sigs(key in any::<Scalar>(), msg in any::<[u8;32]>(), aux_rand in any::<[u8;32]>()) {
7979
let secp = &*SECP;
80-
let keypair = secp256k1::KeyPair::from_secret_key(secp, &key.into());
80+
let keypair = secp256k1::Keypair::from_secret_key(secp, &key.into());
8181
let fun_pk = secp256k1::XOnlyPublicKey::from_keypair(&keypair).0.into();
82-
let secp_msg = secp256k1::Message::from_slice(&msg).unwrap();
82+
let secp_msg = secp256k1::Message::from_digest_slice(&msg).unwrap();
8383
let sig = secp.sign_schnorr_with_aux_rand(&secp_msg, &keypair, &aux_rand);
8484
let schnorr = Schnorr::<Sha256,_>::verify_only();
8585
let fun_msg = Message::<Public>::raw(&msg);

‎secp256kfun/Cargo.toml

Lines changed: 22 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -22,10 +22,13 @@ secp256kfun_arithmetic_macros = { version = "0.9.0", path = "../arithmetic_macro
2222

2323
# optional
2424
serde = { version = "1.0", optional = true, default-features = false, features = ["derive"] }
25-
secp256k1_0_27 = { package = "secp256k1", version = "0.27", optional = true, default-features = false }
2625
proptest = { version = "1", optional = true }
2726
bincode = { version = "2.0.0-rc.3", optional = true, default-features = false, features = ["derive"] }
2827

28+
secp256k1_0_27 = { package = "secp256k1", version = "0.27", optional = true, default-features = false }
29+
secp256k1_0_28 = { package = "secp256k1", version = "0.28", optional = true, default-features = false }
30+
31+
2932
[dev-dependencies]
3033
serde_json = "1"
3134
rand = { version = "0.8" }
@@ -39,11 +42,25 @@ wasm-bindgen-test = "0.3"
3942

4043
[features]
4144
default = ["std"]
45+
libsecp_compat = ["libsecp_compat_0_28"]
46+
alloc = [
47+
"serde?/alloc",
48+
"digest/alloc",
49+
"bincode?/alloc",
50+
"secp256k1_0_27?/alloc",
51+
"secp256k1_0_28?/alloc",
52+
]
53+
std = ["alloc", "subtle/std", "digest/std", "bincode?/std", "secp256k1_0_27?/std", "secp256k1_0_28?/std"]
54+
serde = [
55+
"dep:serde",
56+
"bincode?/serde",
57+
"secp256k1_0_27?/serde",
58+
"secp256k1_0_28?/serde",
59+
]
60+
4261
libsecp_compat_0_27 = [ "dep:secp256k1_0_27" ]
43-
libsecp_compat = ["libsecp_compat_0_27"]
44-
alloc = ["serde?/alloc", "digest/alloc", "secp256k1_0_27?/alloc", "bincode?/alloc"]
45-
std = ["alloc", "subtle/std", "digest/std", "bincode?/std", "secp256k1_0_27?/std"]
46-
serde = [ "dep:serde", "secp256k1_0_27?/serde", "bincode?/serde" ]
62+
libsecp_compat_0_28 = [ "dep:secp256k1_0_28" ]
63+
4764

4865
[[bench]]
4966
name = "bench_ecmult"

‎secp256kfun/src/lib.rs

Lines changed: 11 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -43,13 +43,6 @@ pub use point::Point;
4343
pub use scalar::Scalar;
4444
pub use slice::Slice;
4545

46-
#[cfg(feature = "libsecp_compat_0_27")]
47-
/// Re-export `secp256k1`
48-
pub extern crate secp256k1_0_27;
49-
50-
#[cfg(feature = "libsecp_compat")]
51-
pub use secp256k1_0_27 as secp256k1;
52-
5346
/// Re-export `serde`
5447
#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
5548
#[cfg(feature = "serde")]
@@ -89,3 +82,14 @@ pub static G: &Point<marker::BasePoint, marker::Public, marker::NonZero> =
8982

9083
// it is applied to nonce generators too so export at root
9184
pub use hash::Tag;
85+
86+
#[cfg(feature = "libsecp_compat_0_27")]
87+
/// Re-export `secp256k1`
88+
pub extern crate secp256k1_0_27;
89+
90+
#[cfg(feature = "libsecp_compat_0_28")]
91+
/// Re-export `secp256k1`
92+
pub extern crate secp256k1_0_28;
93+
94+
#[cfg(feature = "libsecp_compat")]
95+
pub use secp256k1_0_28 as secp256k1;

‎secp256kfun/src/libsecp_compat.rs

Lines changed: 104 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,108 @@
1+
#[cfg(feature = "libsecp_compat_0_28")]
2+
mod v0_28 {
3+
use crate::{marker::*, Point, Scalar};
4+
use secp256k1::{PublicKey, SecretKey, XOnlyPublicKey};
5+
use secp256k1_0_28 as secp256k1;
6+
7+
impl From<Scalar> for SecretKey {
8+
fn from(scalar: Scalar) -> Self {
9+
SecretKey::from_slice(scalar.to_bytes().as_ref()).unwrap()
10+
}
11+
}
12+
13+
impl From<SecretKey> for Scalar {
14+
fn from(sk: SecretKey) -> Self {
15+
Scalar::from_slice(&sk[..])
16+
.unwrap()
17+
.non_zero()
18+
.expect("SecretKey is never zero")
19+
}
20+
}
21+
22+
impl<Z> From<Scalar<Public, Z>> for secp256k1::Scalar {
23+
fn from(value: Scalar<Public, Z>) -> Self {
24+
secp256k1::Scalar::from_be_bytes(value.to_bytes()).unwrap()
25+
}
26+
}
27+
28+
impl From<secp256k1::Scalar> for Scalar<Public, Zero> {
29+
fn from(value: secp256k1::Scalar) -> Self {
30+
Scalar::from_bytes(value.to_be_bytes()).unwrap()
31+
}
32+
}
33+
34+
impl From<PublicKey> for Point {
35+
fn from(pk: PublicKey) -> Self {
36+
Point::<Normal, Public, NonZero>::from_bytes(pk.serialize()).unwrap()
37+
}
38+
}
39+
40+
impl From<Point> for PublicKey {
41+
fn from(pk: Point) -> Self {
42+
PublicKey::from_slice(pk.to_bytes().as_ref()).unwrap()
43+
}
44+
}
45+
46+
impl From<Point<EvenY>> for XOnlyPublicKey {
47+
fn from(point: Point<EvenY>) -> Self {
48+
XOnlyPublicKey::from_slice(point.to_xonly_bytes().as_ref()).unwrap()
49+
}
50+
}
51+
52+
impl From<XOnlyPublicKey> for Point<EvenY> {
53+
fn from(pk: XOnlyPublicKey) -> Self {
54+
Point::from_xonly_bytes(pk.serialize()).unwrap()
55+
}
56+
}
57+
58+
#[cfg(test)]
59+
mod test {
60+
use super::*;
61+
use core::str::FromStr;
62+
#[cfg(feature = "proptest")]
63+
use proptest::prelude::*;
64+
65+
#[test]
66+
fn public_key() {
67+
let pk = PublicKey::from_str("0479BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8").unwrap();
68+
let point = Point::from(pk);
69+
assert_eq!(pk.serialize().as_ref(), point.to_bytes().as_ref());
70+
}
71+
72+
#[cfg(feature = "proptest")]
73+
proptest! {
74+
75+
#[test]
76+
fn prop_public_key(first_byte in 0u8..10, x_bytes in any::<[u8;32]>()) {
77+
let mut bytes = [0u8;33];
78+
bytes[0] = first_byte;
79+
bytes[1..33].copy_from_slice(&x_bytes[..]);
80+
let pk = PublicKey::from_slice(&bytes[..]).ok();
81+
let point = Point::<_,Public, >::from_bytes(bytes);
82+
assert_eq!(pk.map(|pk| pk.serialize()), point.map(|point| point.to_bytes()));
83+
}
84+
85+
#[test]
86+
fn prop_secret_key(bytes in any::<[u8;32]>()) {
87+
let sk = SecretKey::from_slice(&bytes[..]).unwrap();
88+
let scalar = Scalar::from(sk);
89+
assert_eq!(&sk[..], scalar.to_bytes().as_ref());
90+
}
91+
92+
93+
94+
#[test]
95+
fn scalar_roundtrip(scalar in any::<Scalar<Public, Zero>>()) {
96+
let secp_scalar = secp256k1::Scalar::from(scalar);
97+
let rt_scalar = Scalar::from(secp_scalar);
98+
assert_eq!(rt_scalar, scalar);
99+
}
100+
}
101+
}
102+
}
103+
1104
#[cfg(feature = "libsecp_compat_0_27")]
2-
mod v27_0 {
105+
mod v0_27 {
3106
use crate::{marker::*, Point, Scalar};
4107
use secp256k1::{PublicKey, SecretKey, XOnlyPublicKey};
5108
use secp256k1_0_27 as secp256k1;

0 commit comments

Comments
 (0)