Skip to content

Commit c1d935a

Browse files
curiecryptcuriecrypt
committed
errors and tests revised
1 parent c21fa2c commit c1d935a

File tree

2 files changed

+72
-83
lines changed

2 files changed

+72
-83
lines changed

‎mithril-stm/src/signature_scheme/schnorr_signature/mod.rs‎

Lines changed: 71 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -18,13 +18,38 @@ mod tests {
1818
use rand_chacha::ChaCha20Rng;
1919
use rand_core::SeedableRng;
2020

21-
use crate::{SchnorrSignature, signature_scheme::SchnorrSignatureError};
21+
use crate::{
22+
SchnorrSignature,
23+
signature_scheme::{PrimeOrderProjectivePoint, ScalarFieldElement, SchnorrSignatureError},
24+
};
2225

2326
use super::{SchnorrSigningKey, SchnorrVerificationKey};
2427

2528
proptest! {
2629
#![proptest_config(ProptestConfig::with_cases(10))]
2730

31+
#[test]
32+
fn verification_key(seed in any::<[u8;32]>()) {
33+
// Valid generation check
34+
let sk = SchnorrSigningKey::generate(&mut ChaCha20Rng::from_seed(seed)).unwrap();
35+
let g = PrimeOrderProjectivePoint::create_generator();
36+
let vk = g.scalar_multiplication(&sk.0);
37+
let vk_from_sk = SchnorrVerificationKey::new_from_signing_key(sk).unwrap();
38+
assert_eq!(vk, vk_from_sk.0);
39+
40+
// Check if sk is 0
41+
let mut bytes = [0u8; 32];
42+
let sk = SchnorrSigningKey(ScalarFieldElement::from_bytes(&bytes).unwrap());
43+
SchnorrVerificationKey::new_from_signing_key(sk)
44+
.expect_err("Verification key should not be generated from zero signing key");
45+
46+
// Check if sk is 1
47+
bytes[0] = 1;
48+
let sk = SchnorrSigningKey(ScalarFieldElement::from_bytes(&bytes).unwrap());
49+
SchnorrVerificationKey::new_from_signing_key(sk)
50+
.expect_err("Verification key should not be generated from one signing key");
51+
}
52+
2853
#[test]
2954
fn valid_signing_verification(
3055
msg in prop::collection::vec(any::<u8>(), 1..128),
@@ -67,15 +92,27 @@ mod tests {
6792
fn signing_key_to_from_bytes(seed in any::<[u8;32]>()) {
6893
let mut rng = ChaCha20Rng::from_seed(seed);
6994
let sk = SchnorrSigningKey::generate(&mut rng).unwrap();
70-
7195
let mut sk_bytes = sk.to_bytes();
96+
97+
// Valid conversion
7298
let recovered_sk = SchnorrSigningKey::from_bytes(&sk_bytes).unwrap();
7399
assert_eq!(sk.0, recovered_sk.0, "Recovered signing key does not match with the original!");
74100

75-
sk_bytes[31] |= 0xff;
101+
// Not enough bytes
102+
let mut short_bytes = [0u8; 31];
103+
short_bytes.copy_from_slice(sk_bytes.get(..31).unwrap());
104+
let result = SchnorrSigningKey::from_bytes(&short_bytes).expect_err("From bytes conversion of signing key should fail");
105+
assert!(
106+
matches!(
107+
result.downcast_ref::<SchnorrSignatureError>(),
108+
Some(SchnorrSignatureError::SerializationError)
109+
),
110+
"Unexpected error: {result:?}"
111+
);
76112

113+
// Invalid bytes
114+
sk_bytes[31] |= 0xff;
77115
let result = SchnorrSigningKey::from_bytes(&sk_bytes).expect_err("From bytes conversion of signing key should fail");
78-
79116
assert!(
80117
matches!(
81118
result.downcast_ref::<SchnorrSignatureError>(),
@@ -90,15 +127,27 @@ mod tests {
90127
let mut rng = ChaCha20Rng::from_seed(seed);
91128
let sk = SchnorrSigningKey::generate(&mut rng).unwrap();
92129
let vk = SchnorrVerificationKey::new_from_signing_key(sk.clone()).unwrap();
93-
94130
let mut vk_bytes = vk.to_bytes();
131+
132+
// Valid conversion
95133
let recovered_vk = SchnorrVerificationKey::from_bytes(&vk_bytes).unwrap();
96134
assert_eq!(vk.0, recovered_vk.0, "Recovered verification key does not match with the original!");
97135

98-
vk_bytes[31] |= 0xff;
136+
// Not enough bytes
137+
let mut short_bytes = [0u8; 31];
138+
short_bytes.copy_from_slice(vk_bytes.get(..31).unwrap());
139+
let result = SchnorrVerificationKey::from_bytes(&short_bytes).expect_err("From bytes conversion of verification key should fail");
140+
assert!(
141+
matches!(
142+
result.downcast_ref::<SchnorrSignatureError>(),
143+
Some(SchnorrSignatureError::SerializationError)
144+
),
145+
"Unexpected error: {result:?}"
146+
);
99147

148+
// Invalid bytes
149+
vk_bytes[31] |= 0xff;
100150
let result = SchnorrVerificationKey::from_bytes(&vk_bytes).expect_err("From bytes conversion of verification key should fail");
101-
102151
assert!(
103152
matches!(
104153
result.downcast_ref::<SchnorrSignatureError>(),
@@ -111,20 +160,18 @@ mod tests {
111160
#[test]
112161
fn signature_to_from_bytes(msg in prop::collection::vec(any::<u8>(), 1..128), seed in any::<[u8;32]>()) {
113162
let mut rng = ChaCha20Rng::from_seed(seed);
114-
115163
let sk = SchnorrSigningKey::generate(&mut rng).unwrap();
116164
let signature = sk.sign(&msg, &mut ChaCha20Rng::from_seed(seed)).unwrap();
117-
118165
let signature_bytes = signature.to_bytes();
166+
167+
// Valid conversion
119168
let recovered_signature = SchnorrSignature::from_bytes(&signature_bytes).unwrap();
120169
assert_eq!(signature, recovered_signature, "Recovered signature does not match with the original!");
121170

122171
// Test invalid `sigma`
123172
let mut corrupted_bytes = signature_bytes.clone();
124173
corrupted_bytes[31] |= 0xff;
125-
126174
let result = SchnorrSignature::from_bytes(&corrupted_bytes).expect_err("From bytes conversion of signature should fail");
127-
128175
assert!(
129176
matches!(
130177
result.downcast_ref::<SchnorrSignatureError>(),
@@ -136,29 +183,38 @@ mod tests {
136183
// Test invalid `signature`
137184
let mut corrupted_bytes = signature_bytes.clone();
138185
corrupted_bytes[63] |= 0xff;
139-
140186
let result = SchnorrSignature::from_bytes(&corrupted_bytes).expect_err("From bytes conversion should fail");
141-
142187
assert!(
143188
matches!(
144189
result.downcast_ref::<SchnorrSignatureError>(),
145190
Some(SchnorrSignatureError::ScalarFieldElementSerializationError)
146191
),
147192
"Unexpected error: {result:?}"
148193
);
194+
149195
// Test invalid `challenge`
150196
let mut corrupted_bytes = signature_bytes.clone();
151197
corrupted_bytes[95] |= 0xff;
152-
153198
let result = SchnorrSignature::from_bytes(&corrupted_bytes).expect_err("From bytes conversion should fail");
154-
155199
assert!(
156200
matches!(
157201
result.downcast_ref::<SchnorrSignatureError>(),
158202
Some(SchnorrSignatureError::ScalarFieldElementSerializationError)
159203
),
160204
"Unexpected error: {result:?}"
161205
);
206+
207+
// Not enough bytes
208+
let mut short_bytes = [0u8; 95];
209+
short_bytes.copy_from_slice(signature_bytes.get(..95).unwrap());
210+
let result = SchnorrSignature::from_bytes(&short_bytes).expect_err("From bytes conversion of signature should fail");
211+
assert!(
212+
matches!(
213+
result.downcast_ref::<SchnorrSignatureError>(),
214+
Some(SchnorrSignatureError::SerializationError)
215+
),
216+
"Unexpected error: {result:?}"
217+
);
162218
}
163219
}
164220
}

‎mithril-stm/src/signature_scheme/schnorr_signature/verification_key.rs‎

Lines changed: 1 addition & 68 deletions
Original file line numberDiff line numberDiff line change
@@ -63,79 +63,12 @@ impl SchnorrVerificationKey {
6363

6464
#[cfg(test)]
6565
mod tests {
66-
use rand_chacha::ChaCha20Rng;
67-
use rand_core::SeedableRng;
68-
69-
use crate::signature_scheme::ScalarFieldElement;
70-
71-
use super::{PrimeOrderProjectivePoint, SchnorrSigningKey, SchnorrVerificationKey};
72-
73-
#[test]
74-
fn verification_key_from_invalid_signing_key() {
75-
let mut bytes = [0u8; 32];
76-
let sk = SchnorrSigningKey(ScalarFieldElement::from_bytes(&bytes).unwrap());
77-
SchnorrVerificationKey::new_from_signing_key(sk)
78-
.expect_err("Verification key should not be generated from zero signing key");
79-
80-
bytes[0] = 1;
81-
let sk = SchnorrSigningKey(ScalarFieldElement::from_bytes(&bytes).unwrap());
82-
SchnorrVerificationKey::new_from_signing_key(sk)
83-
.expect_err("Verification key should not be generated from one signing key");
84-
}
85-
86-
#[test]
87-
fn generate_verification_key() {
88-
let mut rng = ChaCha20Rng::from_seed([0u8; 32]);
89-
let sk = SchnorrSigningKey::generate(&mut rng).unwrap();
90-
let g = PrimeOrderProjectivePoint::create_generator();
91-
let vk = g.scalar_multiplication(&sk.0);
92-
93-
let vk_from_sk = SchnorrVerificationKey::new_from_signing_key(sk).unwrap();
94-
95-
assert_eq!(vk, vk_from_sk.0);
96-
}
97-
98-
#[test]
99-
fn verify_fail_verification_key_not_on_curve() {
100-
let msg = vec![0, 0, 0, 1];
101-
let seed = [0u8; 32];
102-
let mut rng = ChaCha20Rng::from_seed(seed);
103-
104-
let sk1 = SchnorrSigningKey::generate(&mut rng).unwrap();
105-
let sk2 = SchnorrSigningKey::generate(&mut rng).unwrap();
106-
107-
let vk1 = SchnorrVerificationKey::new_from_signing_key(sk1.clone()).unwrap();
108-
let vk2 = SchnorrVerificationKey::new_from_signing_key(sk2).unwrap();
109-
110-
let sig = sk1.sign(&msg, &mut rng).unwrap();
111-
112-
let result1 = sig.verify(&msg, &vk1);
113-
let result2 = sig.verify(&msg, &vk2);
114-
115-
result1.expect("Correct verification key used, test should pass.");
116-
117-
result2.expect_err("Invalid verification key used, test should fail.");
118-
}
119-
120-
#[test]
121-
fn serialize_deserialize_vk() {
122-
let seed = 0;
123-
let mut rng = rand_chacha::ChaCha8Rng::seed_from_u64(seed);
124-
let sk = SchnorrSigningKey::generate(&mut rng).unwrap();
125-
let vk = SchnorrVerificationKey::new_from_signing_key(sk).unwrap();
126-
127-
let vk_bytes = vk.to_bytes();
128-
let vk2 = SchnorrVerificationKey::from_bytes(&vk_bytes).unwrap();
129-
130-
assert_eq!(vk.0, vk2.0);
131-
}
132-
13366
mod golden {
13467

13568
use rand_chacha::ChaCha20Rng;
13669
use rand_core::SeedableRng;
13770

138-
use super::{SchnorrSigningKey, SchnorrVerificationKey};
71+
use crate::{SchnorrSigningKey, SchnorrVerificationKey};
13972

14073
const GOLDEN_BYTES: &[u8; 32] = &[
14174
144, 52, 95, 161, 127, 253, 49, 32, 140, 217, 231, 207, 32, 238, 244, 196, 97, 241, 47,

0 commit comments

Comments
 (0)