1use crate::cesr::diger::Diger;
2use crate::cesr::prefixer::Prefixer;
3use crate::cesr::signing::{Decrypter, Encrypter, Salter, Sigmat, Signer};
4use crate::cesr::tholder::{Tholder, TholderSith};
5use crate::cesr::verfer::Verfer;
6use crate::cesr::{mtr_dex, Parsable, Tiers};
7use crate::keri::app::keeping::creators::{Algos, Creatory};
8use crate::keri::app::keeping::keeper::{PrePrm, PreSit, PubLot, PubSet};
9use crate::keri::app::keeping::Keeper;
10use crate::keri::app::ri_key;
11use crate::keri::help::helping::nowiso8601;
12use crate::keri::KERIError;
13use crate::Matter;
14use chrono::Utc;
15use sodiumoxide::crypto::sign::SecretKey;
16use std::collections::VecDeque;
17
18pub struct Manager {
28 pub ks: Keeper,
30
31 pub encrypter: Option<Encrypter>,
33
34 pub decrypter: Option<Decrypter>,
36
37 pub inited: bool,
39
40 _seed: Vec<u8>,
44}
45
46impl Manager {
47 pub fn new(
57 ks: Keeper,
58 seed: Option<Vec<u8>>,
59 aeid: Option<Vec<u8>>,
60 pidx: Option<usize>,
61 algo: Option<Algos>,
62 salt: Option<Vec<u8>>,
63 tier: Option<Tiers>,
64 ) -> Result<Self, KERIError> {
65 let mut manager = Manager {
66 ks,
67 encrypter: None,
68 decrypter: None,
69 _seed: seed.unwrap_or_default(),
70 inited: false,
71 };
72
73 if manager.ks.opened() {
74 manager.setup(aeid, pidx, algo, salt, tier)?;
75 }
76
77 Ok(manager)
78 }
79
80 pub fn setup(
92 &mut self,
93 aeid: Option<Vec<u8>>,
94 pidx: Option<usize>,
95 algo: Option<Algos>,
96 salt: Option<Vec<u8>>,
97 tier: Option<Tiers>,
98 ) -> Result<(), KERIError> {
99 if !self.ks.opened() {
100 return Err(KERIError::ManagerError(
101 "Attempt to setup Manager closed keystore database .ks.".to_string(),
102 ));
103 }
104
105 let aeid = aeid.unwrap_or_default();
106 let pidx = pidx.unwrap_or(0);
107 let algo = algo.unwrap_or_else(|| Algos::Salty);
108
109 let salt = match salt {
110 Some(mut s) => {
111 if Salter::from_qb64b(&mut s, None)?.qb64b() != s {
113 return Err(KERIError::ManagerError(format!(
114 "Invalid qb64 for salt={:?}",
115 s
116 )));
117 }
118 s
119 }
120 None => Salter::new(None, None, None)?.qb64b(),
121 };
122
123 let tier = tier.unwrap_or_else(|| Tiers::LOW);
124
125 if self.pidx().is_none() {
127 self.set_pidx(pidx)?;
128 }
129
130 if self.algo().is_none() {
131 self.set_algo(algo)?;
132 }
133
134 if self.salt().is_none() {
135 self.set_salt(salt)?;
136 }
137
138 if self.tier().is_none() {
139 self.set_tier(tier)?;
140 }
141
142 if self.aeid().is_empty() {
144 self.update_aeid(aeid, self._seed.clone())?;
145 } else {
146 self.encrypter = Some(Encrypter::new(None, None, Some(&mut self.aeid()))?);
147
148 if self._seed.is_empty()
149 || !self.encrypter.as_ref().unwrap().verify_seed(&self._seed)?
150 {
151 return Err(KERIError::AuthError(format!(
152 "Last seed missing or provided last seed not associated with last aeid={:?}.",
153 self.aeid()
154 )));
155 }
156
157 self.decrypter = Some(Decrypter::new(Some(&self._seed), None, None)?);
158 }
159
160 self.inited = true;
161 Ok(())
162 }
163
164 pub fn ingest(
188 &mut self,
189 secrecies: Vec<Vec<String>>,
190 iridx: Option<usize>,
191 ncount: Option<usize>,
192 ncode: Option<&str>,
193 dcode: Option<&str>,
194 algo: Option<Algos>,
195 salt: Option<Vec<u8>>,
196 stem: Option<String>,
197 tier: Option<Tiers>,
198 rooted: Option<bool>,
199 transferable: Option<bool>,
200 temp: Option<bool>,
201 ) -> Result<(String, Vec<Vec<Verfer>>), KERIError> {
202 let iridx = iridx.unwrap_or(0);
203 let ncount = ncount.unwrap_or(1);
204 let ncode = ncode.unwrap_or(mtr_dex::ED25519_SEED);
205 let _dcode = dcode.unwrap_or(mtr_dex::BLAKE3_256);
206 let algo = algo.unwrap_or(Algos::Salty);
207 let rooted = rooted.unwrap_or(true);
208 let transferable = transferable.unwrap_or(true);
209 let temp = temp.unwrap_or(false);
210
211 if iridx > secrecies.len() {
212 return Err(KERIError::ValueError(format!(
213 "Initial ridx={} beyond last secrecy.",
214 iridx
215 )));
216 }
217
218 let salt = if rooted && salt.is_none() {
220 self.salt().unwrap_or_else(|| {
221 Salter::new(None, None, None).unwrap().qb64b()
223 })
224 } else {
225 salt.unwrap_or_else(|| {
226 self.salt().unwrap_or_else(|| {
227 Salter::new(None, None, None).unwrap().qb64b()
229 })
230 })
231 };
232
233 let tier = if rooted && tier.is_none() {
234 self.tier().unwrap_or(Tiers::LOW) } else {
236 tier.unwrap_or_else(|| {
237 self.tier().unwrap_or(Tiers::LOW) })
239 };
240
241 let pidx = self.pidx().unwrap_or(0);
242
243 let creator = Creatory::new(algo);
245 let creator_instance = creator.make(
246 Some(&String::from_utf8_lossy(&salt)),
247 stem.as_deref(),
248 Some(tier.clone()),
249 )?;
250
251 let mut ipre = String::new();
252 let mut pubs = Vec::new();
253 let mut ridx = 0;
254 let mut kidx = 0;
255
256 let mut verferies: Vec<Vec<Verfer>> = Vec::new(); let mut first = true;
258 let mut secrecies = VecDeque::from(secrecies);
259
260 while let Some(csecrets) = secrecies.pop_front() {
261 let mut csigners = Vec::new();
263 for secret in &csecrets {
264 let signer = Signer::new(
265 Some(&base64::decode(secret).map_err(|e| {
266 KERIError::ValueError(format!("Invalid base64 secret: {}", e))
267 })?),
268 None, Some(transferable),
270 )?;
271 csigners.push(signer);
272 }
273
274 let csize = csigners.len();
275 verferies.push(csigners.iter().map(|s| s.verfer.clone()).collect());
276
277 if first {
278 let pp = PrePrm {
280 pidx,
281 algo: format!("{:?}", algo).to_lowercase(),
282 salt: if let Some(ref encrypter) = self.encrypter {
283 encrypter.encrypt(Some(&salt), None, None)?.qb64()
284 } else {
285 String::from_utf8_lossy(&salt).to_string()
286 },
287 stem: stem.clone().unwrap_or_default(),
288 tier: format!("{:?}", tier).to_lowercase(),
289 };
290
291 let pre = csigners[0].verfer.qb64b();
292 ipre = csigners[0].verfer.qb64();
293
294 let mut pre_copy = pre.clone();
295 let prefixer = Prefixer::from_qb64b(&mut pre_copy, None)?;
296
297 if !self.ks.pres.put(&[&pre], &prefixer)? {
298 return Err(KERIError::ValueError(format!(
299 "Already incepted pre={}.",
300 String::from_utf8_lossy(&pre)
301 )));
302 }
303
304 if !self.ks.prms.put(&[&pre], &pp)? {
305 return Err(KERIError::ValueError(format!(
306 "Already incepted prm for pre={}.",
307 String::from_utf8_lossy(&pre)
308 )));
309 }
310
311 self.set_pidx(pidx + 1)?; first = false;
313 }
314
315 let pre = csigners[0].verfer.qb64b();
317 for signer in &csigners {
318 self.ks
319 .pris
320 .put(&[&signer.verfer.qb64b()], signer, self.encrypter.clone())?;
321 }
322
323 pubs = csigners.iter().map(|s| s.verfer.qb64()).collect();
324 let pub_set = PubSet { pubs: pubs.clone() };
325 self.ks.pubs.put(&[&ri_key(&pre, ridx)], &pub_set)?;
326
327 let dt = nowiso8601();
328 if ridx == iridx.saturating_sub(1).max(0) {
329 let old = if iridx == 0 {
331 Some(PubLot::default()) } else {
333 let osith = format!("{:x}", (csize / 2).max(1));
334 let _ost =
335 Tholder::new(None, None, Some(TholderSith::HexString(osith)))?.sith();
336 Some(PubLot {
337 pubs: pubs.clone(),
338 ridx,
339 kidx,
340 dt: dt.clone(),
341 })
342 };
343
344 let ps = PreSit {
345 old,
346 new: PubLot::default(), nxt: PubLot::default(),
348 };
349
350 if !self.ks.sits.pin(&[&pre], &ps)? {
351 return Err(KERIError::ValueError(format!(
352 "Problem updating pubsit db for pre={}.",
353 String::from_utf8_lossy(&pre)
354 )));
355 }
356 }
357
358 if ridx == iridx {
359 let mut ps = self.ks.sits.get(&[&pre])?.ok_or_else(|| {
361 KERIError::ValueError(format!(
362 "Attempt to rotate nonexistent pre={}.",
363 String::from_utf8_lossy(&pre)
364 ))
365 })?;
366
367 let new = PubLot {
368 pubs: pubs.clone(),
369 ridx,
370 kidx,
371 dt: dt.clone(),
372 };
373 ps.new = new;
374
375 if !self.ks.sits.pin(&[&pre], &ps)? {
376 return Err(KERIError::ValueError(format!(
377 "Problem updating pubsit db for pre={}.",
378 String::from_utf8_lossy(&pre)
379 )));
380 }
381 }
382
383 if ridx == iridx + 1 {
384 let mut ps = self.ks.sits.get(&[&pre])?.ok_or_else(|| {
386 KERIError::ValueError(format!(
387 "Attempt to rotate nonexistent pre={}.",
388 String::from_utf8_lossy(&pre)
389 ))
390 })?;
391
392 let nxt = PubLot {
393 pubs: pubs.clone(),
394 ridx,
395 kidx,
396 dt: dt.clone(),
397 };
398 ps.nxt = nxt;
399
400 if !self.ks.sits.pin(&[&pre], &ps)? {
401 return Err(KERIError::ValueError(format!(
402 "Problem updating pubsit db for pre={}.",
403 String::from_utf8_lossy(&pre)
404 )));
405 }
406 }
407
408 ridx += 1; kidx += csize; }
411
412 let nsigners = creator_instance.create(
414 None,
415 Some(ncount),
416 Some(ncode),
417 Some(pidx),
418 Some(ridx),
419 Some(kidx),
420 Some(transferable),
421 Some(temp),
422 );
423
424 let pre = if !verferies.is_empty() && !verferies[0].is_empty() {
426 verferies[0][0].qb64b()
427 } else {
428 return Err(KERIError::ValueError(
429 "No signers were ingested".to_string(),
430 ));
431 };
432
433 for signer in &nsigners {
435 self.ks
436 .pris
437 .put(&[&signer.verfer.qb64b()], signer, self.encrypter.clone())?;
438 }
439
440 pubs = nsigners.iter().map(|s| s.verfer.qb64()).collect();
441 let pub_set = PubSet { pubs: pubs.clone() };
442 self.ks.pubs.put(&[&ri_key(&pre, ridx)], &pub_set)?;
443
444 if ridx == iridx + 1 {
445 let dt = nowiso8601();
447 let mut ps = self.ks.sits.get(&[&pre])?.ok_or_else(|| {
448 KERIError::ValueError(format!(
449 "Attempt to rotate nonexistent pre={}.",
450 String::from_utf8_lossy(&pre)
451 ))
452 })?;
453
454 let nxt = PubLot {
455 pubs: pubs.clone(),
456 ridx,
457 kidx,
458 dt,
459 };
460 ps.nxt = nxt;
461
462 if !self.ks.sits.pin(&[&pre], &ps)? {
463 return Err(KERIError::ValueError(format!(
464 "Problem updating pubsit db for pre={}.",
465 String::from_utf8_lossy(&pre)
466 )));
467 }
468 }
469
470 Ok((ipre, verferies))
471 }
472
473 pub fn replay(
474 &mut self,
475 pre: &[u8],
476 dcode: Option<&str>,
477 advance: Option<bool>,
478 erase: Option<bool>,
479 ) -> Result<(Vec<Verfer>, Vec<Diger>), KERIError> {
480 let dcode = dcode.unwrap_or(mtr_dex::BLAKE3_256);
481 let advance = advance.unwrap_or(true);
482 let erase = erase.unwrap_or(true);
483
484 let pp = self.ks.prms.get(&[pre])?.ok_or_else(|| {
486 KERIError::ValueError(format!(
487 "Attempt to replay nonexistent pre={}.",
488 String::from_utf8_lossy(pre)
489 ))
490 })?;
491
492 let mut ps = self.ks.sits.get(&[pre])?.ok_or_else(|| {
494 KERIError::ValueError(format!(
495 "Attempt to replay nonexistent pre={}.",
496 String::from_utf8_lossy(pre)
497 ))
498 })?;
499
500 let old_keys_to_erase = if advance {
502 let old_keys = ps.old.clone();
504
505 ps.old = Some(ps.new.clone()); ps.new = ps.nxt.clone(); let ridx = ps.new.ridx;
508 let kidx = ps.new.kidx;
509 let csize = ps.new.pubs.len();
510
511 let pubset = self
516 .ks
517 .pubs
518 .get(&[&ri_key(pre, ridx + 1)])?
519 .ok_or_else(|| {
520 KERIError::IndexError(format!(
521 "Invalid replay attempt of pre={} at ridx={}.",
522 String::from_utf8_lossy(pre),
523 ridx
524 ))
525 })?;
526
527 let pubs = pubset.pubs.clone(); let dt = nowiso8601();
529 let nxt = PubLot {
530 pubs,
531 ridx: ridx + 1,
532 kidx: kidx + csize,
533 dt,
534 };
535 ps.nxt = nxt;
536
537 old_keys
539 } else {
540 None
541 };
542
543 let mut verfers = Vec::new(); for pub_key in &ps.new.pubs {
545 if !self._seed.is_empty() && self.decrypter.is_none() {
546 return Err(KERIError::DecryptError(
547 "Unauthorized decryption attempt. Aeid but no decrypter.".to_string(),
548 ));
549 }
550
551 let signer = self
552 .ks
553 .pris
554 .get(&[pub_key.as_bytes()], self.decrypter.clone())?
555 .ok_or_else(|| {
556 KERIError::ValueError(format!("Missing prikey in db for pubkey={}", pub_key))
557 })?;
558
559 verfers.push(signer.verfer);
560 }
561
562 let mut digers = Vec::new();
564 for pub_key in &ps.nxt.pubs {
565 let diger = Diger::from_ser(pub_key.as_bytes(), Some(dcode))?;
566 digers.push(diger);
567 }
568
569 if advance {
570 if !self.ks.sits.pin(&[pre], &ps)? {
571 return Err(KERIError::ValueError(format!(
572 "Problem updating pubsit db for pre={}.",
573 String::from_utf8_lossy(pre)
574 )));
575 }
576
577 if erase {
579 if let Some(old) = old_keys_to_erase {
580 for pub_key in &old.pubs {
581 self.ks.pris.rem(&[pub_key.as_bytes()])?;
582 }
583 }
584 }
585 }
586
587 Ok((verfers, digers))
588 }
589
590 pub fn update_aeid(&mut self, aeid: Vec<u8>, seed: Vec<u8>) -> Result<(), KERIError> {
602 let current_aeid = self.aeid();
603
604 if !current_aeid.is_empty() {
606 if self._seed.is_empty()
607 || !self
608 .encrypter
609 .as_ref()
610 .ok_or_else(|| {
611 KERIError::AuthError("Current encrypter is missing".to_string())
612 })?
613 .verify_seed(&self._seed)?
614 {
615 return Err(KERIError::AuthError(format!(
616 "Last seed missing or provided last seed not associated with last aeid={:?}.",
617 current_aeid
618 )));
619 }
620 }
621
622 if !aeid.is_empty() {
624 if aeid != current_aeid {
625 let new_encrypter = Encrypter::new(None, None, Some(&aeid.clone()))?;
627
628 if seed.is_empty() || !new_encrypter.verify_seed(&seed)? {
630 return Err(KERIError::AuthError(format!(
631 "Seed missing or provided seed not associated with provided aeid={:?}.",
632 aeid
633 )));
634 }
635
636 self.encrypter = Some(new_encrypter);
637 }
638 } else {
639 self.encrypter = None;
641 }
642
643 if let Some(salt) = self.salt() {
647 self.set_salt(salt)?;
649 }
650
651 if let Some(decrypter) = &self.decrypter {
653 let empty: [&[u8]; 0] = [];
655 for (keys, mut data) in self
656 .ks
657 .prms
658 .get_item_iter(&empty)
659 .map_err(|e| KERIError::ManagerError(format!("Failed to update aeid: {}", e)))?
660 {
661 if !data.salt.is_empty() {
662 let salter_any = decrypter.decrypt(
664 None,
665 Some(&data.salt),
666 None,
667 Some(false),
668 Some(false),
669 )?;
670 let salter = salter_any.downcast_ref::<Salter>().ok_or_else(|| {
671 KERIError::ValueError("Failed to downcast to Salter".to_string())
672 })?;
673
674 if let Some(encrypter) = &self.encrypter {
676 let encrypted = encrypter.encrypt(None, Some(salter), None)?;
677 data.salt = encrypted.qb64();
678 } else {
679 data.salt = salter.qb64();
680 }
681
682 self.ks.prms.pin(&keys, &data).map_err(|e| {
684 KERIError::ManagerError(format!("Failed to update aeid: {}", e))
685 })?;
686 }
687 }
688
689 let empty: [&[u8]; 0] = [];
692 for (keys, signer) in self
693 .ks
694 .pris
695 .get_item_iter(&empty, false, Some(decrypter.clone()))
696 .map_err(|e| KERIError::ManagerError(format!("Failed to update aeid: {}", e)))?
697 {
698 self.ks
700 .pris
701 .pin(&keys, &signer, self.encrypter.clone())
702 .map_err(|e| {
703 KERIError::ManagerError(format!("Failed to update aeid: {}", e))
704 })?;
705 }
706 }
707
708 self.ks
710 .gbls
711 .pin(&["aeid"], &aeid)
712 .map_err(|e| KERIError::ManagerError(format!("Failed to update aeid: {}", e)))?;
713
714 self._seed = seed.clone();
716
717 if !seed.is_empty() {
719 self.decrypter = Some(Decrypter::new(None, None, Some(&seed))?);
720 } else {
721 self.decrypter = None;
722 }
723
724 Ok(())
725 }
726
727 pub fn aeid(&self) -> Vec<u8> {
732 match self.ks.gbls.get(&["aeid"]) {
733 Ok(Some(bytes)) => bytes,
734 _ => Vec::new(),
735 }
736 }
737
738 pub fn pidx(&self) -> Option<usize> {
743 match self.ks.gbls.get(&["pidx"]) {
744 Ok(Some(bytes)) => {
745 let s = String::from_utf8(bytes).unwrap_or_default();
746 s.parse::<usize>().ok()
747 }
748 _ => None,
749 }
750 }
751
752 pub fn set_pidx(&self, value: usize) -> Result<(), KERIError> {
760 self.ks
761 .gbls
762 .pin(&["pidx"], &value.to_string().as_bytes())
763 .map_err(|e| KERIError::ManagerError(format!("Failed to set pidx: {}", e)))?;
764 Ok(())
765 }
766
767 pub fn algo(&self) -> Option<String> {
772 match self.ks.gbls.get(&["algo"]) {
773 Ok(Some(bytes)) => Some(String::from_utf8(bytes).unwrap_or_default()),
774 _ => None,
775 }
776 }
777
778 pub fn set_algo(&self, value: Algos) -> Result<(), KERIError> {
786 self.ks
787 .gbls
788 .pin(&["algo"], &value.to_string().as_bytes())
789 .map_err(|e| KERIError::ManagerError(format!("Failed to set algo: {}", e)))?;
790 Ok(())
791 }
792
793 pub fn salt(&self) -> Option<Vec<u8>> {
798 match self.ks.gbls.get(&["salt"]) {
799 Ok(Some(bytes)) => match self.decrypter {
800 Some(_) => {
801 let st = String::from_utf8(bytes);
802 let salter = self
803 .decrypter
804 .clone()?
805 .decrypt(None, Some(st.unwrap().as_str()), None, None, None)
806 .unwrap();
807 let salter = salter.downcast_ref::<Salter>().unwrap();
808 Some(salter.qb64b())
809 }
810 None => Some(bytes),
811 },
812 _ => None,
813 }
814 }
815
816 pub fn set_salt(&self, value: Vec<u8>) -> Result<(), KERIError> {
824 if let Some(encrypter) = &self.encrypter {
825 let encrypted_salt =
827 encrypter.encrypt(Some(&value), None, Some(mtr_dex::X25519_CIPHER_SALT))?;
828 self.ks
829 .gbls
830 .pin(&["salt"], &encrypted_salt.qb64b())
831 .map_err(|e| KERIError::ManagerError(format!("Failed to set salt: {}", e)))?;
832 } else {
833 self.ks
834 .gbls
835 .pin(&["salt"], &value)
836 .map_err(|e| KERIError::ManagerError(format!("Failed to set salt: {}", e)))?;
837 }
838
839 Ok(())
840 }
841
842 pub fn tier(&self) -> Option<Tiers> {
847 match self.ks.gbls.get(&["tier"]) {
848 Ok(Some(bytes)) => Some(Tiers::from(
849 String::from_utf8(bytes).unwrap_or_default().as_str(),
850 )),
851 _ => None,
852 }
853 }
854
855 pub fn set_tier(&self, value: Tiers) -> Result<(), KERIError> {
863 self.ks
864 .gbls
865 .put(&["tier"], &value.to_string().as_bytes())
866 .map_err(|e| KERIError::ManagerError(format!("Failed to set tier: {}", e)))?;
867 Ok(())
868 }
869
870 pub fn seed(&self) -> &Vec<u8> {
875 &self._seed
876 }
877
878 pub fn incept(
901 &mut self,
902 icodes: Option<Vec<&str>>,
903 icount: Option<usize>,
904 icode: Option<&str>,
905 ncodes: Option<Vec<&str>>,
906 ncount: Option<usize>,
907 ncode: Option<&str>,
908 dcode: Option<String>,
909 algo: Option<Algos>,
910 salt: Option<Vec<u8>>,
911 stem: Option<&str>,
912 tier: Option<Tiers>,
913 rooted: Option<bool>,
914 transferable: Option<bool>,
915 temp: Option<bool>,
916 ) -> Result<(Vec<Verfer>, Vec<Diger>), KERIError> {
917 let rooted = rooted.unwrap_or(true);
919 let transferable = transferable.unwrap_or(true);
920 let temp = temp.unwrap_or(false);
921 let icount = icount.unwrap_or(1);
922 let ncount = ncount.unwrap_or(1);
923 let icode = icode.unwrap_or_else(|| mtr_dex::ED25519_SEED);
924 let ncode = ncode.unwrap_or_else(|| mtr_dex::ED25519_SEED);
925 let _dcode = dcode.unwrap_or_else(|| mtr_dex::BLAKE3_256.to_string());
926
927 let algo = if rooted && algo.is_none() {
929 Algos::from_str(&self.algo().ok_or_else(|| {
931 KERIError::ValueError("Root algorithm not found in database".to_string())
932 })?)?
933 } else {
934 algo.unwrap_or(Algos::Salty)
935 };
936
937 let salt = if rooted && salt.is_none() {
938 self.salt().ok_or_else(|| {
940 KERIError::ValueError("Root salt not found in database".to_string())
941 })?
942 } else {
943 salt.unwrap_or_else(|| Vec::new())
944 };
945
946 let tier = if rooted && tier.is_none() {
947 &self.tier()
949 } else {
950 &Some(tier.unwrap_or(Tiers::LOW))
951 };
952
953 let pidx = self.pidx().ok_or_else(|| {
955 KERIError::ValueError("Prefix index not found in database".to_string())
956 })?;
957 let ridx = 0; let kidx = 0; let creator = Creatory::new(algo).make(
962 Some(String::from_utf8(salt).unwrap().as_str()),
963 stem.clone(),
964 tier.clone(),
965 )?;
966
967 let icodes = if let Some(ic) = icodes {
969 ic
970 } else {
971 (0..icount).map(|_| icode).collect()
973 };
974
975 let icode_count = icodes.len();
976 let isigners = creator.create(
977 Some(icodes),
978 None,
979 None,
980 Some(pidx),
981 Some(ridx),
982 Some(kidx),
983 Some(transferable),
984 Some(temp),
985 );
986
987 let verfers: Vec<Verfer> = isigners.iter().map(|s| s.verfer.clone()).collect();
988
989 let ncodes = if let Some(nc) = ncodes {
991 nc
992 } else {
993 (0..ncount).map(|_| ncode).collect()
995 };
996
997 let nsigners = creator.create(
998 Some(ncodes),
999 Some(0), None,
1001 Some(pidx),
1002 Some(ridx + 1),
1003 Some(kidx + icode_count),
1004 Some(transferable),
1005 Some(temp),
1006 );
1007
1008 let digers: Vec<Diger> = nsigners
1010 .iter()
1011 .map(|signer| -> Result<Diger, KERIError> {
1012 Diger::from_ser(&mut signer.verfer.qb64b(), None)
1013 .map_err(|e| KERIError::MatterError(e.to_string()))
1014 })
1015 .collect::<Result<Vec<Diger>, KERIError>>()?;
1016
1017 let tier_str = match creator.tier() {
1018 None => "",
1019 Some(tier) => &tier.to_string(),
1020 };
1021 let mut pp = PrePrm {
1023 pidx,
1024 algo: algo.to_string(),
1025 stem: creator.stem().clone(),
1026 tier: tier_str.to_string(),
1027 salt: String::new(),
1028 };
1029
1030 if !creator.salt().is_empty() {
1031 if let Some(encrypter) = &self.encrypter {
1032 let cipher = encrypter.encrypt(
1034 Some(&creator.salt().as_bytes().to_vec()),
1035 None,
1036 Some(mtr_dex::X25519_CIPHER_SALT),
1037 )?;
1038 pp.salt = cipher.qb64();
1039 } else {
1040 pp.salt = String::from_utf8_lossy(&creator.salt().as_bytes().to_vec()).to_string();
1042 }
1043 }
1044
1045 let dt = Utc::now().format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string();
1048
1049 let ps = PreSit {
1051 old: None,
1052 new: PubLot {
1053 pubs: verfers.iter().map(|v| v.qb64()).collect(),
1054 ridx,
1055 kidx,
1056 dt: dt.clone(),
1057 },
1058 nxt: PubLot {
1059 pubs: nsigners.iter().map(|s| s.verfer.qb64()).collect(),
1060 ridx: ridx + 1,
1061 kidx: kidx + icode_count,
1062 dt,
1063 },
1064 };
1065
1066 let pre = verfers[0].qb64b();
1068
1069 let pre_exists = self.ks.pres.get(&[&pre])?;
1071 if pre_exists.is_some() {
1072 return Err(KERIError::ValueError(format!(
1073 "Already incepted pre={}.",
1074 String::from_utf8_lossy(&pre)
1075 )));
1076 }
1077
1078 let prefixer = Prefixer::from_qb64b(&mut pre.clone(), None)?;
1080 self.ks
1081 .pres
1082 .put(&[&pre], &prefixer)
1083 .map_err(|e| KERIError::ManagerError(format!("Failed to update pres: {}", e)))?;
1084
1085 if !self.ks.prms.put(&[&pre], &pp)? {
1087 return Err(KERIError::ValueError(format!(
1088 "Already incepted prm for pre={}.",
1089 String::from_utf8_lossy(&pre)
1090 )));
1091 }
1092
1093 self.set_pidx(pidx + 1)?;
1095
1096 if !self.ks.sits.put(&[&pre], &ps)? {
1098 return Err(KERIError::ValueError(format!(
1099 "Already incepted sit for pre={}.",
1100 String::from_utf8_lossy(&pre)
1101 )));
1102 }
1103
1104 for signer in isigners {
1106 self.ks
1107 .pris
1108 .put(&[&signer.verfer.qb64b()], &signer, self.encrypter.clone())
1109 .map_err(|e| KERIError::ManagerError(format!("Failed to put pris: {}", e)))?;
1110 }
1111
1112 self.ks
1114 .pubs
1115 .put(
1116 &[&Keeper::ri_key(
1117 String::from_utf8(pre.clone()).unwrap().as_str(),
1118 ridx as u64,
1119 )],
1120 &PubSet { pubs: ps.new.pubs },
1121 )
1122 .map_err(|e| KERIError::ManagerError(format!("Failed to update pubs: {}", e)))?;
1123
1124 for signer in nsigners {
1126 self.ks
1127 .pris
1128 .put(&[&signer.verfer.qb64b()], &signer, self.encrypter.clone())
1129 .map_err(|e| KERIError::ManagerError(format!("Failed to put pris: {}", e)))?;
1130 }
1131
1132 self.ks
1134 .pubs
1135 .put(
1136 &[&Keeper::ri_key(
1137 String::from_utf8(pre).unwrap().as_str(),
1138 (ridx + 1) as u64,
1139 )],
1140 &PubSet { pubs: ps.nxt.pubs },
1141 )
1142 .map_err(|e| KERIError::ManagerError(format!("Failed to put pubs: {}", e)))?;
1143
1144 Ok((verfers, digers))
1145 }
1146
1147 pub fn move_prefix(&self, old: &[u8], new: &[u8]) -> Result<(), KERIError> {
1148 if old == new {
1150 return Ok(());
1151 }
1152
1153 let old_pre = self.ks.pres.get(&[old])?;
1155 if old_pre.is_none() {
1156 return Err(KERIError::ValueError(format!(
1157 "Nonexistent old pre={}, nothing to assign.",
1158 String::from_utf8_lossy(old)
1159 )));
1160 }
1161
1162 let new_pre = self.ks.pres.get(&[new])?;
1164 if new_pre.is_some() {
1165 return Err(KERIError::ValueError(format!(
1166 "Preexistent new pre={} may not clobber.",
1167 String::from_utf8_lossy(new)
1168 )));
1169 }
1170
1171 let old_prm = self.ks.prms.get(&[old])?;
1173 if old_prm.is_none() {
1174 return Err(KERIError::ValueError(format!(
1175 "Nonexistent old prm for pre={}, nothing to move.",
1176 String::from_utf8_lossy(old)
1177 )));
1178 }
1179 let old_prm = old_prm.unwrap();
1180
1181 let new_prm = self.ks.prms.get(&[new])?;
1183 if new_prm.is_some() {
1184 return Err(KERIError::ValueError(format!(
1185 "Preexistent new prm for pre={} may not clobber.",
1186 String::from_utf8_lossy(new)
1187 )));
1188 }
1189
1190 let old_sit = self.ks.sits.get(&[old])?;
1192 if old_sit.is_none() {
1193 return Err(KERIError::ValueError(format!(
1194 "Nonexistent old sit for pre={}, nothing to move.",
1195 String::from_utf8_lossy(old)
1196 )));
1197 }
1198 let old_sit = old_sit.unwrap();
1199
1200 let new_sit = self.ks.sits.get(&[new])?;
1202 if new_sit.is_some() {
1203 return Err(KERIError::ValueError(format!(
1204 "Preexistent new sit for pre={} may not clobber.",
1205 String::from_utf8_lossy(new)
1206 )));
1207 }
1208
1209 if !self.ks.prms.put(&[new], &old_prm)? {
1211 return Err(KERIError::ValueError(format!(
1212 "Failed moving prm from old pre={} to new pre={}.",
1213 String::from_utf8_lossy(old),
1214 String::from_utf8_lossy(new)
1215 )));
1216 } else {
1217 self.ks.prms.rem(&[old])?;
1218 }
1219
1220 if !self.ks.sits.put(&[new], &old_sit)? {
1222 return Err(KERIError::ValueError(format!(
1223 "Failed moving sit from old pre={} to new pre={}.",
1224 String::from_utf8_lossy(old),
1225 String::from_utf8_lossy(new)
1226 )));
1227 } else {
1228 self.ks.sits.rem(&[old])?;
1229 }
1230
1231 let mut i: u64 = 0;
1233 let old_str = String::from_utf8_lossy(old).to_string();
1234 let new_str = String::from_utf8_lossy(new).to_string();
1235
1236 while let Some(pl) = self.ks.pubs.get(&[&Keeper::ri_key(&old_str, i)])? {
1237 if !self.ks.pubs.put(&[&Keeper::ri_key(&new_str, i)], &pl)? {
1238 return Err(KERIError::ValueError(format!(
1239 "Failed moving pubs at pre={} ri={} to new pre={}",
1240 old_str, i, new_str
1241 )));
1242 }
1243 self.ks.pubs.rem(&[&Keeper::ri_key(&old_str, i)])?;
1245 i += 1;
1246 }
1247
1248 let mut new_copy = new.to_vec();
1250 let new_prefixer = Prefixer::from_qb64b(&mut new_copy, None)?;
1251
1252 if !self.ks.pres.pin(&[old], &new_prefixer)? {
1254 return Err(KERIError::ValueError(format!(
1255 "Failed assigning new pre={} to old pre={}.",
1256 String::from_utf8_lossy(new),
1257 String::from_utf8_lossy(old)
1258 )));
1259 }
1260
1261 if !self.ks.pres.put(&[new], &new_prefixer)? {
1263 return Err(KERIError::ValueError(format!(
1264 "Failed assigning new pre={}.",
1265 String::from_utf8_lossy(new)
1266 )));
1267 }
1268
1269 Ok(())
1270 }
1271
1272 pub fn rotate(
1310 &self,
1311 pre: &[u8],
1312 ncodes: Option<Vec<&str>>,
1313 ncount: Option<usize>,
1314 ncode: Option<&str>,
1315 dcode: Option<&str>,
1316 transferable: Option<bool>,
1317 temp: Option<bool>,
1318 erase: Option<bool>,
1319 ) -> Result<(Vec<Verfer>, Vec<Diger>), KERIError> {
1320 let ncount = ncount.unwrap_or(1);
1322 let ncode = ncode.unwrap_or(mtr_dex::ED25519_SEED);
1323 let _dcode = dcode.unwrap_or(mtr_dex::BLAKE3_256);
1324 let transferable = transferable.unwrap_or(true);
1325 let temp = temp.unwrap_or(false);
1326 let erase = erase.unwrap_or(true);
1327
1328 let pp = match self.ks.prms.get(&[pre])? {
1330 Some(pp) => pp,
1331 None => {
1332 return Err(KERIError::ValueError(format!(
1333 "Attempt to rotate nonexistent pre={}.",
1334 String::from_utf8_lossy(pre)
1335 )))
1336 }
1337 };
1338
1339 let mut ps = match self.ks.sits.get(&[pre])? {
1341 Some(ps) => ps,
1342 None => {
1343 return Err(KERIError::ValueError(format!(
1344 "Attempt to rotate nonexistent pre={}.",
1345 String::from_utf8_lossy(pre)
1346 )))
1347 }
1348 };
1349
1350 if ps.nxt.pubs.is_empty() {
1352 return Err(KERIError::ValueError(format!(
1353 "Attempt to rotate nontransferable pre={}.",
1354 String::from_utf8_lossy(pre)
1355 )));
1356 }
1357
1358 let old = ps.old.clone();
1360
1361 ps.old = Some(ps.new.clone());
1363
1364 ps.new = ps.nxt.clone();
1366
1367 let mut verfers = Vec::new();
1369 for pub_key in &ps.new.pubs {
1370 if self.encrypter.is_some() && self.decrypter.is_none() {
1372 return Err(KERIError::AuthError(
1373 "Unauthorized decryption attempt. Aeid but no decrypter.".to_string(),
1374 ));
1375 }
1376
1377 let signer = match self
1379 .ks
1380 .pris
1381 .get(&[pub_key.as_bytes()], self.decrypter.clone())?
1382 {
1383 Some(signer) => signer,
1384 None => {
1385 return Err(KERIError::ValueError(format!(
1386 "Missing prikey in db for pubkey={}",
1387 pub_key
1388 )))
1389 }
1390 };
1391
1392 verfers.push(signer.verfer);
1393 }
1394
1395 let salt = if !pp.salt.is_empty() {
1397 if self.encrypter.is_some() {
1398 if self.decrypter.is_none() {
1400 return Err(KERIError::AuthError(
1401 "Unauthorized decryption. Aeid but no decrypter.".to_string(),
1402 ));
1403 }
1404
1405 let salter_any = self.decrypter.as_ref().unwrap().decrypt(
1407 None,
1408 Some(&pp.salt),
1409 None,
1410 None,
1411 None,
1412 )?;
1413
1414 let salter = salter_any.downcast_ref::<Salter>().ok_or_else(|| {
1415 KERIError::ValueError("Failed to downcast to Salter".to_string())
1416 })?;
1417
1418 salter.qb64()
1419 } else {
1420 let mut salt_bytes = pp.salt.as_bytes().to_vec();
1422 let salter = Salter::from_qb64b(&mut salt_bytes, None)?;
1423 salter.qb64()
1424 }
1425 } else {
1426 String::new()
1427 };
1428
1429 let creator = Creatory::new(Algos::from_str(&pp.algo)?).make(
1431 Some(&salt),
1432 Some(&pp.stem),
1433 Some(Tiers::from(pp.tier.as_str())),
1434 )?;
1435
1436 let ncodes_to_use = if let Some(codes) = ncodes {
1438 codes
1439 } else {
1440 vec![ncode; ncount]
1442 };
1443
1444 let pidx = pp.pidx;
1446 let ridx = ps.new.ridx + 1;
1447 let kidx = ps.nxt.kidx + ps.new.pubs.len();
1448
1449 let signers = creator.create(
1452 Some(ncodes_to_use),
1453 Some(0),
1454 None,
1455 Some(pidx),
1456 Some(ridx),
1457 Some(kidx),
1458 Some(transferable),
1459 Some(temp),
1460 );
1461
1462 let digers = signers
1464 .iter()
1465 .map(|signer| -> Result<Diger, KERIError> {
1466 Diger::from_ser(&mut signer.verfer.qb64b(), None)
1467 .map_err(|e| KERIError::MatterError(e.to_string()))
1468 })
1469 .collect::<Result<Vec<Diger>, KERIError>>()?;
1470
1471 let dt = Utc::now().format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string();
1473 ps.nxt = PubLot {
1474 pubs: signers.iter().map(|signer| signer.verfer.qb64()).collect(),
1475 ridx,
1476 kidx,
1477 dt,
1478 };
1479
1480 if !self.ks.sits.pin(&[pre], &ps)? {
1482 return Err(KERIError::ValueError(format!(
1483 "Problem updating pubsit db for pre={}.",
1484 String::from_utf8_lossy(pre)
1485 )));
1486 }
1487
1488 for signer in &signers {
1490 self.ks
1491 .pris
1492 .put(&[&signer.verfer.qb64b()], signer, self.encrypter.clone())?;
1493 }
1494
1495 let pre_str = String::from_utf8_lossy(pre).to_string();
1497 self.ks.pubs.put(
1498 &[&Keeper::ri_key(&pre_str, ps.nxt.ridx as u64)],
1499 &PubSet { pubs: ps.nxt.pubs },
1500 )?;
1501
1502 if erase && old.is_some() {
1504 if let Some(old_keys) = old {
1505 for pub_key in old_keys.pubs {
1506 self.ks.pris.rem(&[pub_key.as_bytes()])?;
1507 }
1508 }
1509 }
1510
1511 Ok((verfers, digers))
1512 }
1513
1514 pub fn sign(
1545 &self,
1546 ser: &[u8],
1547 pubs: Option<Vec<String>>,
1548 verfers: Option<Vec<Verfer>>,
1549 indexed: Option<bool>,
1550 indices: Option<Vec<u32>>,
1551 ondices: Option<Vec<Option<u32>>>,
1552 pre: Option<&[u8]>,
1553 _path: Option<(usize, usize)>,
1554 ) -> Result<Vec<Sigmat>, KERIError> {
1555 let indexed = indexed.unwrap_or(true);
1557
1558 let mut signers = Vec::new();
1559
1560 if pubs.is_none() && verfers.is_none() {
1562 if pre.is_none() {
1563 return Err(KERIError::ValueError(
1564 "pubs or verfers or pre required".to_string(),
1565 ));
1566 }
1567
1568 unimplemented!()
1572 }
1573
1574 if let Some(pub_keys) = pubs {
1576 for pub_key in pub_keys {
1577 if self.encrypter.is_some() && self.decrypter.is_none() {
1579 return Err(KERIError::AuthError(
1580 "Unauthorized decryption attempt. Aeid but no decrypter.".to_string(),
1581 ));
1582 }
1583
1584 let signer = self
1586 .ks
1587 .pris
1588 .get(&[pub_key.as_bytes()], self.decrypter.clone())?
1589 .ok_or_else(|| {
1590 KERIError::ValueError(format!(
1591 "Missing prikey in db for pubkey={}",
1592 pub_key
1593 ))
1594 })?;
1595
1596 signers.push(signer);
1597 }
1598 }
1599 else if let Some(verfer_list) = verfers {
1601 for verfer in verfer_list {
1602 if self.encrypter.is_some() && self.decrypter.is_none() {
1604 return Err(KERIError::AuthError(
1605 "Unauthorized decryption attempt. Aeid but no decrypter.".to_string(),
1606 ));
1607 }
1608
1609 let signer = self
1611 .ks
1612 .pris
1613 .get(&[verfer.qb64b().as_slice()], self.decrypter.clone())?
1614 .ok_or_else(|| {
1615 KERIError::ValueError(format!(
1616 "Missing prikey in db for pubkey={}",
1617 verfer.qb64()
1618 ))
1619 })?;
1620
1621 signers.push(signer);
1622 }
1623 }
1624
1625 if let Some(ref idx) = indices {
1627 if idx.len() != signers.len() {
1628 return Err(KERIError::ValueError(format!(
1629 "Mismatch indices length={} and resultant signers length={}",
1630 idx.len(),
1631 signers.len()
1632 )));
1633 }
1634 }
1635
1636 if let Some(ref odx) = ondices {
1638 if odx.len() != signers.len() {
1639 return Err(KERIError::ValueError(format!(
1640 "Mismatch ondices length={} and resultant signers length={}",
1641 odx.len(),
1642 signers.len()
1643 )));
1644 }
1645 }
1646
1647 if indexed {
1649 let mut sigers = Vec::with_capacity(signers.len());
1650
1651 for j in 0..signers.len() {
1652 let i = if let Some(ref idx) = indices {
1654 idx[j]
1656 } else {
1657 j as u32
1659 };
1660
1661 let o = if let Some(ref odx) = ondices {
1663 odx[j]
1665 } else {
1666 Some(i)
1668 };
1669
1670 let siger = signers[j].sign(
1672 ser,
1673 Some(i),
1674 Some(o.is_none()), o,
1676 )?;
1677
1678 sigers.push(siger);
1679 }
1680
1681 Ok(sigers)
1682 } else {
1683 let mut cigars = Vec::with_capacity(signers.len());
1685
1686 for signer in signers {
1687 let cigar = signer.sign(ser, None, None, None)?;
1688 cigars.push(cigar);
1689 }
1690
1691 Ok(cigars)
1692 }
1693 }
1694
1695 pub fn decrypt(
1709 &self,
1710 qb64: &[u8],
1711 pubs: Option<Vec<&str>>,
1712 verfers: Option<Vec<Verfer>>,
1713 ) -> Result<Vec<u8>, KERIError> {
1714 let mut signers = Vec::new();
1715
1716 if let Some(pub_keys) = pubs {
1718 for pub_key in pub_keys {
1719 if self.encrypter.is_some() && self.decrypter.is_none() {
1721 return Err(KERIError::DecryptError(
1722 "Unauthorized decryption attempt. Aeid but no decrypter.".to_string(),
1723 ));
1724 }
1725
1726 let signer = self
1728 .ks
1729 .pris
1730 .get(&[pub_key.as_bytes()], self.decrypter.clone())?
1731 .ok_or_else(|| {
1732 KERIError::ValueError(format!(
1733 "Missing prikey in db for pubkey={}",
1734 pub_key
1735 ))
1736 })?;
1737
1738 signers.push(signer);
1739 }
1740 }
1741 else if let Some(verfer_list) = verfers {
1743 for verfer in verfer_list {
1744 if self.encrypter.is_some() && self.decrypter.is_none() {
1746 return Err(KERIError::DecryptError(
1747 "Unauthorized decryption attempt. Aeid but no decrypter.".to_string(),
1748 ));
1749 }
1750
1751 let signer = self
1753 .ks
1754 .pris
1755 .get(&[verfer.qb64b().as_slice()], self.decrypter.clone())?
1756 .ok_or_else(|| {
1757 KERIError::ValueError(format!(
1758 "Missing prikey in db for pubkey={}",
1759 verfer.qb64()
1760 ))
1761 })?;
1762
1763 signers.push(signer);
1764 }
1765 } else {
1766 return Err(KERIError::ValueError(
1767 "Either pubs or verfers must be provided".to_string(),
1768 ));
1769 }
1770
1771 let qb64b = qb64.to_vec();
1773 let mut plain = Vec::new();
1774
1775 for signer in signers {
1777 let mut sigkey = Vec::with_capacity(signer.raw().len() + signer.verfer().raw().len());
1779 sigkey.extend_from_slice(signer.raw());
1780 sigkey.extend_from_slice(signer.verfer().raw());
1781
1782 let prikey = sodiumoxide::crypto::sign::ed25519::to_curve25519_sk(
1784 &SecretKey::from_slice(&sigkey).unwrap(),
1785 )
1786 .unwrap();
1787
1788 let pubkey = prikey.public_key();
1790
1791 match sodiumoxide::crypto::sealedbox::open(&qb64b, &pubkey, &prikey) {
1793 Ok(decrypted) => {
1794 plain = decrypted;
1795 break;
1796 }
1797 Err(_) => continue, }
1799 }
1800
1801 if plain == qb64b {
1803 return Err(KERIError::ValueError("Unable to decrypt.".to_string()));
1804 }
1805
1806 Ok(plain)
1807 }
1808
1809 }
1811
1812#[cfg(test)]
1813mod tests {
1814 use super::*;
1815 use crate::cesr::indexing::Indexer;
1816 use crate::cesr::signing::{Cipher, Signer};
1817 use crate::keri::db::dbing::LMDBer;
1818 use std::sync::Arc;
1819
1820 #[test]
1821 fn test_manager_creation() -> Result<(), KERIError> {
1822 let lmdber = LMDBer::builder()
1823 .name("manager_ks")
1824 .reopen(true)
1825 .build()
1826 .expect("Failed to open manager database: {}");
1827 let keeper = Keeper::new(Arc::new(lmdber)).expect("Failed to create manager database");
1828 let manager = Manager::new(keeper, None, None, None, None, None, None)?;
1829
1830 assert!(manager.inited);
1831 assert!(manager.encrypter.is_none());
1832 assert!(manager.decrypter.is_none());
1833 assert!(manager.seed().is_empty());
1834
1835 Ok(())
1836 }
1837
1838 #[test]
1839 fn test_manager() -> Result<(), KERIError> {
1840 let raw = b"0123456789abcdef".to_vec();
1842 let salter = Salter::new(Some(&raw), None, None)?;
1843 let salt = salter.qb64b();
1844 let stem = "red";
1845
1846 assert_eq!(salt, b"0AAwMTIzNDU2Nzg5YWJjZGVm");
1847
1848 let ser = br#"{"vs":"KERI10JSON0000fb_","pre":"EvEnZMhz52iTrJU8qKwtDxzmypyosgG70m6LIjkiCdoI","sn":"0","ilk":"icp","sith":"1","keys":["DSuhyBcPZEZLK-fcw5tzHn2N46wRCG_ZOoeKtWTOunRA"],"nxt":"EPYuj8mq_PYYsoBKkzX1kxSPGYBWaIya3slgCOyOtlqU","toad":"0","wits":[],"cnfg":[]}-AABAApYcYd1cppVg7Inh2YCslWKhUwh59TrPpIoqWxN2A38NCbTljvmBPBjSGIFDBNOvVjHpdZlty3Hgk6ilF8pVpAQ"#.to_vec();
1850
1851 let lmdber = LMDBer::builder()
1853 .name("manager_ks")
1854 .reopen(true)
1855 .build()
1856 .expect("Failed to open manager database: {}");
1857 let lmdber_arc = Arc::new(lmdber);
1858 let keeper = Keeper::new(lmdber_arc.clone()).expect("Failed to create manager database");
1859
1860 let result = Manager::new(
1862 keeper,
1863 None,
1864 None,
1865 None,
1866 None,
1867 Some(b"0AzwMTIzNDU2Nzg5YWJjZGVm".to_vec()),
1868 None,
1869 );
1870 assert!(result.is_err());
1871 assert!(matches!(result, Err(KERIError::MatterError(_))));
1872
1873 let keeper = Keeper::new(lmdber_arc.clone()).expect("Failed to create manager database");
1875 let mut manager = Manager::new(keeper, None, None, None, None, Some(salt.clone()), None)?;
1876
1877 assert!(manager.ks.opened());
1878 assert_eq!(manager.pidx(), Some(0));
1879 assert_eq!(manager.tier(), Some(Tiers::LOW));
1880 assert_eq!(manager.salt(), Some(salt.clone()));
1881 assert_eq!(manager.aeid(), Vec::<u8>::new());
1882 assert_eq!(manager.seed(), &Vec::<u8>::new());
1883 assert!(manager.encrypter.is_none());
1884 assert!(manager.decrypter.is_none());
1885
1886 let (verfers, digers) = manager.incept(
1888 None,
1889 None,
1890 None,
1891 None,
1892 None,
1893 None,
1894 None,
1895 None,
1896 Some(salt.clone()),
1897 None,
1898 None,
1899 None,
1900 None,
1901 Some(true),
1902 )?;
1903
1904 assert_eq!(verfers.len(), 1);
1905 assert_eq!(digers.len(), 1);
1906 assert_eq!(manager.pidx(), Some(1));
1907
1908 let spre = verfers[0].qb64b();
1909 assert_eq!(&spre, b"DFRtyHAjSuJaRX6TDPva35GN11VHAruaOXMc79ZYDKsT");
1910
1911 let pp = manager.ks.prms.get(&[&spre])?.unwrap();
1912 assert_eq!(pp.pidx, 0);
1913 assert_eq!(pp.algo, Algos::Salty.to_string());
1914 assert_eq!(pp.salt, String::from_utf8(salt.clone()).unwrap());
1915 assert_eq!(pp.stem, "");
1916 assert_eq!(pp.tier, Tiers::LOW.to_string());
1917
1918 let ps = manager.ks.sits.get(&[&spre])?.unwrap();
1919 assert!(ps.old.is_none());
1920 assert_eq!(ps.new.pubs.len(), 1);
1921 assert_eq!(
1922 ps.new.pubs,
1923 vec!["DFRtyHAjSuJaRX6TDPva35GN11VHAruaOXMc79ZYDKsT"]
1924 );
1925 assert_eq!(ps.new.ridx, 0);
1926 assert_eq!(ps.new.kidx, 0);
1927 assert_eq!(ps.nxt.pubs.len(), 1);
1928 assert_eq!(
1929 ps.nxt.pubs,
1930 vec!["DHByVjuBrM1D9K71TuE5dq1HVDNS5-aLD-wcIlHiVoXX"]
1931 );
1932 assert_eq!(ps.nxt.ridx, 1);
1933 assert_eq!(ps.nxt.kidx, 1);
1934
1935 let keys: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
1936 assert_eq!(keys, ps.new.pubs);
1937
1938 let pl = manager
1940 .ks
1941 .pubs
1942 .get(&[Keeper::ri_key(
1943 String::from_utf8(spre.clone()).unwrap().as_str(),
1944 ps.new.ridx as u64,
1945 )])?
1946 .unwrap();
1947 assert_eq!(pl.pubs, ps.new.pubs);
1948
1949 let pl = manager
1950 .ks
1951 .pubs
1952 .get(&[Keeper::ri_key(
1953 String::from_utf8(spre.clone()).unwrap().as_str(),
1954 ps.nxt.ridx as u64,
1955 )])?
1956 .unwrap();
1957 assert_eq!(pl.pubs, ps.nxt.pubs);
1958
1959 let digs: Vec<String> = digers.iter().map(|d| d.qb64()).collect();
1960 assert_eq!(digs, vec!["EBhBRqVbqhhP7Ciah5pMIOdsY5Mm1ITm2Fjqb028tylu"]);
1961
1962 let oldspre = spre.clone();
1964 let spre = b"DCu5o5cxzv1lgMqxMVG3IcCNK4lpFfpMM-9rfkY3XVUc".to_vec();
1965 manager.move_prefix(&oldspre, &spre)?;
1966
1967 let pl = manager
1969 .ks
1970 .pubs
1971 .get(&[Keeper::ri_key(
1972 String::from_utf8(spre.clone()).unwrap().as_str(),
1973 ps.new.ridx as u64,
1974 )])?
1975 .unwrap();
1976 assert_eq!(pl.pubs, ps.new.pubs);
1977
1978 let pl = manager
1979 .ks
1980 .pubs
1981 .get(&[Keeper::ri_key(
1982 String::from_utf8(spre.clone()).unwrap().as_str(),
1983 ps.nxt.ridx as u64,
1984 )])?
1985 .unwrap();
1986 assert_eq!(pl.pubs, ps.nxt.pubs);
1987
1988 let psigers = manager.sign(
1990 &ser,
1991 Some(ps.new.pubs.clone()),
1992 None,
1993 None,
1994 None,
1995 None,
1996 None,
1997 None,
1998 )?;
1999 for siger in &psigers {
2000 match siger {
2001 Sigmat::Indexed(_) => {}
2002 _ => panic!("Expected indexed signature"),
2003 }
2004 }
2005
2006 let vsigers = manager.sign(
2008 &ser,
2009 None,
2010 Some(verfers.clone()),
2011 None,
2012 None,
2013 None,
2014 None,
2015 None,
2016 )?;
2017
2018 let psigs: Vec<String> = psigers
2019 .iter()
2020 .map(|s| {
2021 let Sigmat::Indexed(sig) = s else {
2022 panic!("Not indexed")
2023 };
2024 sig.qb64()
2025 })
2026 .collect();
2027 let vsigs: Vec<String> = vsigers
2028 .iter()
2029 .map(|s| {
2030 let Sigmat::Indexed(sig) = s else {
2031 panic!("Not indexed")
2032 };
2033 sig.qb64()
2034 })
2035 .collect();
2036
2037 assert_eq!(psigs, vsigs);
2038 assert_eq!(psigs, vec!["AAAa70b4QnTOtGOsMqcezMtVzCFuRJHGeIMkWYHZ5ZxGIXM0XDVAzkYdCeadfPfzlKC6dkfiwuJ0IzLOElaanUgH"]);
2039
2040 let indices = Some(vec![3]);
2042
2043 let psigers = manager.sign(
2045 &ser,
2046 Some(ps.new.pubs.clone()),
2047 None,
2048 None,
2049 indices.clone(),
2050 None,
2051 None,
2052 None,
2053 )?;
2054
2055 match &psigers[0] {
2056 Sigmat::Indexed(s) => assert_eq!(s.index(), 3),
2057 _ => panic!("Expected indexed signature"),
2058 }
2059
2060 let psigs: Vec<String> = psigers
2061 .iter()
2062 .map(|s| {
2063 let Sigmat::Indexed(sig) = s else {
2064 panic!("Not indexed")
2065 };
2066 sig.qb64()
2067 })
2068 .collect();
2069 assert_eq!(psigs, vec!["ADAa70b4QnTOtGOsMqcezMtVzCFuRJHGeIMkWYHZ5ZxGIXM0XDVAzkYdCeadfPfzlKC6dkfiwuJ0IzLOElaanUgH"]);
2070
2071 let vsigers = manager.sign(
2073 &ser,
2074 None,
2075 Some(verfers.clone()),
2076 None,
2077 indices,
2078 None,
2079 None,
2080 None,
2081 )?;
2082
2083 match &vsigers[0] {
2084 Sigmat::Indexed(s) => assert_eq!(s.index(), 3),
2085 _ => panic!("Expected indexed signature"),
2086 }
2087
2088 let vsigs: Vec<String> = vsigers
2089 .iter()
2090 .map(|s| {
2091 let Sigmat::Indexed(sig) = s else {
2092 panic!("Not indexed")
2093 };
2094 sig.qb64()
2095 })
2096 .collect();
2097 assert_eq!(vsigs, psigs);
2098
2099 let pcigars = manager.sign(
2101 &ser,
2102 Some(ps.new.pubs.clone()),
2103 None,
2104 Some(false),
2105 None,
2106 None,
2107 None,
2108 None,
2109 )?;
2110 for cigar in &pcigars {
2111 match cigar {
2112 Sigmat::NonIndexed(_) => (),
2113 _ => panic!("Expected non-indexed signature"),
2114 }
2115 }
2116
2117 let vcigars = manager.sign(
2118 &ser,
2119 None,
2120 Some(verfers.clone()),
2121 Some(false),
2122 None,
2123 None,
2124 None,
2125 None,
2126 )?;
2127
2128 let psigs: Vec<String> = pcigars
2129 .iter()
2130 .map(|s| {
2131 let Sigmat::NonIndexed(sig) = s else {
2132 panic!("Not indexed")
2133 };
2134 sig.qb64()
2135 })
2136 .collect();
2137 let vsigs: Vec<String> = vcigars
2138 .iter()
2139 .map(|s| {
2140 let Sigmat::NonIndexed(sig) = s else {
2141 panic!("Not indexed")
2142 };
2143 sig.qb64()
2144 })
2145 .collect();
2146
2147 assert_eq!(psigs, vsigs);
2148 assert_eq!(psigs, vec!["0BAa70b4QnTOtGOsMqcezMtVzCFuRJHGeIMkWYHZ5ZxGIXM0XDVAzkYdCeadfPfzlKC6dkfiwuJ0IzLOElaanUgH"]);
2149
2150 let oldpubs: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2152 let (verfers, digers) = manager.rotate(
2153 &String::from_utf8(spre.clone()).unwrap().as_bytes(),
2154 None,
2155 None,
2156 None,
2157 None,
2158 None,
2159 None,
2160 None,
2161 )?;
2162
2163 assert_eq!(verfers.len(), 1);
2164 assert_eq!(digers.len(), 1);
2165
2166 let pp = manager.ks.prms.get(&[&spre])?.unwrap();
2167 assert_eq!(pp.pidx, 0);
2168 assert_eq!(pp.algo, Algos::Salty.to_string());
2169 assert_eq!(pp.salt, String::from_utf8(salt.clone()).unwrap());
2170 assert_eq!(pp.stem, "");
2171 assert_eq!(pp.tier, Tiers::LOW.to_string());
2172
2173 let ps = manager.ks.sits.get(&[&spre])?.unwrap();
2174 assert_eq!(
2175 ps.old.clone().unwrap().pubs,
2176 vec!["DFRtyHAjSuJaRX6TDPva35GN11VHAruaOXMc79ZYDKsT"]
2177 );
2178 assert_eq!(ps.new.pubs.len(), 1);
2179 assert_eq!(
2180 ps.new.pubs,
2181 vec!["DHByVjuBrM1D9K71TuE5dq1HVDNS5-aLD-wcIlHiVoXX"]
2182 );
2183 assert_eq!(ps.new.ridx, 1);
2184 assert_eq!(ps.new.kidx, 1);
2185 assert_eq!(ps.nxt.pubs.len(), 1);
2186 assert_eq!(
2187 ps.nxt.pubs,
2188 vec!["DAoQ1WxT29XtCFtOpJZyuO2q38BD8KTefktf7X0WN4YW"]
2189 );
2190 assert_eq!(ps.nxt.ridx, 2);
2191 assert_eq!(ps.nxt.kidx, 2);
2192
2193 let keys: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2194 assert_eq!(keys, ps.new.pubs);
2195
2196 let digs: Vec<String> = digers.iter().map(|d| d.qb64()).collect();
2197 assert_eq!(digs, vec!["EJczV8HmnEWZiEHw2lVuSatrvzCmJOZ3zpa7JFfrnjau"]);
2198
2199 assert_eq!(oldpubs, ps.old.clone().unwrap().pubs);
2200
2201 let oldpubs: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2203 let deadpubs = ps.old.clone().unwrap().pubs.clone();
2204
2205 let (_verfers, _digers) = manager.rotate(
2206 &String::from_utf8(spre.clone()).unwrap().as_bytes(),
2207 None,
2208 None,
2209 None,
2210 None,
2211 None,
2212 None,
2213 None,
2214 )?;
2215
2216 let pp = manager.ks.prms.get(&[&spre])?.unwrap();
2217 assert_eq!(pp.pidx, 0);
2218
2219 let ps = manager.ks.sits.get(&[&spre])?.unwrap();
2220 assert_eq!(oldpubs, ps.old.unwrap().pubs);
2221
2222 for pub_key in deadpubs {
2224 assert!(manager.ks.pris.get(&[pub_key.as_bytes()], None)?.is_none());
2225 }
2226
2227 let pl = manager
2229 .ks
2230 .pubs
2231 .get(&[Keeper::ri_key(
2232 String::from_utf8(spre.clone()).unwrap().as_str(),
2233 ps.new.ridx as u64,
2234 )])?
2235 .unwrap();
2236 assert_eq!(pl.pubs, ps.new.pubs);
2237
2238 let pl = manager
2239 .ks
2240 .pubs
2241 .get(&[Keeper::ri_key(
2242 String::from_utf8(spre.clone()).unwrap().as_str(),
2243 ps.nxt.ridx as u64,
2244 )])?
2245 .unwrap();
2246 assert_eq!(pl.pubs, ps.nxt.pubs);
2247
2248 let (_verfers, digers) = manager.rotate(
2250 &String::from_utf8(spre.clone()).unwrap().as_bytes(),
2251 None,
2252 Some(0),
2253 None,
2254 None,
2255 None,
2256 None,
2257 None,
2258 )?;
2259
2260 let pp = manager.ks.prms.get(&[&spre])?.unwrap();
2261 assert_eq!(pp.pidx, 0);
2262
2263 let ps = manager.ks.sits.get(&[&spre])?.unwrap();
2264 assert!(ps.nxt.pubs.is_empty());
2265 assert!(digers.is_empty());
2266
2267 let result = manager.rotate(
2269 &String::from_utf8(spre.clone()).unwrap().as_bytes(),
2270 None,
2271 None,
2272 None,
2273 None,
2274 None,
2275 None,
2276 None,
2277 );
2278
2279 assert!(result.is_err());
2280 let err = result.unwrap_err();
2281 match err {
2282 KERIError::ValueError(msg) => {
2283 assert!(msg.starts_with("Attempt to rotate nontransferable"));
2284 }
2285 _ => panic!("Expected ValueError"),
2286 }
2287
2288 let (verfers, digers) = manager.incept(
2290 None,
2291 None,
2292 None,
2293 None,
2294 None,
2295 None,
2296 None,
2297 Some(Algos::Randy),
2298 None,
2299 None,
2300 None,
2301 None,
2302 None,
2303 None,
2304 )?;
2305
2306 assert_eq!(verfers.len(), 1);
2307 assert_eq!(digers.len(), 1);
2308 assert_eq!(manager.pidx(), Some(2));
2309
2310 let rpre = verfers[0].qb64b();
2311
2312 let pp = manager.ks.prms.get(&[&rpre])?.unwrap();
2313 assert_eq!(pp.pidx, 1);
2314 assert_eq!(pp.algo, Algos::Randy.to_string());
2315 assert_eq!(pp.salt, "");
2316 assert_eq!(pp.stem, "");
2317 assert_eq!(pp.tier, "");
2318
2319 let ps = manager.ks.sits.get(&[&rpre])?.unwrap();
2320 assert!(ps.old.is_none());
2321 assert_eq!(ps.new.pubs.len(), 1);
2322 assert_eq!(ps.new.ridx, 0);
2323 assert_eq!(ps.new.kidx, 0);
2324 assert_eq!(ps.nxt.pubs.len(), 1);
2325 assert_eq!(ps.nxt.ridx, 1);
2326 assert_eq!(ps.nxt.kidx, 1);
2327
2328 let keys: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2329 for key in &keys {
2330 assert!(manager.ks.pris.get(&[key.as_bytes()], None)?.is_some());
2331 }
2332
2333 let digs: Vec<String> = digers.iter().map(|d| d.qb64()).collect();
2334 assert_eq!(digs.len(), 1);
2335
2336 let oldrpre = rpre.clone();
2338 let rpre = b"DMqxMVG3IcCNK4lpFfCu5o5cxzv1lgpMM-9rfkY3XVUc".to_vec();
2339 manager.move_prefix(&oldrpre, &rpre)?;
2340
2341 let oldpubs: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2343
2344 let (_verfers, _digers) = manager.rotate(
2345 &String::from_utf8(rpre.clone()).unwrap().as_bytes(),
2346 None,
2347 None,
2348 None,
2349 None,
2350 None,
2351 None,
2352 None,
2353 )?;
2354
2355 let pp = manager.ks.prms.get(&[&rpre])?.unwrap();
2356 assert_eq!(pp.pidx, 1);
2357
2358 let ps = manager.ks.sits.get(&[&rpre])?.unwrap();
2359 assert_eq!(oldpubs, ps.old.unwrap().pubs);
2360
2361 let (verfers, digers) = manager.incept(
2363 None,
2364 None,
2365 None,
2366 None,
2367 Some(0),
2368 None,
2369 None,
2370 Some(Algos::Randy),
2371 None,
2372 None,
2373 None,
2374 None,
2375 None,
2376 None,
2377 )?;
2378
2379 assert_eq!(manager.pidx(), Some(3));
2380 let rpre = verfers[0].qb64b();
2381
2382 let pp = manager.ks.prms.get(&[&rpre])?.unwrap();
2383 assert_eq!(pp.pidx, 2);
2384
2385 let ps = manager.ks.sits.get(&[&rpre])?.unwrap();
2386 assert!(ps.nxt.pubs.is_empty());
2387 assert!(digers.is_empty());
2388
2389 let result = manager.rotate(
2391 &String::from_utf8(rpre.clone()).unwrap().as_bytes(),
2392 None,
2393 None,
2394 None,
2395 None,
2396 None,
2397 None,
2398 None,
2399 );
2400
2401 assert!(result.is_err());
2402
2403 let (verfers, digers) = manager.incept(
2405 None,
2406 None,
2407 None,
2408 None,
2409 None,
2410 None,
2411 None,
2412 None,
2413 Some(salt.clone()),
2414 Some(stem),
2415 None,
2416 None,
2417 None,
2418 Some(true),
2419 )?;
2420
2421 assert_eq!(verfers.len(), 1);
2422 assert_eq!(digers.len(), 1);
2423 assert_eq!(manager.pidx(), Some(4));
2424
2425 let spre = verfers[0].qb64b();
2426 assert_eq!(&spre, b"DOtu4gX3oc4feusD8wWIykLhjkpiJHXEe29eJ2b_1CyM");
2427
2428 let pp = manager.ks.prms.get(&[&spre])?.unwrap();
2429 assert_eq!(pp.pidx, 3);
2430 assert_eq!(pp.algo, Algos::Salty.to_string());
2431 assert_eq!(pp.salt, String::from_utf8(salt.clone()).unwrap());
2432 assert_eq!(pp.stem, stem);
2433 assert_eq!(pp.tier, Tiers::LOW.to_string());
2434
2435 let ps = manager.ks.sits.get(&[&spre])?.unwrap();
2436 assert!(ps.old.is_none());
2437 assert_eq!(ps.new.pubs.len(), 1);
2438 assert_eq!(
2439 ps.new.pubs,
2440 vec!["DOtu4gX3oc4feusD8wWIykLhjkpiJHXEe29eJ2b_1CyM"]
2441 );
2442 assert_eq!(ps.new.ridx, 0);
2443 assert_eq!(ps.new.kidx, 0);
2444 assert_eq!(ps.nxt.pubs.len(), 1);
2445 assert_eq!(
2446 ps.nxt.pubs,
2447 vec!["DBzZ6vejSNAZpXv1SDRnIF_P1UqcW5d2pu2U-v-uhXvE"]
2448 );
2449 assert_eq!(ps.nxt.ridx, 1);
2450 assert_eq!(ps.nxt.kidx, 1);
2451
2452 let keys: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2453 assert_eq!(keys, ps.new.pubs);
2454
2455 let digs: Vec<String> = digers.iter().map(|d| d.qb64()).collect();
2456 assert_eq!(digs, vec!["EIGjhyyBRcqCkPE9bmkph7morew0wW0ak-rQ-dHCH-M2"]);
2457
2458 let result = manager.incept(
2460 None,
2461 None,
2462 None,
2463 None,
2464 None,
2465 None,
2466 None,
2467 None,
2468 Some(salt.clone()),
2469 Some(stem),
2470 None,
2471 None,
2472 None,
2473 Some(true),
2474 );
2475
2476 assert!(result.is_err());
2477 let err = result.unwrap_err();
2478 match err {
2479 KERIError::ValueError(msg) => {
2480 assert!(msg.starts_with("Already incepted pre"));
2481 }
2482 _ => panic!("Expected ValueError"),
2483 }
2484
2485 let oldspre = spre.clone();
2487 let spre = b"DCNK4lpFfpMM-9rfkY3XVUcCu5o5cxzv1lgMqxMVG3Ic".to_vec();
2488 manager.move_prefix(&oldspre, &spre)?;
2489
2490 let result = manager.incept(
2492 None,
2493 None,
2494 None,
2495 None,
2496 None,
2497 None,
2498 None,
2499 None,
2500 Some(salt.clone()),
2501 Some(stem),
2502 None,
2503 None,
2504 None,
2505 Some(true),
2506 );
2507
2508 assert!(result.is_err());
2509 let err = result.unwrap_err();
2510 match err {
2511 KERIError::ValueError(msg) => {
2512 assert!(msg.starts_with("Already incepted pre"));
2513 }
2514 _ => panic!("Expected ValueError"),
2515 }
2516
2517 let (verfers, digers) = manager.incept(
2519 None,
2520 None,
2521 None,
2522 None,
2523 Some(0),
2524 None,
2525 None,
2526 None,
2527 Some(salt.clone()),
2528 Some("wit0"),
2529 None,
2530 None,
2531 Some(false),
2532 Some(true),
2533 )?;
2534
2535 let wit0pre = verfers[0].qb64();
2536 assert_eq!(wit0pre, "BOTNI4RzN706NecNdqTlGEcMSTWiFUvesEqmxWR_op8n");
2537 assert_eq!(verfers[0].code(), mtr_dex::ED25519N);
2538 assert!(digers.is_empty());
2539
2540 let (verfers, digers) = manager.incept(
2541 None,
2542 None,
2543 None,
2544 None,
2545 Some(0),
2546 None,
2547 None,
2548 None,
2549 Some(salt.clone()),
2550 Some("wit1"),
2551 None,
2552 None,
2553 Some(false),
2554 Some(true),
2555 )?;
2556
2557 let wit1pre = verfers[0].qb64();
2558 assert_eq!(wit1pre, "BAB_5xNXH4hoxDCtAHPFPDedZ6YwTo8mbdw_v0AOHOMt");
2559 assert_eq!(verfers[0].code(), mtr_dex::ED25519N);
2560 assert!(digers.is_empty());
2561
2562 assert_ne!(wit0pre, wit1pre);
2563
2564 Ok(())
2565 }
2566
2567 #[test]
2568 fn test_manager_with_aeid() -> Result<(), KERIError> {
2569 let rawsalt = b"0123456789abcdef".to_vec();
2571 let salter = Salter::new(Some(&rawsalt), None, None)?;
2572 let salt = salter.qb64();
2573 assert_eq!(salt, "0AAwMTIzNDU2Nzg5YWJjZGVm");
2574
2575 let cryptseed0 =
2577 b"h,#|\x8ap\"\x12\xc43t2\xa6\xe1\x18\x19\xf0f2,y\xc4\xc21@\xf5@\x15.\xa2\x1a\xcf"
2578 .to_vec();
2579 let cryptsigner0 = Signer::new(
2580 Some(&cryptseed0),
2581 Some("A"), Some(false),
2583 )?;
2584
2585 let seed0 = cryptsigner0.qb64();
2586 let aeid0 = cryptsigner0.verfer().qb64();
2587 assert_eq!(aeid0, "BCa7mK96FwxkU0TdF54Yqg3qBDXUWpOhQ_Mtr7E77yZB");
2588
2589 let decrypter0 = Decrypter::new(None, None, Some(seed0.as_bytes()))?;
2590 let encrypter0 = Encrypter::new(None, None, Some(aeid0.as_bytes()))?;
2591 assert!(encrypter0.verify_seed(seed0.as_bytes())?);
2592
2593 let cryptseed1 = b"\x89\xfe{\xd9'\xa7\xb3\x89#\x19\xbec\xee\xed\xc0\xf9\x97\xd0\x8f9\x1dyNII\x98\xbd\xa4\xf6\xfe\xbb\x03".to_vec();
2595 let cryptsigner1 = Signer::new(
2596 Some(&cryptseed1),
2597 Some("A"), Some(false),
2599 )?;
2600
2601 let seed1 = cryptsigner1.qb64();
2602 let aeid1 = cryptsigner1.verfer().qb64();
2603 assert_eq!(aeid1, "BEcOrMrG_7r_NWaLl6h8UJapwIfQWIkjrIPXkCZm2fFM");
2604
2605 let decrypter1 = Decrypter::new(None, None, Some(seed1.as_bytes()))?;
2606 let encrypter1 = Encrypter::new(None, None, Some(aeid1.as_bytes()))?;
2607 assert!(encrypter1.verify_seed(seed1.as_bytes())?);
2608
2609 let ser = br#"{"vs":"KERI10JSON0000fb_","pre":"EvEnZMhz52iTrJU8qKwtDxzmypyosgG70m6LIjkiCdoI","sn":"0","ilk":"icp","sith":"1","keys":["DSuhyBcPZEZLK-fcw5tzHn2N46wRCG_ZOoeKtWTOunRA"],"nxt":"EPYuj8mq_PYYsoBKkzX1kxSPGYBWaIya3slgCOyOtlqU","toad":"0","wits":[],"cnfg":[]}-AABAApYcYd1cppVg7Inh2YCslWKhUwh59TrPpIoqWxN2A38NCbTljvmBPBjSGIFDBNOvVjHpdZlty3Hgk6ilF8pVpAQ"#.to_vec();
2611
2612 let lmdber = LMDBer::builder()
2614 .name("manager_ks")
2615 .reopen(true)
2616 .build()
2617 .expect("Failed to open manager database: {}");
2618 let keeper = Keeper::new(Arc::new(lmdber)).expect("Failed to create manager database");
2619
2620 let mut manager = Manager::new(
2622 keeper,
2623 Some(seed0.as_bytes().to_vec()),
2624 Some(aeid0.as_bytes().to_vec()),
2625 None,
2626 None,
2627 Some(salt.as_bytes().to_vec()),
2628 None,
2629 )?;
2630
2631 assert!(manager.ks.opened());
2632 assert!(manager.inited);
2633
2634 assert_eq!(manager.salt(), Some(b"0AAwMTIzNDU2Nzg5YWJjZGVm".to_vec()));
2636 assert_eq!(
2637 manager.aeid(),
2638 b"BCa7mK96FwxkU0TdF54Yqg3qBDXUWpOhQ_Mtr7E77yZB".to_vec()
2639 );
2640
2641 assert_eq!(
2643 manager.encrypter.as_ref().unwrap().qb64(),
2644 encrypter0.qb64()
2645 );
2646 assert_eq!(
2647 manager.decrypter.as_ref().unwrap().qb64(),
2648 decrypter0.qb64()
2649 );
2650 assert_eq!(manager.seed(), &seed0.as_bytes().to_vec());
2651 assert_eq!(manager.aeid(), aeid0.as_bytes().to_vec());
2652
2653 assert_eq!(manager.algo().unwrap(), Algos::Salty.to_string());
2654 assert_eq!(manager.salt().unwrap(), salt.as_bytes().to_vec());
2655 assert_eq!(manager.pidx().unwrap(), 0);
2656 assert_eq!(manager.tier().unwrap(), Tiers::LOW);
2657
2658 let mut stored_salt = manager.ks.gbls.get(&["salt"])?.unwrap();
2660 let salt_cipher0 = Cipher::from_qb64b(&mut stored_salt, None)?;
2661
2662 let decrypted = salt_cipher0.decrypt(None, Some(seed0.as_bytes()), None, None)?;
2663 let decrypted_matter = decrypted
2664 .downcast_ref::<Salter>()
2665 .expect("Failed to downcast to Salter");
2666 assert_eq!(decrypted_matter.qb64(), salt);
2667
2668 let (verfers, digers) = manager.incept(
2670 None,
2671 None,
2672 None,
2673 None,
2674 None,
2675 None,
2676 None,
2677 None,
2678 Some(salt.as_bytes().to_vec()),
2679 None,
2680 None,
2681 None,
2682 None,
2683 Some(true),
2684 )?;
2685
2686 assert_eq!(verfers.len(), 1);
2687 assert_eq!(digers.len(), 1);
2688 assert_eq!(manager.pidx().unwrap(), 1);
2689
2690 let spre = verfers[0].qb64b();
2691 assert_eq!(
2692 String::from_utf8(spre.clone()).unwrap(),
2693 "DFRtyHAjSuJaRX6TDPva35GN11VHAruaOXMc79ZYDKsT"
2694 );
2695
2696 let pp = manager.ks.prms.get(&[&spre])?.unwrap();
2698 assert_eq!(pp.pidx, 0);
2699 assert_eq!(pp.algo, Algos::Salty.to_string());
2700
2701 let _decrypted_salt = manager.decrypter.as_ref().unwrap().decrypt(
2703 None,
2704 Some(pp.salt.as_str()),
2705 None,
2706 None,
2707 None,
2708 )?;
2709 assert_eq!(pp.stem, "");
2712 assert_eq!(pp.tier, Tiers::LOW.to_string());
2713
2714 let ps = manager.ks.sits.get(&[&spre])?.unwrap();
2716 assert!(ps.old.is_none());
2717 assert_eq!(ps.new.pubs.len(), 1);
2718 assert_eq!(
2719 ps.new.pubs[0],
2720 "DFRtyHAjSuJaRX6TDPva35GN11VHAruaOXMc79ZYDKsT"
2721 );
2722 assert_eq!(ps.new.ridx, 0);
2723 assert_eq!(ps.new.kidx, 0);
2724 assert_eq!(ps.nxt.pubs.len(), 1);
2725 assert_eq!(
2726 ps.nxt.pubs[0],
2727 "DHByVjuBrM1D9K71TuE5dq1HVDNS5-aLD-wcIlHiVoXX"
2728 );
2729 assert_eq!(ps.nxt.ridx, 1);
2730 assert_eq!(ps.nxt.kidx, 1);
2731
2732 let keys: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2734 assert_eq!(keys, ps.new.pubs);
2735
2736 let ri_key = Keeper::ri_key(
2738 &String::from_utf8(spre.clone()).unwrap(),
2739 ps.new.ridx as u64,
2740 );
2741 let pl = manager.ks.pubs.get(&[&ri_key])?.unwrap();
2742 assert_eq!(pl.pubs, ps.new.pubs);
2743
2744 let ri_key = Keeper::ri_key(
2745 &String::from_utf8(spre.clone()).unwrap(),
2746 ps.nxt.ridx as u64,
2747 );
2748 let pl = manager.ks.pubs.get(&[&ri_key])?.unwrap();
2749 assert_eq!(pl.pubs, ps.nxt.pubs);
2750
2751 let digs: Vec<String> = digers.iter().map(|d| d.qb64()).collect();
2753 assert_eq!(digs[0], "EBhBRqVbqhhP7Ciah5pMIOdsY5Mm1ITm2Fjqb028tylu");
2754
2755 let oldspre = spre.clone();
2757 let spre = b"DCu5o5cxzv1lgMqxMVG3IcCNK4lpFfpMM-9rfkY3XVUc".to_vec();
2758 manager.move_prefix(&oldspre, &spre)?;
2759
2760 let ri_key = Keeper::ri_key(
2762 &String::from_utf8(spre.clone()).unwrap(),
2763 ps.new.ridx as u64,
2764 );
2765 let pl = manager.ks.pubs.get(&[&ri_key])?.unwrap();
2766 assert_eq!(pl.pubs, ps.new.pubs);
2767
2768 let ri_key = Keeper::ri_key(
2769 &String::from_utf8(spre.clone()).unwrap(),
2770 ps.nxt.ridx as u64,
2771 );
2772 let pl = manager.ks.pubs.get(&[&ri_key])?.unwrap();
2773 assert_eq!(pl.pubs, ps.nxt.pubs);
2774
2775 let psigers = manager.sign(
2777 &ser,
2778 Some(ps.new.pubs.clone()),
2779 None,
2780 None,
2781 None,
2782 None,
2783 None,
2784 None,
2785 )?;
2786 for siger in &psigers {
2787 assert!(matches!(siger, Sigmat::Indexed(_)));
2788 }
2789
2790 let vsigers = manager.sign(
2792 &ser,
2793 None,
2794 Some(verfers.clone()),
2795 None,
2796 None,
2797 None,
2798 None,
2799 None,
2800 )?;
2801
2802 let psigs: Vec<String> = psigers
2803 .iter()
2804 .map(|s| {
2805 let Sigmat::Indexed(sig) = s else {
2806 panic!("Not indexed")
2807 };
2808 sig.qb64()
2809 })
2810 .collect();
2811 let vsigs: Vec<String> = vsigers
2812 .iter()
2813 .map(|s| {
2814 let Sigmat::Indexed(sig) = s else {
2815 panic!("Not indexed")
2816 };
2817 sig.qb64()
2818 })
2819 .collect();
2820
2821 assert_eq!(psigs, vsigs);
2822 assert_eq!(psigs[0], "AAAa70b4QnTOtGOsMqcezMtVzCFuRJHGeIMkWYHZ5ZxGIXM0XDVAzkYdCeadfPfzlKC6dkfiwuJ0IzLOElaanUgH");
2823
2824 let indices = Some(vec![3]);
2826
2827 let psigers = manager.sign(
2829 &ser,
2830 Some(ps.new.pubs.clone()),
2831 None,
2832 None,
2833 indices.clone(),
2834 None,
2835 None,
2836 None,
2837 )?;
2838
2839 if let Sigmat::Indexed(siger) = &psigers[0] {
2840 assert_eq!(siger.index(), 3);
2841 } else {
2842 panic!("Expected indexed signature");
2843 }
2844
2845 let psigs: Vec<String> = psigers
2846 .iter()
2847 .map(|s| {
2848 let Sigmat::Indexed(sig) = s else {
2849 panic!("Not indexed")
2850 };
2851 sig.qb64()
2852 })
2853 .collect();
2854 assert_eq!(psigs[0], "ADAa70b4QnTOtGOsMqcezMtVzCFuRJHGeIMkWYHZ5ZxGIXM0XDVAzkYdCeadfPfzlKC6dkfiwuJ0IzLOElaanUgH");
2855
2856 let vsigers = manager.sign(
2858 &ser,
2859 None,
2860 Some(verfers.clone()),
2861 None,
2862 indices,
2863 None,
2864 None,
2865 None,
2866 )?;
2867
2868 if let Sigmat::Indexed(siger) = &vsigers[0] {
2869 assert_eq!(siger.index(), 3);
2870 } else {
2871 panic!("Expected indexed signature");
2872 }
2873
2874 let vsigs: Vec<String> = vsigers
2875 .iter()
2876 .map(|s| {
2877 let Sigmat::Indexed(sig) = s else {
2878 panic!("Not indexed")
2879 };
2880 sig.qb64()
2881 })
2882 .collect();
2883 assert_eq!(vsigs, psigs);
2884
2885 let pcigars = manager.sign(
2887 &ser,
2888 Some(ps.new.pubs.clone()),
2889 None,
2890 Some(false),
2891 None,
2892 None,
2893 None,
2894 None,
2895 )?;
2896 for cigar in &pcigars {
2897 assert!(matches!(cigar, Sigmat::NonIndexed(_)));
2898 }
2899
2900 let vcigars = manager.sign(
2901 &ser,
2902 None,
2903 Some(verfers.clone()),
2904 Some(false),
2905 None,
2906 None,
2907 None,
2908 None,
2909 )?;
2910
2911 let psigs: Vec<String> = pcigars
2912 .iter()
2913 .map(|s| {
2914 let Sigmat::NonIndexed(sig) = s else {
2915 panic!("Not indexed")
2916 };
2917 sig.qb64()
2918 })
2919 .collect();
2920 let vsigs: Vec<String> = vcigars
2921 .iter()
2922 .map(|s| {
2923 let Sigmat::NonIndexed(sig) = s else {
2924 panic!("Not indexed")
2925 };
2926 sig.qb64()
2927 })
2928 .collect();
2929
2930 assert_eq!(psigs, vsigs);
2931 assert_eq!(psigs[0], "0BAa70b4QnTOtGOsMqcezMtVzCFuRJHGeIMkWYHZ5ZxGIXM0XDVAzkYdCeadfPfzlKC6dkfiwuJ0IzLOElaanUgH");
2932
2933 let oldpubs: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2935 let (verfers, digers) = manager.rotate(
2936 &String::from_utf8(spre.clone()).unwrap().as_bytes(),
2937 None,
2938 None,
2939 None,
2940 None,
2941 None,
2942 None,
2943 None,
2944 )?;
2945
2946 assert_eq!(verfers.len(), 1);
2947 assert_eq!(digers.len(), 1);
2948
2949 let pp = manager.ks.prms.get(&[&spre])?.unwrap();
2951 assert_eq!(pp.pidx, 0);
2952 assert_eq!(pp.algo, Algos::Salty.to_string());
2953
2954 let _decrypted_salt = manager.decrypter.as_ref().unwrap().decrypt(
2956 None,
2957 Some(pp.salt.as_str()),
2958 None,
2959 None,
2960 None,
2961 )?;
2962 assert_eq!(pp.stem, "");
2965 assert_eq!(pp.tier, Tiers::LOW.to_string());
2966
2967 let ps = manager.ks.sits.get(&[&spre])?.unwrap();
2969 assert_eq!(
2970 ps.old.as_ref().unwrap().pubs[0],
2971 "DFRtyHAjSuJaRX6TDPva35GN11VHAruaOXMc79ZYDKsT"
2972 );
2973 assert_eq!(ps.new.pubs.len(), 1);
2974 assert_eq!(
2975 ps.new.pubs[0],
2976 "DHByVjuBrM1D9K71TuE5dq1HVDNS5-aLD-wcIlHiVoXX"
2977 );
2978 assert_eq!(ps.new.ridx, 1);
2979 assert_eq!(ps.new.kidx, 1);
2980 assert_eq!(ps.nxt.pubs.len(), 1);
2981 assert_eq!(
2982 ps.nxt.pubs[0],
2983 "DAoQ1WxT29XtCFtOpJZyuO2q38BD8KTefktf7X0WN4YW"
2984 );
2985 assert_eq!(ps.nxt.ridx, 2);
2986 assert_eq!(ps.nxt.kidx, 2);
2987
2988 let keys: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
2990 assert_eq!(keys, ps.new.pubs);
2991
2992 let digs: Vec<String> = digers.iter().map(|d| d.qb64()).collect();
2994 assert_eq!(digs[0], "EJczV8HmnEWZiEHw2lVuSatrvzCmJOZ3zpa7JFfrnjau");
2995
2996 assert_eq!(oldpubs, ps.old.as_ref().unwrap().pubs);
2998
2999 manager.update_aeid(aeid1.as_bytes().to_vec(), seed1.as_bytes().to_vec())?;
3001 assert_eq!(
3002 manager.encrypter.as_ref().unwrap().qb64(),
3003 encrypter1.qb64()
3004 );
3005 assert_eq!(
3006 manager.decrypter.as_ref().unwrap().qb64(),
3007 decrypter1.qb64()
3008 );
3009 assert_eq!(manager.seed(), &seed1.as_bytes().to_vec());
3010 assert_eq!(manager.aeid(), aeid1.as_bytes().to_vec());
3011
3012 assert_eq!(manager.algo().unwrap(), Algos::Salty.to_string());
3013 assert_eq!(manager.salt().unwrap(), salt.as_bytes().to_vec());
3014 assert_eq!(manager.pidx().unwrap(), 1);
3015 assert_eq!(manager.tier().unwrap(), Tiers::LOW);
3016
3017 let mut stored_salt = manager.ks.gbls.get(&["salt"])?.unwrap();
3020 let salt_cipher1 = Cipher::from_qb64b(&mut stored_salt, None)?;
3021 assert_ne!(salt_cipher0.qb64(), salt_cipher1.qb64());
3025
3026 let oldpubs: Vec<String> = verfers.iter().map(|v| v.qb64()).collect();
3028 let deadpubs = ps.old.as_ref().unwrap().pubs.clone();
3029
3030 let (_verfers, _digers) = manager.rotate(
3031 &String::from_utf8(spre.clone()).unwrap().as_bytes(),
3032 None,
3033 None,
3034 None,
3035 None,
3036 None,
3037 None,
3038 None,
3039 )?;
3040
3041 let pp = manager.ks.prms.get(&[&spre])?.unwrap();
3043 assert_eq!(pp.pidx, 0);
3044
3045 let ps = manager.ks.sits.get(&[&spre])?.unwrap();
3047 assert_eq!(oldpubs, ps.old.as_ref().unwrap().pubs);
3048
3049 for pub_key in deadpubs {
3051 assert!(manager.ks.pris.get(&[pub_key.as_bytes()], None)?.is_none());
3052 }
3053
3054 let ri_key = Keeper::ri_key(
3056 &String::from_utf8(spre.clone()).unwrap(),
3057 ps.new.ridx as u64,
3058 );
3059 let pl = manager.ks.pubs.get(&[&ri_key])?.unwrap();
3060 assert_eq!(pl.pubs, ps.new.pubs);
3061
3062 let ri_key = Keeper::ri_key(
3063 &String::from_utf8(spre.clone()).unwrap(),
3064 ps.nxt.ridx as u64,
3065 );
3066 let pl = manager.ks.pubs.get(&[&ri_key])?.unwrap();
3067 assert_eq!(pl.pubs, ps.nxt.pubs);
3068
3069 let (_verfers, digers) = manager.rotate(
3071 &String::from_utf8(spre.clone()).unwrap().as_bytes(),
3072 None,
3073 Some(0),
3074 None,
3075 None,
3076 None,
3077 None,
3078 None,
3079 )?;
3080
3081 let pp = manager.ks.prms.get(&[&spre])?.unwrap();
3083 assert_eq!(pp.pidx, 0);
3084
3085 let ps = manager.ks.sits.get(&[&spre])?.unwrap();
3087 assert!(ps.nxt.pubs.is_empty());
3088 assert!(digers.is_empty());
3089
3090 let result = manager.rotate(
3092 &String::from_utf8(spre).unwrap().as_bytes(),
3093 None,
3094 None,
3095 None,
3096 None,
3097 None,
3098 None,
3099 None,
3100 );
3101
3102 assert!(result.is_err());
3103 match result {
3104 Err(KERIError::ValueError(msg)) => {
3105 assert!(msg.starts_with("Attempt to rotate nontransferable"));
3106 }
3107 _ => panic!("Expected ValueError"),
3108 }
3109
3110 Ok(())
3111 }
3112}