1use crate::cesr::cigar::Cigar;
2use crate::cesr::indexing::idr_dex;
3use crate::cesr::indexing::siger::Siger;
4use crate::cesr::signing::Sigmat;
5use crate::cesr::verfer::Verfer;
6use crate::cesr::{mtr_dex, BaseMatter, Parsable};
7use crate::errors::MatterError;
8use crate::Matter;
9use p256::ecdsa::SigningKey;
10use rand_core::{OsRng, RngCore};
11use secp256k1::{Message, Secp256k1, SecretKey};
12use sha3::{Digest, Sha3_256};
13use sodiumoxide::crypto::sign::ed25519;
14use sodiumoxide::randombytes;
15use std::any::Any;
16
17#[derive(Debug, Clone)]
26pub struct Signer {
27 base: BaseMatter,
28 pub verfer: Verfer,
29}
30
31impl Signer {
32 pub fn new(
34 raw: Option<&[u8]>,
35 code: Option<&str>,
36 transferable: Option<bool>,
37 ) -> Result<Self, MatterError> {
38 let code = code.unwrap_or(mtr_dex::ED25519_SEED);
40 let transferable = transferable.unwrap_or(true);
41
42 let raw_bytes = match raw {
44 Some(bytes) => bytes.to_vec(),
45 None => {
46 match code {
47 mtr_dex::ED25519_SEED => {
48 sodiumoxide::init().map_err(|_| {
49 MatterError::CryptoError("Sodium initialization failed".into())
50 })?;
51 let seed = randombytes::randombytes(ed25519::SEEDBYTES);
52 seed[..].to_vec()
53 }
54 mtr_dex::ECDSA_256R1_SEED => {
55 let mut seed = vec![0u8; 32]; OsRng.fill_bytes(&mut seed);
57 seed
58 }
59 mtr_dex::ECDSA_256K1_SEED => {
60 let mut seed = vec![0u8; 32]; OsRng.fill_bytes(&mut seed);
62 seed
63 }
64 _ => {
65 return Err(MatterError::UnexpectedCode(format!(
66 "Unsupported signer code: {}",
67 code
68 )))
69 }
70 }
71 }
72 };
73
74 let base = BaseMatter::new(Some(&raw_bytes), Some(code), None, None)?;
76
77 let verfer = match code {
79 mtr_dex::ED25519_SEED => {
80 let raw_bytes: [u8; 32] = raw_bytes
81 .try_into()
82 .map_err(|_| MatterError::CryptoError("Invalid Ed25519 seed".into()))?;
83
84 sodiumoxide::init()
85 .map_err(|_| MatterError::CryptoError("Sodium initialization failed".into()))?;
86 let seed = ed25519::Seed::from_slice(&raw_bytes)
87 .ok_or_else(|| MatterError::CryptoError("Invalid Ed25519 seed".to_string()))?;
88 let (pk, _) = ed25519::keypair_from_seed(&seed);
89 let verfer_code = if transferable {
90 mtr_dex::ED25519
91 } else {
92 mtr_dex::ED25519N
93 };
94 Verfer::new(Some(&pk[..]), Some(verfer_code))?
95 }
96 mtr_dex::ECDSA_256R1_SEED => {
97 let signing_key = SigningKey::from_slice(&raw_bytes)
98 .map_err(|_| MatterError::CryptoError("Invalid P256 seed".into()))?;
99 let verkey = signing_key
100 .verifying_key()
101 .to_encoded_point(true)
102 .as_bytes()
103 .to_vec();
104 let verfer_code = if transferable {
105 mtr_dex::ECDSA_256R1
106 } else {
107 mtr_dex::ECDSA_256R1N
108 };
109 Verfer::new(Some(&verkey), Some(verfer_code))?
110 }
111 mtr_dex::ECDSA_256K1_SEED => {
112 let raw_bytes: [u8; 32] = raw_bytes
113 .try_into()
114 .map_err(|_| MatterError::CryptoError("Invalid Secp256k1 seed".into()))?;
115
116 let secp = Secp256k1::new();
117 let secret_key = SecretKey::from_byte_array(&raw_bytes)
118 .map_err(|_| MatterError::CryptoError("Invalid Secp256k1 seed".into()))?;
119 let public_key = secp256k1::PublicKey::from_secret_key(&secp, &secret_key);
120 let verkey = public_key.serialize();
121 let verfer_code = if transferable {
122 mtr_dex::ECDSA_256K1
123 } else {
124 mtr_dex::ECDSA_256K1N
125 };
126 Verfer::new(Some(&verkey), Some(verfer_code))?
127 }
128 _ => {
129 return Err(MatterError::UnexpectedCode(format!(
130 "Unsupported signer code: {}",
131 code
132 )))
133 }
134 };
135
136 Ok(Self { base, verfer })
137 }
138
139 pub fn from_raw(raw: Option<&[u8]>) -> Result<Self, MatterError> {
141 Self::new(raw, None, None)
142 }
143
144 pub fn verfer(&self) -> &Verfer {
146 &self.verfer
147 }
148 pub fn set_verfer(&mut self, verfer: Verfer) {
149 self.verfer = verfer;
150 }
151
152 pub fn sign(
154 &self,
155 ser: &[u8],
156 index: Option<u32>,
157 only: Option<bool>,
158 ondex: Option<u32>,
159 ) -> Result<Sigmat, MatterError> {
160 let only = only.unwrap_or(false);
161
162 match self.base.code() {
163 mtr_dex::ED25519_SEED => self.sign_ed25519(ser, index, only, ondex),
164 mtr_dex::ECDSA_256R1_SEED => self.sign_secp256r1(ser, index, only, ondex),
165 mtr_dex::ECDSA_256K1_SEED => self.sign_secp256k1(ser, index, only, ondex),
166 _ => Err(MatterError::UnexpectedCode(format!(
167 "Unsupported signer code: {}",
168 self.base.code()
169 ))),
170 }
171 }
172
173 fn sign_ed25519(
175 &self,
176 ser: &[u8],
177 index: Option<u32>,
178 only: bool,
179 ondex: Option<u32>,
180 ) -> Result<Sigmat, MatterError> {
181 sodiumoxide::init()
182 .map_err(|_| MatterError::CryptoError("Sodium initialization failed".into()))?;
183
184 let seed = ed25519::Seed::from_slice(self.base.raw())
185 .ok_or_else(|| MatterError::CryptoError("Invalid Ed25519 seed".into()))?;
186 let (_, sk) = ed25519::keypair_from_seed(&seed);
187
188 let signed = ed25519::sign_detached(ser, &sk);
189 let sig = signed.as_ref();
190 let mut ondex = ondex;
191
192 match index {
193 None => {
194 let cigar = Cigar::new(
196 Some(sig),
197 Some(mtr_dex::ED25519_SIG),
198 None,
199 None,
200 Some(self.verfer.clone()),
201 )?;
202 Ok(Sigmat::NonIndexed(cigar))
203 }
204 Some(idx) => {
205 let code = if only {
207 ondex = None;
209 if idx <= 63 {
210 idr_dex::ED25519_CRT_SIG } else {
212 idr_dex::ED25519_BIG_CRT_SIG }
214 } else {
215 let ondex_val = ondex.unwrap_or(idx); if ondex_val == idx && idx <= 63 {
218 idr_dex::ED25519_SIG } else {
220 idr_dex::ED25519_BIG_SIG }
222 };
223
224 let siger = Siger::new(
225 Some(sig),
226 Some(code),
227 Some(idx),
228 ondex,
229 Some(self.verfer.clone()),
230 )?;
231
232 Ok(Sigmat::Indexed(siger))
233 }
234 }
235 }
236
237 fn sign_secp256r1(
239 &self,
240 ser: &[u8],
241 index: Option<u32>,
242 only: bool,
243 ondex: Option<u32>,
244 ) -> Result<Sigmat, MatterError> {
245 let signing_key = SigningKey::from_slice(self.base.raw())
246 .map_err(|_| MatterError::CryptoError("Invalid P256 seed".into()))?;
247
248 let (signature, _) = match signing_key.sign_recoverable(ser) {
250 Ok(sig) => sig,
251 Err(_) => {
252 return Err(MatterError::CryptoError(
253 "Invalid message for signing".into(),
254 ));
255 }
256 };
257
258 let r_bytes = signature.r().to_bytes();
260 let s_bytes = signature.s().to_bytes();
261
262 let mut sig = Vec::with_capacity(64);
264 sig.extend_from_slice(&r_bytes);
265 sig.extend_from_slice(&s_bytes);
266
267 match index {
268 None => {
269 let cigar = Cigar::new(
271 Some(&sig),
272 Some(mtr_dex::ECDSA_256R1_SIG),
273 None,
274 None,
275 Some(self.verfer.clone()),
276 )?;
277 Ok(Sigmat::NonIndexed(cigar))
278 }
279 Some(idx) => {
280 let code = if only {
282 if idx <= 63 {
284 idr_dex::ECDSA_256R1_CRT_SIG } else {
286 idr_dex::ECDSA_256R1_BIG_CRT_SIG }
288 } else {
289 let ondex_val = ondex.unwrap_or(idx); if ondex_val == idx && idx <= 63 {
292 idr_dex::ECDSA_256R1_SIG } else {
294 idr_dex::ECDSA_256R1_BIG_SIG }
296 };
297
298 let siger = Siger::new(
299 Some(&sig),
300 Some(code),
301 Some(idx),
302 ondex,
303 Some(self.verfer.clone()),
304 )?;
305
306 Ok(Sigmat::Indexed(siger))
307 }
308 }
309 }
310
311 fn sign_secp256k1(
313 &self,
314 ser: &[u8],
315 index: Option<u32>,
316 only: bool,
317 ondex: Option<u32>,
318 ) -> Result<Sigmat, MatterError> {
319 let secp = Secp256k1::new();
320 let secret_key = SecretKey::from_slice(self.base.raw())
321 .map_err(|_| MatterError::CryptoError("Invalid Secp256k1 seed".into()))?;
322
323 let mut hasher = Sha3_256::new();
325 hasher.update(ser);
326 let result = hasher.finalize();
327 let mut digest = [0u8; 32];
328 digest.copy_from_slice(&result);
329
330 let message = Message::from_digest(digest);
331
332 let signature = secp.sign_ecdsa(&message, &secret_key);
334
335 let sig_bytes = signature.serialize_compact();
337
338 match index {
339 None => {
340 let cigar = Cigar::new(
342 Some(&sig_bytes),
343 Some(mtr_dex::ECDSA_256K1_SIG),
344 None,
345 None,
346 Some(self.verfer.clone()),
347 )?;
348 Ok(Sigmat::NonIndexed(cigar))
349 }
350 Some(idx) => {
351 let code = if only {
353 if idx <= 63 {
355 idr_dex::ECDSA_256K1_CRT_SIG } else {
357 idr_dex::ECDSA_256K1_BIG_CRT_SIG }
359 } else {
360 let ondex_val = ondex.unwrap_or(idx); if ondex_val == idx && idx <= 63 {
363 idr_dex::ECDSA_256K1_SIG } else {
365 idr_dex::ECDSA_256K1_BIG_SIG }
367 };
368
369 let siger = Siger::new(
370 Some(&sig_bytes),
371 Some(code),
372 Some(idx),
373 ondex,
374 Some(self.verfer.clone()),
375 )?;
376
377 Ok(Sigmat::Indexed(siger))
378 }
379 }
380 }
381
382 pub fn from_qb64b_and_transferable(
383 data: &mut Vec<u8>,
384 strip: Option<bool>,
385 transferable: bool,
386 ) -> Result<Self, MatterError> {
387 let mut signer = Signer::from_qb64b(data, strip)?;
388 let verfer = match signer.code() {
390 mtr_dex::ED25519_SEED => {
391 let raw_bytes: [u8; 32] = signer
392 .raw()
393 .try_into()
394 .map_err(|_| MatterError::CryptoError("Invalid Ed25519 seed".into()))?;
395
396 sodiumoxide::init()
397 .map_err(|_| MatterError::CryptoError("Sodium initialization failed".into()))?;
398 let seed = ed25519::Seed::from_slice(&raw_bytes)
399 .ok_or_else(|| MatterError::CryptoError("Invalid Ed25519 seed".to_string()))?;
400 let (pk, _) = ed25519::keypair_from_seed(&seed);
401 let verfer_code = if transferable {
402 mtr_dex::ED25519
403 } else {
404 mtr_dex::ED25519N
405 };
406 Verfer::new(Some(&pk[..]), Some(verfer_code))?
407 }
408 mtr_dex::ECDSA_256R1_SEED => {
409 let signing_key = SigningKey::from_slice(&signer.raw())
410 .map_err(|_| MatterError::CryptoError("Invalid P256 seed".into()))?;
411 let verkey = signing_key
412 .verifying_key()
413 .to_encoded_point(true)
414 .as_bytes()
415 .to_vec();
416 let verfer_code = if transferable {
417 mtr_dex::ECDSA_256R1
418 } else {
419 mtr_dex::ECDSA_256R1N
420 };
421 Verfer::new(Some(&verkey), Some(verfer_code))?
422 }
423 mtr_dex::ECDSA_256K1_SEED => {
424 let raw_bytes: [u8; 32] = signer
425 .raw()
426 .try_into()
427 .map_err(|_| MatterError::CryptoError("Invalid Secp256k1 seed".into()))?;
428
429 let secp = Secp256k1::new();
430 let secret_key = SecretKey::from_byte_array(&raw_bytes)
431 .map_err(|_| MatterError::CryptoError("Invalid Secp256k1 seed".into()))?;
432 let public_key = secp256k1::PublicKey::from_secret_key(&secp, &secret_key);
433 let verkey = public_key.serialize();
434 let verfer_code = if transferable {
435 mtr_dex::ECDSA_256K1
436 } else {
437 mtr_dex::ECDSA_256K1N
438 };
439 Verfer::new(Some(&verkey), Some(verfer_code))?
440 }
441 _ => {
442 return Err(MatterError::UnexpectedCode(format!(
443 "Unsupported signer code: {}",
444 signer.code()
445 )))
446 }
447 };
448
449 signer.set_verfer(verfer);
450 Ok(signer)
451 }
452}
453
454impl Parsable for Signer {
455 fn from_qb64b(data: &mut Vec<u8>, strip: Option<bool>) -> Result<Self, MatterError> {
456 let base = BaseMatter::from_qb64b(data, strip)?;
457
458 let raw = base.raw();
460 let code = base.code();
461
462 Self::new(Some(raw), Some(code), None)
463 }
464
465 fn from_qb2(data: &mut Vec<u8>, strip: Option<bool>) -> Result<Self, MatterError> {
466 let base = BaseMatter::from_qb2(data, strip)?;
467
468 let raw = base.raw();
470 let code = base.code();
471
472 Self::new(Some(raw), Some(code), None)
473 }
474}
475
476impl Matter for Signer {
477 fn code(&self) -> &str {
478 self.base.code()
479 }
480 fn raw(&self) -> &[u8] {
481 self.base.raw()
482 }
483 fn qb64(&self) -> String {
484 self.base.qb64()
485 }
486 fn qb64b(&self) -> Vec<u8> {
487 self.base.qb64b()
488 }
489 fn qb2(&self) -> Vec<u8> {
490 self.base.qb2()
491 }
492 fn soft(&self) -> &str {
493 self.base.soft()
494 }
495 fn full_size(&self) -> usize {
496 self.base.full_size()
497 }
498 fn size(&self) -> usize {
499 self.base.size()
500 }
501 fn is_transferable(&self) -> bool {
502 self.base.is_transferable()
503 }
504 fn is_digestive(&self) -> bool {
505 self.base.is_digestive()
506 }
507 fn is_prefixive(&self) -> bool {
508 self.base.is_prefixive()
509 }
510 fn is_special(&self) -> bool {
511 self.base.is_special()
512 }
513 fn as_any(&self) -> &dyn Any {
514 self
515 }
516}
517
518#[cfg(test)]
519mod tests {
520 use super::*;
521 use crate::cesr::indexing::siger::Siger;
522 use crate::cesr::indexing::{raw_size, Indexer};
523 use crate::cesr::raw_size as mtr_raw_size;
524 use sodiumoxide::randombytes;
525
526 #[test]
527 fn test_signer_creation() {
528 let signer = Signer::new(None, None, None).unwrap();
530 assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
531
532 let verfer = signer.verfer();
534 assert_eq!(verfer.code(), mtr_dex::ED25519);
535
536 let signer = Signer::new(None, None, Some(false)).unwrap();
538 let verfer = signer.verfer();
539 assert_eq!(verfer.code(), mtr_dex::ED25519N);
540 }
541
542 #[test]
543 fn test_signing() {
544 let signer = Signer::new(None, None, None).unwrap();
546
547 let ser = b"test data";
549
550 let Sigmat::NonIndexed(signature) = signer.sign(ser, None, None, None).unwrap() else {
552 panic!("Invalid type")
553 };
554 assert_eq!(signature.code(), mtr_dex::ED25519_SIG);
555
556 let Sigmat::Indexed(signature) = signer.sign(ser, Some(0), None, None).unwrap() else {
558 panic!("Invalid type")
559 };
560 assert_eq!(signature.code(), idr_dex::ED25519_SIG);
561
562 let Sigmat::Indexed(signature) = signer.sign(ser, Some(100), None, None).unwrap() else {
564 panic!("Invalid type")
565 };
566 assert_eq!(signature.code(), idr_dex::ED25519_BIG_SIG);
567
568 let Sigmat::Indexed(signature) = signer.sign(ser, Some(0), Some(true), None).unwrap()
570 else {
571 panic!("Invalid type")
572 };
573 assert_eq!(signature.code(), idr_dex::ED25519_CRT_SIG);
574 }
575
576 #[test]
577 fn test_signer() -> Result<(), MatterError> {
578 let signer = Signer::new(None, None, None)?;
580 assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
581 assert_eq!(signer.raw().len(), mtr_raw_size(mtr_dex::ED25519_SEED)?);
582 assert_eq!(signer.verfer().code(), mtr_dex::ED25519);
583 assert_eq!(signer.verfer().raw().len(), mtr_raw_size(mtr_dex::ED25519)?);
584
585 let ser = b"abcdefghijklmnopqrstuvwxyz0123456789";
587
588 let Sigmat::NonIndexed(cigar) = signer.sign(ser, None, None, None)? else {
589 panic!("Invalid type")
590 };
591 assert_eq!(cigar.code(), mtr_dex::ED25519_SIG);
592 assert_eq!(cigar.raw().len(), mtr_raw_size(mtr_dex::ED25519_SIG)?);
593 let result = signer.verfer().verify(cigar.raw(), ser)?;
594 assert!(result);
595
596 let index = 0;
598 let Sigmat::Indexed(siger) = signer.sign(ser, Some(index), None, None)? else {
599 panic!("Invalid type")
600 };
601 let siger = siger.as_any().downcast_ref::<Siger>().unwrap();
602 assert_eq!(siger.code(), idr_dex::ED25519_SIG);
603 assert_eq!(siger.raw().len(), mtr_raw_size(mtr_dex::ED25519_SIG)?);
604 assert_eq!(siger.index(), index);
605 assert_eq!(siger.ondex(), Some(index));
606 let result = signer.verfer().verify(siger.raw(), ser)?;
607 assert!(result);
608
609 assert_eq!(cigar.raw(), siger.raw());
616
617 let result = Signer::new(None, Some(mtr_dex::ED25519N), None);
619 assert!(result.is_err());
620
621 let signer = Signer::new(None, None, Some(false))?;
623 assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
624 assert_eq!(signer.raw().len(), mtr_raw_size(mtr_dex::ED25519_SEED)?);
625 assert_eq!(signer.verfer().code(), mtr_dex::ED25519N);
626 assert_eq!(
627 signer.verfer().raw().len(),
628 mtr_raw_size(mtr_dex::ED25519N)?
629 );
630
631 let Sigmat::NonIndexed(cigar) = signer.sign(ser, None, None, None)? else {
632 panic!("Invalid type")
633 };
634 assert_eq!(cigar.code(), mtr_dex::ED25519_SIG);
635 assert_eq!(cigar.raw().len(), mtr_raw_size(mtr_dex::ED25519_SIG)?);
636 let result = signer.verfer().verify(cigar.raw(), ser)?;
637 assert!(result);
638
639 let Sigmat::Indexed(siger) = signer.sign(ser, Some(0), None, None)? else {
641 panic!("Invalid type")
642 };
643 assert_eq!(siger.code(), idr_dex::ED25519_SIG);
644 assert_eq!(siger.raw().len(), mtr_raw_size(mtr_dex::ED25519_SIG)?);
645 assert_eq!(siger.index(), index);
646 assert_eq!(siger.ondex(), Some(index));
647 let result = signer.verfer().verify(siger.raw(), ser)?;
648 assert!(result);
649
650 let invalid_ser: [&[u8]; 2] = [ser, b"ABCDEFG"];
652 let result = signer.verfer().verify(siger.raw(), &invalid_ser.concat())?;
653 assert!(!result);
654
655 sodiumoxide::init().unwrap();
657 let seed = randombytes::randombytes(32); let signer = Signer::new(Some(&seed), Some(mtr_dex::ED25519_SEED), None)?;
659 assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
660 assert_eq!(signer.raw().len(), mtr_raw_size(mtr_dex::ED25519_SEED)?);
661 assert_eq!(signer.raw(), seed);
662 assert_eq!(signer.verfer().code(), mtr_dex::ED25519);
663 assert_eq!(signer.verfer().raw().len(), mtr_raw_size(mtr_dex::ED25519)?);
664
665 let Sigmat::NonIndexed(cigar) = signer.sign(ser, None, None, None)? else {
666 panic!("Invalid type")
667 };
668 assert_eq!(cigar.code(), mtr_dex::ED25519_SIG);
669 assert_eq!(cigar.raw().len(), mtr_raw_size(mtr_dex::ED25519_SIG)?);
670 let result = signer.verfer().verify(cigar.raw(), ser)?;
671 assert!(result);
672
673 let index = 1;
675 let Sigmat::Indexed(siger) = signer.sign(ser, Some(index), None, None)? else {
676 panic!("Invalid type")
677 };
678 assert_eq!(siger.code(), idr_dex::ED25519_SIG);
679 assert_eq!(siger.raw().len(), mtr_raw_size(mtr_dex::ED25519_SIG)?);
680 assert_eq!(siger.index(), index);
681 assert_eq!(siger.ondex(), Some(index));
682 let result = signer.verfer().verify(siger.raw(), ser)?;
683 assert!(result);
684
685 assert_eq!(cigar.raw(), siger.raw());
687
688 let index = 1;
690 let ondex = 3;
691 let Sigmat::Indexed(siger) = signer.sign(ser, Some(index), None, Some(ondex))? else {
692 panic!("Invalid type")
693 };
694 assert_eq!(siger.code(), idr_dex::ED25519_BIG_SIG);
695 assert_eq!(siger.raw().len(), raw_size(idr_dex::ED25519_BIG_SIG)?);
696 assert_eq!(siger.index(), index);
697 assert_eq!(siger.ondex(), Some(ondex));
698 let result = signer.verfer().verify(siger.raw(), ser)?;
699 assert!(result);
700
701 let index = 67;
703 let Sigmat::Indexed(siger) = signer.sign(ser, Some(index), None, None)? else {
704 panic!("Invalid type")
705 };
706 assert_eq!(siger.code(), idr_dex::ED25519_BIG_SIG);
707 assert_eq!(siger.raw().len(), raw_size(idr_dex::ED25519_BIG_SIG)?);
708 assert_eq!(siger.index(), index);
709 assert_eq!(siger.ondex(), Some(index));
710 let result = signer.verfer().verify(siger.raw(), ser)?;
711 assert!(result);
712
713 let ondex = 67;
715 let Sigmat::Indexed(siger) = signer.sign(ser, Some(index), None, Some(ondex))? else {
716 panic!("Invalid type")
717 };
718 assert_eq!(siger.code(), idr_dex::ED25519_BIG_SIG);
719 assert_eq!(siger.raw().len(), raw_size(idr_dex::ED25519_BIG_SIG)?);
720 assert_eq!(siger.index(), index);
721 assert_eq!(siger.ondex(), Some(ondex));
722 let result = signer.verfer().verify(siger.raw(), ser)?;
723 assert!(result);
724
725 let index = 4;
727 let Sigmat::Indexed(siger) = signer.sign(ser, Some(index), Some(true), None)? else {
728 panic!("Invalid type")
729 };
730 assert_eq!(siger.code(), idr_dex::ED25519_CRT_SIG);
731 assert_eq!(siger.raw().len(), raw_size(idr_dex::ED25519_CRT_SIG)?);
732 assert_eq!(siger.index(), index);
733 assert_eq!(siger.ondex(), None);
734 let result = signer.verfer().verify(siger.raw(), ser)?;
735 assert!(result);
736
737 let Sigmat::Indexed(siger) = signer.sign(ser, Some(index), Some(true), Some(index + 2))?
739 else {
740 panic!("Invalid type")
741 };
742 assert_eq!(siger.code(), idr_dex::ED25519_CRT_SIG);
743 assert_eq!(siger.raw().len(), raw_size(idr_dex::ED25519_CRT_SIG)?);
744 assert_eq!(siger.index(), index);
745 assert_eq!(siger.ondex(), None);
746 let result = signer.verfer().verify(siger.raw(), ser)?;
747 assert!(result);
748
749 let index = 65;
751 let Sigmat::Indexed(siger) = signer.sign(ser, Some(index), Some(true), None)? else {
752 panic!("Invalid type")
753 };
754 assert_eq!(siger.code(), idr_dex::ED25519_BIG_CRT_SIG);
755 assert_eq!(siger.raw().len(), raw_size(idr_dex::ED25519_BIG_CRT_SIG)?);
756 assert_eq!(siger.index(), index);
757 assert_eq!(siger.ondex(), None);
758 let result = signer.verfer().verify(siger.raw(), ser)?;
759 assert!(result);
760
761 let Sigmat::Indexed(siger) = signer.sign(ser, Some(index), Some(true), Some(index + 2))?
763 else {
764 panic!("Invalid type")
765 };
766 assert_eq!(siger.code(), idr_dex::ED25519_BIG_CRT_SIG);
767 assert_eq!(siger.raw().len(), raw_size(idr_dex::ED25519_BIG_CRT_SIG)?);
768 assert_eq!(siger.index(), index);
769 assert_eq!(siger.ondex(), None);
770 let result = signer.verfer().verify(siger.raw(), ser)?;
771 assert!(result);
772
773 let result = Signer::new(Some(&seed), Some(mtr_dex::ED25519N), None);
775 assert!(result.is_err());
776
777 Ok(())
778 }
779
780 #[test]
781 fn test_secp256r1_signer() {
782 let signer = Signer::new(None, Some(mtr_dex::ECDSA_256R1_SEED), None).unwrap();
784 assert_eq!(signer.code(), mtr_dex::ECDSA_256R1_SEED);
785 assert_eq!(
786 signer.raw().len(),
787 mtr_raw_size(mtr_dex::ECDSA_256R1_SEED).unwrap()
788 );
789 assert_eq!(signer.verfer().code(), mtr_dex::ECDSA_256R1);
790 assert_eq!(
791 signer.verfer().raw().len(),
792 mtr_raw_size(mtr_dex::ECDSA_256R1).unwrap()
793 );
794
795 let ser = b"abcdefghijklmnopqrstuvwxyz0123456789";
797
798 let Sigmat::NonIndexed(cigar) = signer.sign(ser, None, None, None).unwrap() else {
799 panic!("Invalid type")
800 };
801 assert_eq!(cigar.code(), mtr_dex::ECDSA_256R1_SIG);
802 assert_eq!(
803 cigar.raw().len(),
804 mtr_raw_size(mtr_dex::ECDSA_256R1_SIG).unwrap()
805 );
806 let result = signer.verfer().verify(cigar.raw(), ser).unwrap();
807 assert!(result);
808
809 sodiumoxide::init().unwrap();
811 let seed = randombytes::randombytes(32);
812 let signer = Signer::new(Some(&seed), Some(mtr_dex::ECDSA_256R1_SEED), None).unwrap();
813 assert_eq!(signer.code(), mtr_dex::ECDSA_256R1_SEED);
814 assert_eq!(
815 signer.raw().len(),
816 mtr_raw_size(mtr_dex::ECDSA_256R1_SEED).unwrap()
817 );
818 assert_eq!(signer.raw(), seed);
819 assert_eq!(signer.verfer().code(), mtr_dex::ECDSA_256R1);
820 assert_eq!(
821 signer.verfer().raw().len(),
822 mtr_raw_size(mtr_dex::ECDSA_256R1).unwrap()
823 );
824
825 let seed = b"\x9f{\xa8\xa7\xa8C9\x96&\xfa\xb1\x99\xeb\xaa \xc4\x1bG\x11\xc4\xaeSAR\xc9\xbd\x04\x9d\x85)~\x93";
827 let signer = Signer::new(Some(seed), Some(mtr_dex::ECDSA_256R1_SEED), None).unwrap();
828 assert_eq!(signer.code(), mtr_dex::ECDSA_256R1_SEED);
829 assert_eq!(
830 signer.raw().len(),
831 mtr_raw_size(mtr_dex::ECDSA_256R1_SEED).unwrap()
832 );
833 assert_eq!(signer.raw(), seed);
834 assert_eq!(signer.verfer().code(), mtr_dex::ECDSA_256R1);
835 assert_eq!(
836 signer.verfer().raw().len(),
837 mtr_raw_size(mtr_dex::ECDSA_256R1).unwrap()
838 );
839 assert_eq!(
840 signer.qb64(),
841 "QJ97qKeoQzmWJvqxmeuqIMQbRxHErlNBUsm9BJ2FKX6T"
842 );
843 assert_eq!(
844 signer.verfer().qb64(),
845 "1AAJA3cK_P2CDlh-_EMFPvyqTPI1POkw-dr14DANx5JEXDCZ"
846 );
847
848 let ser = b"abc";
850 let seed = b"\x35\x86\xc9\xa0\x4d\x33\x67\x85\xd5\xe4\x6a\xda\x62\xf0\x54\xc5\xa5\xf4\x32\x3f\x46\xcb\x92\x23\x07\xe0\xe2\x79\xb7\xe5\xf5\x0a";
851 let verkey = b"\x03\x16\x99\xbc\xa0\x51\x8f\xa6\x6c\xb3\x5d\x6b\x0a\x92\xf6\x84\x96\x28\x7b\xb6\x64\xe8\xe8\x57\x69\x15\xb8\xea\x9a\x02\x06\x2a\xff";
852 let sig = b"\x8c\xfa\xb4\x40\x01\xd2\xab\x4a\xbc\xc5\x96\x8b\xa2\x65\x76\xcd\x51\x9d\x3b\x40\xc3\x35\x21\x73\x9a\x1b\xe8\x2f\xe1\x30\x28\xe1\x07\x90\x08\xa6\x42\xd7\x3f\x36\x8c\x96\x32\xff\x01\x64\x03\x18\x08\x85\xb8\xa4\x97\x76\xbe\x9c\xe4\xd7\xc5\xe7\x05\xda\x51\x23";
853
854 let signerqb64 = "QDWGyaBNM2eF1eRq2mLwVMWl9DI_RsuSIwfg4nm35fUK";
855 let verferqb64 = "1AAJAxaZvKBRj6Zss11rCpL2hJYoe7Zk6OhXaRW46poCBir_";
856 let cigarqb64 = "0ICM-rRAAdKrSrzFlouiZXbNUZ07QMM1IXOaG-gv4TAo4QeQCKZC1z82jJYy_wFkAxgIhbikl3a-nOTXxecF2lEj";
857
858 let signer = Signer::new(Some(seed), Some(mtr_dex::ECDSA_256R1_SEED), None).unwrap();
859 let Sigmat::NonIndexed(cigar) = signer.sign(ser, None, None, None).unwrap() else {
860 panic!("Invalid type")
861 };
862
863 assert_eq!(signer.code(), mtr_dex::ECDSA_256R1_SEED);
864 assert_eq!(
865 signer.raw().len(),
866 mtr_raw_size(mtr_dex::ECDSA_256R1_SEED).unwrap()
867 );
868 assert_eq!(signer.raw(), seed);
869 assert_eq!(signer.qb64(), signerqb64);
870
871 assert_eq!(signer.verfer().code(), mtr_dex::ECDSA_256R1);
872 assert_eq!(
873 signer.verfer().raw().len(),
874 mtr_raw_size(mtr_dex::ECDSA_256R1).unwrap()
875 );
876 assert_eq!(signer.verfer().raw(), verkey);
877 assert_eq!(signer.verfer().qb64(), verferqb64);
878
879 assert_eq!(cigar.code(), mtr_dex::ECDSA_256R1_SIG);
880 assert_eq!(
881 cigar.raw().len(),
882 mtr_raw_size(mtr_dex::ECDSA_256R1_SIG).unwrap()
883 );
884 assert!(signer.verfer().verify(cigar.raw(), ser).unwrap());
885 assert!(signer.verfer().verify(sig, ser).unwrap());
886
887 let cigar =
888 Cigar::new(Some(sig), Some(mtr_dex::ECDSA_256R1_SIG), None, None, None).unwrap();
889 assert_eq!(cigar.qb64(), cigarqb64);
890 }
891}