Skip to main content

libkeri/cesr/signing/
signer.rs

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/// Signer is a Matter subclass with method to create signature of serialization
18/// using:
19///     .raw as signing (private) key seed,
20///     .code as cipher suite for signing
21///     .verfer whose property .raw is public key for signing.
22///
23/// If not provided, .verfer is generated from private key seed using .code
24/// as cipher suite for creating key-pair.
25#[derive(Debug, Clone)]
26pub struct Signer {
27    base: BaseMatter,
28    pub verfer: Verfer,
29}
30
31impl Signer {
32    /// Create a new Signer with the given parameters
33    pub fn new(
34        raw: Option<&[u8]>,
35        code: Option<&str>,
36        transferable: Option<bool>,
37    ) -> Result<Self, MatterError> {
38        // Default code is Ed25519_Seed
39        let code = code.unwrap_or(mtr_dex::ED25519_SEED);
40        let transferable = transferable.unwrap_or(true);
41
42        // Handle the case when raw is None (generate random key)
43        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]; // P256 seeds are 32 bytes
56                        OsRng.fill_bytes(&mut seed);
57                        seed
58                    }
59                    mtr_dex::ECDSA_256K1_SEED => {
60                        let mut seed = vec![0u8; 32]; // Secp256k1 seeds are 32 bytes
61                        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        // Create base matter
75        let base = BaseMatter::new(Some(&raw_bytes), Some(code), None, None)?;
76
77        // Generate verfer based on the signing key
78        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    /// Create a Signer from raw bytes using default code
140    pub fn from_raw(raw: Option<&[u8]>) -> Result<Self, MatterError> {
141        Self::new(raw, None, None)
142    }
143
144    /// Get the verfer associated with this signer
145    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    /// Sign the serialization and return a signature (Cigar or Siger)
153    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    /// Sign using Ed25519
174    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                // Non-indexed signature (Cigar)
195                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                // Indexed signature (Siger)
206                let code = if only {
207                    // Only main index
208                    ondex = None;
209                    if idx <= 63 {
210                        idr_dex::ED25519_CRT_SIG // Small current only
211                    } else {
212                        idr_dex::ED25519_BIG_CRT_SIG // Big current only
213                    }
214                } else {
215                    // Both indices
216                    let ondex_val = ondex.unwrap_or(idx); // Default to same as index
217                    if ondex_val == idx && idx <= 63 {
218                        idr_dex::ED25519_SIG // Small both same
219                    } else {
220                        idr_dex::ED25519_BIG_SIG // Big both
221                    }
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    /// Sign using SECP256R1 (P-256)
238    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        // Sign the message
249        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        // Extract r and s components
259        let r_bytes = signature.r().to_bytes();
260        let s_bytes = signature.s().to_bytes();
261
262        // Combine r and s into a single signature
263        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                // Non-indexed signature (Cigar)
270                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                // Indexed signature (Siger)
281                let code = if only {
282                    // Only main index
283                    if idx <= 63 {
284                        idr_dex::ECDSA_256R1_CRT_SIG // Small current only
285                    } else {
286                        idr_dex::ECDSA_256R1_BIG_CRT_SIG // Big current only
287                    }
288                } else {
289                    // Both indices
290                    let ondex_val = ondex.unwrap_or(idx); // Default to same as index
291                    if ondex_val == idx && idx <= 63 {
292                        idr_dex::ECDSA_256R1_SIG // Small both same
293                    } else {
294                        idr_dex::ECDSA_256R1_BIG_SIG // Big both
295                    }
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    /// Sign using SECP256K1
312    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        // Create a message object from the serialization
324        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        // Sign the message
333        let signature = secp.sign_ecdsa(&message, &secret_key);
334
335        // Extract r and s components
336        let sig_bytes = signature.serialize_compact();
337
338        match index {
339            None => {
340                // Non-indexed signature (Cigar)
341                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                // Indexed signature (Siger)
352                let code = if only {
353                    // Only main index
354                    if idx <= 63 {
355                        idr_dex::ECDSA_256K1_CRT_SIG // Small current only
356                    } else {
357                        idr_dex::ECDSA_256K1_BIG_CRT_SIG // Big current only
358                    }
359                } else {
360                    // Both indices
361                    let ondex_val = ondex.unwrap_or(idx); // Default to same as index
362                    if ondex_val == idx && idx <= 63 {
363                        idr_dex::ECDSA_256K1_SIG // Small both same
364                    } else {
365                        idr_dex::ECDSA_256K1_BIG_SIG // Big both
366                    }
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        // Generate verfer based on the signing key
389        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        // Create a Signer from the base matter
459        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        // Create a Signer from the base matter
469        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        // Test creation with random seed
529        let signer = Signer::new(None, None, None).unwrap();
530        assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
531
532        // Test that verfer is created correctly
533        let verfer = signer.verfer();
534        assert_eq!(verfer.code(), mtr_dex::ED25519);
535
536        // Test non-transferable
537        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        // Create a signer
545        let signer = Signer::new(None, None, None).unwrap();
546
547        // Test data to sign
548        let ser = b"test data";
549
550        // Sign without index (Cigar)
551        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        // Sign with index (Siger)
557        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        // Sign with large index
563        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        // Sign with only=true
569        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        // Test default Signer instance (Ed25519)
579        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        // Create something to sign and verify
586        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        // Test with index
597        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        // Test verification with invalid data
610        // let invalid_ser: &[&[u8]] = [ser, b"ABCDEFG"].concat();
611        // let result = signer.verfer().verify(siger.raw(), &invalid_ser)?;
612        // assert!(!result);
613
614        // Raw values should be the same
615        assert_eq!(cigar.raw(), siger.raw());
616
617        // Test with invalid code (not a SEED type)
618        let result = Signer::new(None, Some(mtr_dex::ED25519N), None);
619        assert!(result.is_err());
620
621        // Test non-transferable
622        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        // Test with index for non-transferable
640        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        // Test verification with invalid data
651        let invalid_ser: [&[u8]; 2] = [ser, b"ABCDEFG"];
652        let result = signer.verfer().verify(siger.raw(), &invalid_ser.concat())?;
653        assert!(!result);
654
655        // Test non-default seed
656        sodiumoxide::init().unwrap();
657        let seed = randombytes::randombytes(32); // SEEDBYTES for Ed25519
658        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        // Test with different index
674        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        // Raw should match
686        assert_eq!(cigar.raw(), siger.raw());
687
688        // Test with different index and ondex - should use Big format
689        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        // Test Big index (same index, ondex)
702        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        // Test Big index with different ondex
714        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        // Test current only
726        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        // Test current only ignores ondex
738        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        // Test big current only
750        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        // Test big current only ignores ondex
762        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        // Test with invalid code
774        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        // Test Secp256r1, default seed
783        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        // Create something to sign and verify
796        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        // Test non-default seed
810        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        // Test hardcoded seed
826        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        // Test vectors from CERSide
849        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}