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#[derive(Debug, Clone)]
15pub struct Verfer {
16 base: BaseMatter,
17}
18
19impl Verfer {
20 pub fn from_qb64(qb64: &str) -> Result<Self, MatterError> {
23 let base = BaseMatter::from_qb64(qb64)?;
24
25 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 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 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 _ => Err(MatterError::UnsupportedCodeError(String::from(self.code()))),
80 }
81 }
82
83 fn ed25519_verify(&self, sig: &[u8], ser: &[u8]) -> Result<bool, MatterError> {
85 if self.raw().len() != ed25519::PUBLICKEYBYTES {
87 return Err(MatterError::InvalidKeyLength {
88 expected: ed25519::PUBLICKEYBYTES,
89 actual: self.raw().len(),
90 });
91 }
92
93 if sig.len() != ed25519::SIGNATUREBYTES {
95 return Err(MatterError::InvalidSignatureLength {
96 expected: ed25519::SIGNATUREBYTES,
97 actual: sig.len(),
98 });
99 }
100
101 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 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 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 if self.raw().len() != 33 && self.raw().len() != 65 {
129 return Err(MatterError::InvalidKeyLength {
130 expected: 33, actual: self.raw().len(),
132 });
133 }
134
135 let verifying_key = VerifyingKey::from_sec1_bytes(&self.raw())
137 .map_err(|e| MatterError::Secp256r1Error(format!("Invalid public key: {}", e)))?;
138
139 let signature_result = p256Signature::from_bytes(sig.into());
143
144 let signature = match signature_result {
146 Ok(sig) => sig,
147 Err(_) => {
148 p256Signature::try_from(sig).map_err(|e| {
150 MatterError::Secp256r1Error(format!("Invalid signature format: {}", e))
151 })?
152 }
153 };
154
155 match verifying_key.verify(ser, &signature) {
157 Ok(_) => Ok(true),
158 Err(_) => Ok(false), }
160 }
161
162 fn secp256k1_verify(&self, sig: &[u8], ser: &[u8]) -> Result<bool, MatterError> {
163 let secp = Secp256k1::verification_only();
165
166 if self.raw().len() != 33 && self.raw().len() != 65 {
169 return Err(MatterError::InvalidKeyLength {
170 expected: 33, actual: self.raw().len(),
172 });
173 }
174
175 let public_key = PublicKey::from_slice(&self.raw())
177 .map_err(|e| MatterError::Secp256k1Error(format!("Invalid public key: {}", e)))?;
178
179 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 Signature::from_der(sig)
190 .map_err(|e| MatterError::Secp256k1Error(format!("Invalid DER signature: {}", e)))?
191 };
192
193 let mut hasher = Sha256::new();
196 hasher.update(ser);
197 let result = hasher.finalize();
198 let message_hash: [u8; 32] = result.into();
199
200 let message = Message::from_digest(message_hash);
202
203 match secp.verify_ecdsa(&message, &signature, &public_key) {
205 Ok(_) => Ok(true),
206 Err(_) => Ok(false), }
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 sodiumoxide::init().expect("Sodium initialization failed");
304
305 let (public_key, secret_key) = ed25519::gen_keypair();
307 let verkey = public_key.as_ref();
308
309 let empty_result = Verfer::new(None, Some(mtr_dex::ED25519N));
311 assert!(matches!(empty_result, Err(MatterError::TypeError(_))));
312
313 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 let ser = b"abcdefghijklmnopqrstuvwxyz0123456789";
320
321 let sig = ed25519::sign_detached(ser, &secret_key);
323
324 let result = verfer.verify(sig.as_ref(), ser).unwrap();
326 assert!(result);
327
328 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 let result = verfer.verify(sig.as_ref(), ser).unwrap();
335 assert!(result);
336
337 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 sodiumoxide::init().expect("Sodium initialization failed");
349
350 let signing_key = SigningKey::random(&mut OsRng);
351
352 let p256_public_key = signing_key.verifying_key();
354 let verkey = p256_public_key.to_encoded_point(true).as_bytes().to_vec();
355
356 let verfer = Verfer::new(Some(&verkey), Some(mtr_dex::ECDSA_256R1))
358 .expect("Failed to create verfer");
359
360 assert_eq!(verfer.raw(), &(*verkey));
362 assert_eq!(verfer.code(), mtr_dex::ECDSA_256R1);
363
364 let ser = b"abcdefghijklmnopqrstuvwxyz0123456789";
366
367 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 let der_bytes = signature.to_bytes();
379
380 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 let result = verfer
392 .verify(&raw_sig, ser)
393 .expect("Verification failed with error");
394 assert!(result);
395
396 let result = verfer
398 .verify(&der_bytes, b"ABC")
399 .expect("Verification failed with error");
400 assert!(!result);
401
402 let verfer = Verfer::new(Some(&verkey), Some(mtr_dex::ECDSA_256R1N))
404 .expect("Failed to create verfer");
405
406 assert_eq!(verfer.raw(), &(*verkey));
408 assert_eq!(verfer.code(), mtr_dex::ECDSA_256R1N);
409 }
410
411 #[test]
412 fn test_verfer_secp256k1() {
413 let secp = Secp256k1::new();
415
416 let mut rng = rand::thread_rng();
418 let secret_key = SecretKey::new(&mut rng);
419
420 let public_key = PublicKey::from_secret_key(&secp, &secret_key);
422 let verkey = public_key.serialize();
423
424 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 let ser = b"abcdefghijklmnopqrstuvwxyz0123456789";
432
433 let mut hasher = Sha256::new();
435 hasher.update(ser);
436 let digest = hasher.finalize();
437 let digest: [u8; 32] = digest.into();
438
439 let message = Message::from_digest(digest);
441 let signature = secp.sign_ecdsa(&message, &secret_key);
442
443 let der_sig = signature.serialize_der();
445
446 let ser_sig = signature.serialize_compact();
448
449 let result = verfer.verify(&ser_sig, ser).unwrap();
451 assert!(result);
452
453 let wrong_message = b"ABC";
455 let result = verfer.verify(&der_sig, wrong_message);
456 assert!(result.is_err() || !result.unwrap());
457
458 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 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 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 let der_sig = signature.serialize_der();
481
482 let ser_sig = signature.serialize_compact();
484
485 let result = verfer.verify(&ser_sig, ser).unwrap();
487 assert!(result);
488
489 let wrong_message = b"ABC";
491 let result = verfer.verify(&der_sig, wrong_message);
492 assert!(result.is_err() || !result.unwrap());
493 }
494}