Skip to main content

libkeri/cesr/
verfer.rs

1use crate::cesr::{mtr_dex, BaseMatter, Parsable};
2use crate::errors::MatterError;
3use crate::Matter;
4use sodiumoxide::crypto::sign::ed25519;
5use std::any::Any;
6
7use p256::ecdsa::{signature::Verifier, Signature as p256Signature, VerifyingKey};
8use secp256k1::ecdsa::Signature;
9use secp256k1::{Message, PublicKey, Secp256k1};
10use sha2::{Digest, Sha256};
11
12///  Verfer is Matter subclass with method to verify signature of serialization
13///  using the .raw as verifier key and .code for signature cipher suite.
14#[derive(Debug, Clone)]
15pub struct Verfer {
16    base: BaseMatter,
17}
18
19impl Verfer {
20    /// Creates a new `Verfer` instance from a QB64-encoded string.
21    /// This method calls `BaseMatter::from_qb64` and verifies the code is supported.
22    pub fn from_qb64(qb64: &str) -> Result<Self, MatterError> {
23        let base = BaseMatter::from_qb64(qb64)?;
24
25        // Validate the code is supported
26        if ![
27            mtr_dex::ED25519N,
28            mtr_dex::ED25519,
29            mtr_dex::ECDSA_256R1N,
30            mtr_dex::ECDSA_256R1,
31            mtr_dex::ECDSA_256K1N,
32            mtr_dex::ECDSA_256K1,
33        ]
34        .contains(&base.code())
35        {
36            return Err(MatterError::UnsupportedCodeError(String::from(base.code())));
37        }
38
39        Ok(Verfer { base })
40    }
41
42    pub fn new(code: Option<&[u8]>, raw: Option<&str>) -> Result<Self, MatterError> {
43        let verfer = Self {
44            base: BaseMatter::new(code, raw, None, None)?,
45        };
46
47        // Validate the code is supported
48        if ![
49            mtr_dex::ED25519N,
50            mtr_dex::ED25519,
51            mtr_dex::ECDSA_256R1N,
52            mtr_dex::ECDSA_256R1,
53            mtr_dex::ECDSA_256K1N,
54            mtr_dex::ECDSA_256K1,
55        ]
56        .contains(&verfer.code())
57        {
58            return Err(MatterError::UnsupportedCodeError(String::from(
59                verfer.code(),
60            )));
61        }
62
63        Ok(verfer)
64    }
65
66    // Public method that dispatches to the appropriate implementation
67    pub fn verify(&self, sig: &[u8], ser: &[u8]) -> Result<bool, MatterError> {
68        match self.code() {
69            code if code == mtr_dex::ED25519N || code == mtr_dex::ED25519 => {
70                self.ed25519_verify(sig, ser)
71            }
72            code if code == mtr_dex::ECDSA_256R1N || code == mtr_dex::ECDSA_256R1 => {
73                self.secp256r1_verify(sig, ser)
74            }
75            code if code == mtr_dex::ECDSA_256K1N || code == mtr_dex::ECDSA_256K1 => {
76                self.secp256k1_verify(sig, ser)
77            }
78            // This should never happen because we validate in the constructor
79            _ => Err(MatterError::UnsupportedCodeError(String::from(self.code()))),
80        }
81    }
82
83    // Private implementation methods
84    fn ed25519_verify(&self, sig: &[u8], ser: &[u8]) -> Result<bool, MatterError> {
85        // Ed25519 public key must be 32 bytes
86        if self.raw().len() != ed25519::PUBLICKEYBYTES {
87            return Err(MatterError::InvalidKeyLength {
88                expected: ed25519::PUBLICKEYBYTES,
89                actual: self.raw().len(),
90            });
91        }
92
93        // Ed25519 signature must be 64 bytes
94        if sig.len() != ed25519::SIGNATUREBYTES {
95            return Err(MatterError::InvalidSignatureLength {
96                expected: ed25519::SIGNATUREBYTES,
97                actual: sig.len(),
98            });
99        }
100
101        // Convert raw key bytes to sodiumoxide PublicKey
102        let pk = match ed25519::PublicKey::from_slice(&self.raw()) {
103            Some(key) => key,
104            None => {
105                return Err(MatterError::VerificationError(
106                    "Invalid public key format".to_string(),
107                ))
108            }
109        };
110
111        // Convert signature bytes to sodiumoxide Signature
112        let signature = match ed25519::Signature::from_bytes(sig) {
113            Ok(sig) => sig,
114            Err(_) => {
115                return Err(MatterError::VerificationError(
116                    "Invalid signature format".to_string(),
117                ))
118            }
119        };
120        // Verify the signature
121        let result = ed25519::verify_detached(&signature, ser, &pk);
122
123        Ok(result)
124    }
125
126    fn secp256r1_verify(&self, sig: &[u8], ser: &[u8]) -> Result<bool, MatterError> {
127        // P-256 public keys are typically 33 bytes (compressed) or 65 bytes (uncompressed)
128        if self.raw().len() != 33 && self.raw().len() != 65 {
129            return Err(MatterError::InvalidKeyLength {
130                expected: 33, // We can expect compressed keys as standard
131                actual: self.raw().len(),
132            });
133        }
134
135        // Parse the verifying key from SEC1 encoded public key bytes
136        let verifying_key = VerifyingKey::from_sec1_bytes(&self.raw())
137            .map_err(|e| MatterError::Secp256r1Error(format!("Invalid public key: {}", e)))?;
138
139        // For P-256 ECDSA signatures, we need to handle different formats
140
141        // Try to parse the signature as DER format first
142        let signature_result = p256Signature::from_bytes(sig.into());
143
144        // If DER parsing fails, try ASN.1 format
145        let signature = match signature_result {
146            Ok(sig) => sig,
147            Err(_) => {
148                // If not DER, try ASN.1
149                p256Signature::try_from(sig).map_err(|e| {
150                    MatterError::Secp256r1Error(format!("Invalid signature format: {}", e))
151                })?
152            }
153        };
154
155        // Verify the signature against the hash
156        match verifying_key.verify(ser, &signature) {
157            Ok(_) => Ok(true),
158            Err(_) => Ok(false), // Signature verification failed but the function succeeded
159        }
160    }
161
162    fn secp256k1_verify(&self, sig: &[u8], ser: &[u8]) -> Result<bool, MatterError> {
163        // Create a secp256k1 context for verification only
164        let secp = Secp256k1::verification_only();
165
166        // SECP256K1 public keys are typically 33 bytes (compressed) or 65 bytes (uncompressed)
167        // Check that we have a valid public key length
168        if self.raw().len() != 33 && self.raw().len() != 65 {
169            return Err(MatterError::InvalidKeyLength {
170                expected: 33, // We can expect compressed keys as standard
171                actual: self.raw().len(),
172            });
173        }
174
175        // Parse the public key from self.raw
176        let public_key = PublicKey::from_slice(&self.raw())
177            .map_err(|e| MatterError::Secp256k1Error(format!("Invalid public key: {}", e)))?;
178
179        // For ECDSA signatures with secp256k1, we typically expect DER or compact format
180        // Compact is 64 bytes, DER can vary but is typically ~70-72 bytes
181
182        // Attempt to parse as compact first (most common in many systems)
183        let signature = if sig.len() == 64 {
184            Signature::from_compact(sig).map_err(|e| {
185                MatterError::Secp256k1Error(format!("Invalid compact signature: {}", e))
186            })?
187        } else {
188            // Try as DER format
189            Signature::from_der(sig)
190                .map_err(|e| MatterError::Secp256k1Error(format!("Invalid DER signature: {}", e)))?
191        };
192
193        // ECDSA requires a 32-byte message digest
194        // Hash the serialized data to get a 32-byte digest
195        let mut hasher = Sha256::new();
196        hasher.update(ser);
197        let result = hasher.finalize();
198        let message_hash: [u8; 32] = result.into();
199
200        // Create a Message object from the 32-byte hash
201        let message = Message::from_digest(message_hash);
202
203        // Verify the signature
204        match secp.verify_ecdsa(&message, &signature, &public_key) {
205            Ok(_) => Ok(true),
206            Err(_) => Ok(false), // Verification failed but function succeeded
207        }
208    }
209}
210
211impl Parsable for Verfer {
212    fn from_qb64b(data: &mut Vec<u8>, strip: Option<bool>) -> Result<Self, MatterError> {
213        let base = BaseMatter::from_qb64b(data, strip)?;
214        if ![
215            mtr_dex::ED25519N,
216            mtr_dex::ED25519,
217            mtr_dex::ECDSA_256R1N,
218            mtr_dex::ECDSA_256R1,
219            mtr_dex::ECDSA_256K1N,
220            mtr_dex::ECDSA_256K1,
221        ]
222        .contains(&base.code())
223        {
224            return Err(MatterError::UnsupportedCodeError(String::from(base.code())));
225        }
226
227        Ok(Verfer { base })
228    }
229
230    fn from_qb2(data: &mut Vec<u8>, strip: Option<bool>) -> Result<Self, MatterError> {
231        let base = BaseMatter::from_qb2(data, strip)?;
232        if ![
233            mtr_dex::ED25519N,
234            mtr_dex::ED25519,
235            mtr_dex::ECDSA_256R1N,
236            mtr_dex::ECDSA_256R1,
237            mtr_dex::ECDSA_256K1N,
238            mtr_dex::ECDSA_256K1,
239        ]
240        .contains(&base.code())
241        {
242            return Err(MatterError::UnsupportedCodeError(String::from(base.code())));
243        }
244
245        Ok(Verfer { base })
246    }
247}
248
249impl Matter for Verfer {
250    fn code(&self) -> &str {
251        self.base.code()
252    }
253    fn raw(&self) -> &[u8] {
254        self.base.raw()
255    }
256    fn qb64(&self) -> String {
257        self.base.qb64()
258    }
259    fn qb64b(&self) -> Vec<u8> {
260        self.base.qb64b()
261    }
262    fn qb2(&self) -> Vec<u8> {
263        self.base.qb2()
264    }
265    fn soft(&self) -> &str {
266        self.base.soft()
267    }
268    fn full_size(&self) -> usize {
269        self.base.full_size()
270    }
271    fn size(&self) -> usize {
272        self.base.size()
273    }
274    fn is_transferable(&self) -> bool {
275        self.base.is_transferable()
276    }
277    fn is_digestive(&self) -> bool {
278        self.base.is_digestive()
279    }
280    fn is_prefixive(&self) -> bool {
281        self.base.is_prefixive()
282    }
283    fn is_special(&self) -> bool {
284        self.base.is_special()
285    }
286    fn as_any(&self) -> &dyn Any {
287        self
288    }
289}
290
291#[cfg(test)]
292mod tests {
293    use super::*;
294    use p256::ecdsa::{signature::Signer, SigningKey};
295    use rand_core::OsRng;
296    use secp256k1::{rand, PublicKey, Secp256k1, SecretKey};
297    use sha2::{Digest, Sha256};
298    use sodiumoxide::crypto::sign::ed25519;
299
300    #[test]
301    fn test_verfer_ed25519() {
302        // Initialize sodiumoxide
303        sodiumoxide::init().expect("Sodium initialization failed");
304
305        // Generate random seed and keypair
306        let (public_key, secret_key) = ed25519::gen_keypair();
307        let verkey = public_key.as_ref();
308
309        // Test EmptyMaterialError
310        let empty_result = Verfer::new(None, Some(mtr_dex::ED25519N));
311        assert!(matches!(empty_result, Err(MatterError::TypeError(_))));
312
313        // Test with Ed25519N code
314        let verfer = Verfer::new(Some(verkey), Some(mtr_dex::ED25519N)).unwrap();
315        assert_eq!(verfer.raw(), verkey);
316        assert_eq!(verfer.code(), mtr_dex::ED25519N);
317
318        // Create something to sign and verify
319        let ser = b"abcdefghijklmnopqrstuvwxyz0123456789";
320
321        // Sign the message
322        let sig = ed25519::sign_detached(ser, &secret_key);
323
324        // Verify the signature
325        let result = verfer.verify(sig.as_ref(), ser).unwrap();
326        assert!(result);
327
328        // Test with Ed25519 code
329        let verfer = Verfer::new(Some(verkey), Some(mtr_dex::ED25519)).unwrap();
330        assert_eq!(verfer.raw(), verkey);
331        assert_eq!(verfer.code(), mtr_dex::ED25519);
332
333        // Verify the signature again
334        let result = verfer.verify(sig.as_ref(), ser).unwrap();
335        assert!(result);
336
337        // Test with invalid code
338        let blake_result = Verfer::new(Some(verkey), Some(mtr_dex::BLAKE3_256));
339        assert!(matches!(
340            blake_result,
341            Err(MatterError::UnsupportedCodeError(_))
342        ));
343    }
344
345    #[test]
346    fn test_secp256r1_verfer() {
347        // Initialize sodiumoxide
348        sodiumoxide::init().expect("Sodium initialization failed");
349
350        let signing_key = SigningKey::random(&mut OsRng);
351
352        // Get the public key in compressed format (equivalent to CompressedPoint in Python)
353        let p256_public_key = signing_key.verifying_key();
354        let verkey = p256_public_key.to_encoded_point(true).as_bytes().to_vec();
355
356        // Create Verfer with secp256r1
357        let verfer = Verfer::new(Some(&verkey), Some(mtr_dex::ECDSA_256R1))
358            .expect("Failed to create verfer");
359
360        // Verify the verfer properties
361        assert_eq!(verfer.raw(), &(*verkey));
362        assert_eq!(verfer.code(), mtr_dex::ECDSA_256R1);
363
364        // Message to sign
365        let ser = b"abcdefghijklmnopqrstuvwxyz0123456789";
366
367        // Sign the message
368        // Note: p256 library automatically hashes using SHA-256 when signing
369        let signature: p256Signature = signing_key.sign(ser);
370        let result = match p256_public_key.verify(ser, &signature) {
371            Ok(_) => true,
372            Err(_) => false,
373        };
374        assert!(result);
375
376        // Convert the ASN.1 DER signature to raw R and S values
377        // (equivalent to decode_dss_signature in Python)
378        let der_bytes = signature.to_bytes();
379
380        // Also create a raw signature from R and S components
381        // This is equivalent to the Python code creating sig from r and s
382        // Extract the r and s values
383        let r = signature.r().to_bytes();
384        let s = signature.s().to_bytes();
385
386        let mut raw_sig = Vec::with_capacity(64);
387        raw_sig.extend_from_slice(&r);
388        raw_sig.extend_from_slice(&s);
389
390        // Verify the signature
391        let result = verfer
392            .verify(&raw_sig, ser)
393            .expect("Verification failed with error");
394        assert!(result);
395
396        // Test negative case
397        let result = verfer
398            .verify(&der_bytes, b"ABC")
399            .expect("Verification failed with error");
400        assert!(!result);
401
402        // Create Verfer with secp256r1
403        let verfer = Verfer::new(Some(&verkey), Some(mtr_dex::ECDSA_256R1N))
404            .expect("Failed to create verfer");
405
406        // Verify the verfer properties
407        assert_eq!(verfer.raw(), &(*verkey));
408        assert_eq!(verfer.code(), mtr_dex::ECDSA_256R1N);
409    }
410
411    #[test]
412    fn test_verfer_secp256k1() {
413        // Create a new secp256k1 context
414        let secp = Secp256k1::new();
415
416        // Generate random secret key
417        let mut rng = rand::thread_rng();
418        let secret_key = SecretKey::new(&mut rng);
419
420        // Get the public key in compressed format (equivalent to X962 compressed point format)
421        let public_key = PublicKey::from_secret_key(&secp, &secret_key);
422        let verkey = public_key.serialize();
423
424        // Create verfer with the compressed public key
425        let verfer = Verfer::new(Some(&verkey.to_vec()), Some(mtr_dex::ECDSA_256K1)).unwrap();
426
427        assert_eq!(verfer.raw(), verkey.to_vec());
428        assert_eq!(verfer.code(), mtr_dex::ECDSA_256K1);
429
430        // Message to sign
431        let ser = b"abcdefghijklmnopqrstuvwxyz0123456789";
432
433        // Hash the message with SHA-256
434        let mut hasher = Sha256::new();
435        hasher.update(ser);
436        let digest = hasher.finalize();
437        let digest: [u8; 32] = digest.into();
438
439        // Sign the message hash with the secret key
440        let message = Message::from_digest(digest);
441        let signature = secp.sign_ecdsa(&message, &secret_key);
442
443        // Get DER format for signature (for testing DER rejection)
444        let der_sig = signature.serialize_der();
445
446        // Convert to r+s format (each 32 bytes)
447        let ser_sig = signature.serialize_compact();
448
449        // Verify signature
450        let result = verfer.verify(&ser_sig, ser).unwrap();
451        assert!(result);
452
453        // Try verifying with wrong message
454        let wrong_message = b"ABC";
455        let result = verfer.verify(&der_sig, wrong_message);
456        assert!(result.is_err() || !result.unwrap());
457
458        // Test with ECDSA_256k1N
459        // Generate new random keys
460        let secret_key = SecretKey::new(&mut rng);
461        let public_key = PublicKey::from_secret_key(&secp, &secret_key);
462        let verkey = public_key.serialize();
463
464        // Create verfer with the compressed public key using ECDSA_256k1N
465        let verfer = Verfer::new(Some(&verkey.to_vec()), Some(mtr_dex::ECDSA_256K1N)).unwrap();
466
467        assert_eq!(verfer.raw(), verkey.to_vec());
468        assert_eq!(verfer.code(), mtr_dex::ECDSA_256K1N);
469
470        // Sign the message hash with the secret key
471        let mut hasher = Sha256::new();
472        hasher.update(ser);
473        let digest = hasher.finalize();
474        let digest: [u8; 32] = digest.into();
475
476        let message = Message::from_digest(digest);
477        let signature = secp.sign_ecdsa(&message, &secret_key);
478
479        // Get DER format for signature (for testing DER rejection)
480        let der_sig = signature.serialize_der();
481
482        // Convert to r+s format (each 32 bytes)
483        let ser_sig = signature.serialize_compact();
484
485        // Verify signature
486        let result = verfer.verify(&ser_sig, ser).unwrap();
487        assert!(result);
488
489        // Try verifying with wrong message
490        let wrong_message = b"ABC";
491        let result = verfer.verify(&der_sig, wrong_message);
492        assert!(result.is_err() || !result.unwrap());
493    }
494}