Skip to main content

libkeri/keri/app/keeping/
creators.rs

1use crate::cesr::signing::{Salter, Signer};
2use crate::cesr::{mtr_dex, Tiers};
3use crate::errors::MatterError;
4use crate::Matter;
5use std::fmt;
6use std::fmt::Debug;
7
8/// Algorithm options for key creation
9#[allow(dead_code)]
10#[derive(Debug, Clone, Copy, PartialEq)]
11pub enum Algos {
12    Randy,
13    Salty,
14}
15
16impl fmt::Display for Algos {
17    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
18        match self {
19            Algos::Randy => write!(f, "randy"),
20            Algos::Salty => write!(f, "salty"),
21        }
22    }
23}
24
25impl Algos {
26    pub fn from_str(s: &str) -> Result<Self, MatterError> {
27        match s.to_lowercase().as_str() {
28            "randy" => Ok(Algos::Randy),
29            "salty" => Ok(Algos::Salty),
30            _ => Err(MatterError::ValueError(format!(
31                "Unsupported creation algorithm = {}.",
32                s
33            ))),
34        }
35    }
36}
37
38/// Creator trait defines the interface for key pair creation
39pub trait Creator: Debug {
40    /// Create signers based on parameters
41    fn create(
42        &self,
43        codes: Option<Vec<&str>>,
44        count: Option<usize>,
45        code: Option<&str>,
46        pidx: Option<usize>,
47        ridx: Option<usize>,
48        kidx: Option<usize>,
49        transferable: Option<bool>,
50        temp: Option<bool>,
51    ) -> Vec<Signer>;
52
53    /// Get the salt value
54    fn salt(&self) -> String;
55
56    /// Get the stem value
57    fn stem(&self) -> String;
58
59    /// Get the tier value
60    fn tier(&self) -> Option<&Tiers>;
61}
62
63/// RandyCreator creates key pairs based on re-randomizing each seed algorithm
64#[derive(Debug)]
65pub struct RandyCreator {
66    // No fields required for base implementation
67}
68
69impl RandyCreator {
70    /// Create a new RandyCreator instance
71    pub fn new() -> Self {
72        RandyCreator {}
73    }
74}
75
76impl Creator for RandyCreator {
77    fn create(
78        &self,
79        codes: Option<Vec<&str>>,
80        count: Option<usize>,
81        code: Option<&str>,
82        _pidx: Option<usize>,
83        _ridx: Option<usize>,
84        _kidx: Option<usize>,
85        transferable: Option<bool>,
86        _temp: Option<bool>,
87    ) -> Vec<Signer> {
88        let count = count.unwrap_or(1);
89        let code = code.unwrap_or(mtr_dex::ED25519_SEED);
90        let transferable = transferable.unwrap_or(true);
91
92        let mut signers = Vec::new();
93
94        // If codes provided, use them, otherwise create 'count' signers with the same code
95        if let Some(code_list) = codes {
96            for &c in code_list.iter() {
97                signers.push(
98                    Signer::new(None, Some(c), Some(transferable))
99                        .expect("Failed to create signer"),
100                );
101            }
102        } else {
103            for _ in 0..count {
104                signers.push(
105                    Signer::new(None, Some(code), Some(transferable))
106                        .expect("Failed to create signer"),
107                );
108            }
109        }
110
111        signers
112    }
113
114    fn salt(&self) -> String {
115        String::new()
116    }
117
118    fn stem(&self) -> String {
119        String::new()
120    }
121
122    fn tier(&self) -> Option<&Tiers> {
123        None
124    }
125}
126
127/// SaltyCreator creates key pairs based on random salt plus path stretch algorithm
128#[derive(Debug)]
129pub struct SaltyCreator {
130    salter: Salter,
131    stem: String,
132}
133
134impl SaltyCreator {
135    /// Create a new SaltyCreator
136    pub fn new(
137        salt: Option<&str>,
138        stem: Option<&str>,
139        tier: Option<Tiers>,
140    ) -> Result<Self, MatterError> {
141        let salter = if let Some(s) = salt {
142            Salter::from_qb64_and_tier(s, tier)
143        } else {
144            Salter::new(None, None, tier)
145        }?;
146
147        let stem = stem.unwrap_or("").to_string();
148
149        Ok(SaltyCreator { salter, stem })
150    }
151}
152
153impl Creator for SaltyCreator {
154    fn create(
155        &self,
156        codes: Option<Vec<&str>>,
157        count: Option<usize>,
158        code: Option<&str>,
159        pidx: Option<usize>,
160        ridx: Option<usize>,
161        kidx: Option<usize>,
162        transferable: Option<bool>,
163        temp: Option<bool>,
164    ) -> Vec<Signer> {
165        let count = count.unwrap_or(1);
166        let code = code.unwrap_or(mtr_dex::ED25519_SEED);
167        let transferable = transferable.unwrap_or(true);
168
169        // Additional parameters with defaults
170        let pidx = pidx.unwrap_or(0);
171        let ridx = ridx.unwrap_or(0);
172        let kidx = kidx.unwrap_or(0);
173        let temp = temp.unwrap_or(false);
174
175        self.create_with_options(codes, count, code, pidx, ridx, kidx, transferable, temp)
176    }
177
178    fn salt(&self) -> String {
179        self.salter.qb64()
180    }
181
182    fn stem(&self) -> String {
183        self.stem.clone()
184    }
185
186    fn tier(&self) -> Option<&Tiers> {
187        Some(self.salter.tier())
188    }
189}
190
191impl SaltyCreator {
192    /// Create signers with additional options
193    pub fn create_with_options(
194        &self,
195        codes: Option<Vec<&str>>,
196        count: usize,
197        code: &str,
198        pidx: usize,
199        ridx: usize,
200        kidx: usize,
201        transferable: bool,
202        temp: bool,
203    ) -> Vec<Signer> {
204        let mut signers = Vec::new();
205
206        // Generate code list if not provided
207        let code_list = if let Some(codes) = codes {
208            codes
209        } else {
210            vec![code; count]
211        };
212
213        // Create stem from provided stem or pidx
214        let stem = if !self.stem.is_empty() {
215            self.stem.clone()
216        } else {
217            format!("{:x}", pidx)
218        };
219
220        // Create signers for each code
221        for (i, &code) in code_list.iter().enumerate() {
222            let path = format!("{}{:x}{:x}", stem, ridx, kidx + i);
223
224            // Get tier from salter
225            let tier_option = if *self.salter.tier() == Tiers::HIGH {
226                Some(&Tiers::HIGH)
227            } else if *self.salter.tier() == Tiers::MED {
228                Some(&Tiers::MED)
229            } else if *self.salter.tier() == Tiers::LOW {
230                Some(&Tiers::LOW)
231            } else {
232                None
233            };
234
235            match self
236                .salter
237                .signer(Some(code), Some(transferable), &path, tier_option, temp)
238            {
239                Ok(signer) => signers.push(signer),
240                Err(e) => {
241                    eprintln!("Error creating signer: {:?}", e);
242                    // Continue with next signer instead of failing completely
243                }
244            }
245        }
246
247        signers
248    }
249}
250
251// Default implementations
252impl Default for RandyCreator {
253    fn default() -> Self {
254        Self::new()
255    }
256}
257
258/// Factory for creating Creator instances based on algorithm choice
259#[derive(Debug)]
260pub struct Creatory {
261    algo: Algos,
262}
263
264impl Creatory {
265    /// Create a new Creatory with the specified algorithm
266    pub fn new(algo: Algos) -> Self {
267        Creatory { algo }
268    }
269
270    /// Create a Creator instance based on the chosen algorithm
271    pub fn make(
272        &self,
273        salt: Option<&str>,
274        stem: Option<&str>,
275        tier: Option<Tiers>,
276    ) -> Result<Box<dyn Creator>, MatterError> {
277        match self.algo {
278            Algos::Randy => Ok(Box::new(RandyCreator::new())),
279            Algos::Salty => {
280                let salty = SaltyCreator::new(salt, stem, tier)?;
281                Ok(Box::new(salty))
282            }
283        }
284    }
285}
286
287// Alternative implementation with builder pattern for more flexibility
288pub struct CreatoryBuilder {
289    algo: Algos,
290    salt: Option<String>,
291    stem: Option<String>,
292    tier: Option<Tiers>,
293}
294
295impl CreatoryBuilder {
296    pub fn new(algo: Algos) -> Self {
297        CreatoryBuilder {
298            algo,
299            salt: None,
300            stem: None,
301            tier: None,
302        }
303    }
304
305    pub fn with_salt(mut self, salt: &str) -> Self {
306        self.salt = Some(salt.to_string());
307        self
308    }
309
310    pub fn with_stem(mut self, stem: &str) -> Self {
311        self.stem = Some(stem.to_string());
312        self
313    }
314
315    pub fn with_tier(mut self, tier: Tiers) -> Self {
316        self.tier = Some(tier);
317        self
318    }
319
320    pub fn build(self) -> Result<Box<dyn Creator>, MatterError> {
321        match self.algo {
322            Algos::Randy => Ok(Box::new(RandyCreator::new())),
323            Algos::Salty => {
324                let salt_ref = self.salt.as_deref();
325                let stem_ref = self.stem.as_deref();
326                let tier = self.tier;
327
328                let salty = SaltyCreator::new(salt_ref, stem_ref, tier)?;
329                Ok(Box::new(salty))
330            }
331        }
332    }
333}
334
335// Default implementations
336impl Default for Creatory {
337    fn default() -> Self {
338        Self::new(Algos::Salty)
339    }
340}
341
342#[cfg(test)]
343mod tests {
344    use super::*;
345    use crate::cesr::non_trans_dex;
346    use crate::Matter;
347
348    #[test]
349    fn test_randy_creator() -> Result<(), MatterError> {
350        // Test RandyCreator basics
351        let creator = RandyCreator::new();
352
353        // Test interface properties
354        assert_eq!(creator.salt(), "");
355        assert_eq!(creator.stem(), "");
356        assert_eq!(creator.tier(), None);
357
358        // Test creating a single default signer
359        let signers = creator.create(None, None, None, None, None, None, None, None);
360        assert_eq!(signers.len(), 1);
361
362        let signer = &signers[0];
363        assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
364        assert_eq!(signer.verfer().code(), mtr_dex::ED25519);
365        assert!(!non_trans_dex::TUPLE.contains(&signer.verfer().code()));
366
367        // Test creating multiple signers that are non-transferable
368        let signers = creator.create(
369            None,
370            Some(2),
371            None,
372            None,
373            None,
374            None,
375            Some(false),
376            Some(false),
377        );
378        assert_eq!(signers.len(), 2);
379
380        for signer in &signers {
381            assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
382            assert_eq!(signer.verfer().code(), mtr_dex::ED25519N);
383            assert!(non_trans_dex::TUPLE.contains(&signer.verfer().code()));
384        }
385
386        // Test creating signers with specific codes
387        let codes = vec![mtr_dex::ED25519_SEED, mtr_dex::ED25519_SEED];
388        let signers = creator.create(Some(codes), None, None, None, None, None, None, None);
389        assert_eq!(signers.len(), 2);
390
391        for signer in &signers {
392            assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
393            assert_eq!(signer.verfer().code(), mtr_dex::ED25519);
394        }
395
396        Ok(())
397    }
398
399    #[test]
400    fn test_salty_creator() -> Result<(), MatterError> {
401        // Test SaltyCreator with default parameters
402        let creator = SaltyCreator::new(None, None, None)?;
403
404        // Check basic properties
405        assert!(!creator.salt().is_empty()); // Should have a random salt
406        assert_eq!(creator.stem(), "");
407        assert_eq!(creator.tier(), Some(&Tiers::LOW)); // Default tier
408
409        // Check salter properties
410        assert_eq!(creator.salter.code(), mtr_dex::SALT_128);
411
412        // Test creating a single default signer
413        let signers = creator.create(None, None, None, None, None, None, None, None);
414        assert_eq!(signers.len(), 1);
415
416        let signer = &signers[0];
417        assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
418        assert_eq!(signer.verfer().code(), mtr_dex::ED25519);
419        assert!(!non_trans_dex::TUPLE.contains(&signer.verfer().code()));
420
421        // Test creating multiple signers that are non-transferable
422        let signers = creator.create(
423            None,
424            Some(2),
425            None,
426            None,
427            None,
428            None,
429            Some(false),
430            Some(false),
431        );
432        assert_eq!(signers.len(), 2);
433        assert_eq!(signers.len(), 2);
434
435        for signer in &signers {
436            assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
437            assert_eq!(signer.verfer().code(), mtr_dex::ED25519N);
438            assert!(non_trans_dex::TUPLE.contains(&signer.verfer().code()));
439        }
440
441        // Test with specific salt
442        let raw = b"0123456789abcdef";
443        let salt = Salter::new(Some(raw), None, None)?.qb64();
444        assert_eq!(salt, "0AAwMTIzNDU2Nzg5YWJjZGVm");
445
446        let creator = SaltyCreator::new(Some(&salt), None, None)?;
447        assert_eq!(creator.salt(), salt);
448        assert_eq!(creator.salter.raw(), raw);
449
450        // Test creating a deterministic signer
451        let signers = creator.create(None, None, None, None, None, None, None, None);
452        assert_eq!(signers.len(), 1);
453
454        let signer = &signers[0];
455        assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
456        assert_eq!(
457            signer.qb64(),
458            "APMJe0lwOpwnX9PkvX1mh26vlzGYl6RWgWGclc8CAQJ9"
459        );
460        assert_eq!(signer.verfer().code(), mtr_dex::ED25519);
461        assert!(!non_trans_dex::TUPLE.contains(&signer.verfer().code()));
462        assert_eq!(
463            signer.verfer().qb64(),
464            "DMZy6qbgnKzvCE594tQ4SPs6pIECXTYQBH7BkC4hNY3E"
465        );
466
467        // Test creating a non-transferable temporary signer
468        let signers =
469            creator.create_with_options(None, 1, mtr_dex::ED25519_SEED, 0, 0, 0, false, true);
470        assert_eq!(signers.len(), 1);
471
472        let signer = &signers[0];
473        assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
474        assert_eq!(
475            signer.qb64(),
476            "AMGrAM0noxLpRteO9mxGT-yzYSrKFwJMuNI4KlmSk26e"
477        );
478        assert_eq!(signer.verfer().code(), mtr_dex::ED25519N);
479        assert!(non_trans_dex::TUPLE.contains(&signer.verfer().code()));
480        assert_eq!(
481            signer.verfer().qb64(),
482            "BFRtyHAjSuJaRX6TDPva35GN11VHAruaOXMc79ZYDKsT"
483        );
484
485        Ok(())
486    }
487
488    #[test]
489    fn test_creatory_factory() -> Result<(), MatterError> {
490        // Test Creatory with Randy algorithm
491        let creatory = Creatory::new(Algos::Randy);
492        let creator = creatory.make(None, None, None)?;
493
494        // Verify it created a RandyCreator
495        assert!(creator.salt().is_empty());
496        assert!(creator.stem().is_empty());
497        assert!(creator.tier().is_none());
498
499        let signers = creator.create(None, None, None, None, None, None, None, None);
500        assert_eq!(signers.len(), 1);
501        assert_eq!(signers[0].code(), mtr_dex::ED25519_SEED);
502
503        // Test Creatory with Salty algorithm and specific salt
504        let raw = b"0123456789abcdef";
505        let salt = Salter::new(Some(raw), None, None)?.qb64();
506
507        let creatory = Creatory::new(Algos::Salty);
508        let creator = creatory.make(Some(&salt), None, None)?;
509
510        // Verify it created a SaltyCreator with correct salt
511        assert_eq!(creator.salt(), salt);
512        assert_eq!(creator.stem(), "");
513        assert_eq!(creator.tier(), Some(&Tiers::LOW));
514
515        // Test the CreatoryBuilder pattern
516        let creator = CreatoryBuilder::new(Algos::Salty)
517            .with_salt(&salt)
518            .with_stem("test-stem")
519            .with_tier(Tiers::HIGH)
520            .build()?;
521
522        assert_eq!(creator.salt(), salt);
523        assert_eq!(creator.stem(), "test-stem");
524        assert_eq!(creator.tier(), Some(&Tiers::HIGH));
525
526        Ok(())
527    }
528
529    #[test]
530    fn test_algos_enum() {
531        // Test Algos enum conversion
532        assert_eq!(Algos::Randy.to_string(), "randy");
533        assert_eq!(Algos::Salty.to_string(), "salty");
534
535        assert_eq!(Algos::from_str("randy").unwrap(), Algos::Randy);
536        assert_eq!(Algos::from_str("RANDY").unwrap(), Algos::Randy);
537        assert_eq!(Algos::from_str("salty").unwrap(), Algos::Salty);
538        assert_eq!(Algos::from_str("SALTY").unwrap(), Algos::Salty);
539
540        // Test error case
541        let result = Algos::from_str("invalid");
542        assert!(result.is_err());
543    }
544
545    #[test]
546    fn test_error_handling() -> Result<(), MatterError> {
547        // Test creation with invalid parameters
548        let result = SaltyCreator::new(Some("invalid_salt"), None, None);
549        assert!(result.is_err());
550
551        Ok(())
552    }
553
554    #[test]
555    fn test_deterministic_creation() -> Result<(), MatterError> {
556        // Test that the same inputs produce the same outputs
557        let raw = b"0123456789abcdef";
558        let salt = Salter::new(Some(raw), None, None)?.qb64();
559
560        let creator1 = SaltyCreator::new(Some(&salt), Some("test"), None)?;
561        let creator2 = SaltyCreator::new(Some(&salt), Some("test"), None)?;
562
563        let signers1 = creator1.create(None, None, None, None, None, None, None, None);
564        let signers2 = creator2.create(None, None, None, None, None, None, None, None);
565
566        assert_eq!(signers1[0].qb64(), signers2[0].qb64());
567        assert_eq!(signers1[0].verfer().qb64(), signers2[0].verfer().qb64());
568
569        // Different paths should produce different keys
570        let creator3 = SaltyCreator::new(Some(&salt), Some("different"), None)?;
571        let signers3 = creator3.create(None, None, None, None, None, None, None, None);
572
573        assert_ne!(signers1[0].qb64(), signers3[0].qb64());
574        assert_ne!(signers1[0].verfer().qb64(), signers3[0].verfer().qb64());
575
576        Ok(())
577    }
578
579    #[test]
580    fn test_create_with_codes() -> Result<(), MatterError> {
581        // Test creating signers with specific codes
582        let creator = RandyCreator::new();
583
584        let codes = vec![mtr_dex::ED25519_SEED, mtr_dex::ED25519_SEED];
585        let signers = creator.create(Some(codes), None, None, None, None, None, None, None);
586
587        assert_eq!(signers.len(), 2);
588        assert_eq!(signers[0].code(), mtr_dex::ED25519_SEED);
589        assert_eq!(signers[1].code(), mtr_dex::ED25519_SEED);
590
591        Ok(())
592    }
593
594    #[test]
595    fn test_salty_creator_path_generation() -> Result<(), MatterError> {
596        // Test that different paths generate different keys
597        let raw = b"0123456789abcdef";
598        let salt = Salter::new(Some(raw), None, None)?.qb64();
599
600        let creator = SaltyCreator::new(Some(&salt), None, None)?;
601
602        // Different paths through pidx, ridx, kidx
603        let signers1 =
604            creator.create_with_options(None, 1, mtr_dex::ED25519_SEED, 0, 0, 0, true, false);
605        let signers2 =
606            creator.create_with_options(None, 1, mtr_dex::ED25519_SEED, 1, 0, 0, true, false);
607        let signers3 =
608            creator.create_with_options(None, 1, mtr_dex::ED25519_SEED, 0, 1, 0, true, false);
609        let signers4 =
610            creator.create_with_options(None, 1, mtr_dex::ED25519_SEED, 0, 0, 1, true, false);
611
612        // All should be different
613        let key1 = signers1[0].qb64();
614        let key2 = signers2[0].qb64();
615        let key3 = signers3[0].qb64();
616        let key4 = signers4[0].qb64();
617
618        assert_ne!(key1, key2);
619        assert_ne!(key1, key3);
620        assert_ne!(key1, key4);
621        assert_ne!(key2, key3);
622        assert_ne!(key2, key4);
623        assert_ne!(key3, key4);
624
625        Ok(())
626    }
627
628    #[test]
629    fn test_creator_defaults() -> Result<(), MatterError> {
630        // Test default values
631        let randy = RandyCreator::default();
632        assert_eq!(randy.salt(), "");
633
634        let creatory = Creatory::default();
635        let creator = creatory.make(None, None, None)?;
636
637        // Default should be SaltyCreator
638        assert!(!creator.salt().is_empty());
639        assert_eq!(creator.stem(), "");
640        assert_eq!(creator.tier(), Some(&Tiers::LOW));
641
642        Ok(())
643    }
644}