1mod disk;
14mod writer_lock;
15pub use writer_lock::{StoreWriterLock, WriterLockError};
16mod records;
17#[cfg(feature = "test-support")]
18pub mod testing;
19#[cfg(test)]
20mod tests;
21
22pub use records::*;
23
24use hmac::{Hmac, Mac};
25use serde::{Deserialize, Serialize};
26use sha2::{Digest as _, Sha256};
27use std::{
28 io,
29 path::{Path, PathBuf},
30};
31use subc_os::config_keychain::{
32 AnchorState, KeychainError, KeychainState, KeychainStore, StoreAnchor, StoreKey,
33};
34
35pub const STORE_FORMAT_VERSION: u32 = 1;
36pub const STORE_FILE: &str = "approved.json";
37pub const STORE_BYTE_LIMIT: usize = 64 * 1024 * 1024;
39const KEYCHAIN_SERVICE: &str = "com.cortexkit.subc.config-gate";
40
41fn wall_time_ms() -> u64 {
42 std::time::SystemTime::now()
43 .duration_since(std::time::UNIX_EPOCH)
44 .map_or(0, |duration| {
45 u64::try_from(duration.as_millis()).unwrap_or(u64::MAX)
46 })
47}
48
49#[derive(Clone, Copy, Debug, PartialEq, Eq)]
50pub enum StoreState {
51 Unstamped,
52 Stamped,
53 StoreUnverified,
54 StoreMissing,
55}
56
57#[derive(Clone, Copy, Debug, PartialEq, Eq)]
58pub enum StoreErrorCode {
59 StoreUnverified,
60 StoreMissing,
61 StoreTampered,
62 StoreTooLarge,
63 AnchorPending,
64 GenerationPruned,
65 GenerationMissing,
66 RevisionExhausted,
67 InvalidState,
68 Io,
69}
70
71#[derive(Debug)]
72pub struct StoreError {
73 pub code: StoreErrorCode,
74 pub detail: String,
75}
76impl StoreError {
77 fn new(code: StoreErrorCode, detail: impl ToString) -> Self {
78 Self {
79 code,
80 detail: detail.to_string(),
81 }
82 }
83 fn serialization(error: impl ToString) -> Self {
84 Self::new(StoreErrorCode::InvalidState, error)
85 }
86}
87impl std::fmt::Display for StoreError {
88 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
89 write!(f, "{:?}: {}", self.code, self.detail)
90 }
91}
92impl std::error::Error for StoreError {}
93impl From<io::Error> for StoreError {
94 fn from(error: io::Error) -> Self {
95 Self::new(StoreErrorCode::Io, error)
96 }
97}
98
99#[derive(Clone, Debug, PartialEq, Eq)]
101pub struct StoreActivity {
102 pub event: &'static str,
103 pub detail: String,
104}
105
106#[cfg(test)]
108#[derive(Clone, Default)]
109pub(crate) struct TestStoreKey(std::sync::Arc<std::sync::Mutex<tests::MemoryKey>>);
110
111#[cfg(test)]
112impl TestStoreKey {
113 pub(crate) fn fail_anchor(&self, fail: bool) {
114 self.0.lock().unwrap().set_anchor_failure(fail);
115 }
116
117 pub(crate) fn anchor_calls(&self) -> usize {
118 self.0.lock().unwrap().anchor_calls()
119 }
120}
121
122#[derive(Clone, Debug)]
123pub struct StoreStatus {
124 pub state: StoreState,
125 pub integrity: IntegrityMode,
126 pub revision: u64,
127 pub base_revision: u64,
128 pub anchor_pending: bool,
129 pub warnings: Vec<String>,
130}
131
132pub struct StoreRoot(PathBuf);
135impl StoreRoot {
136 pub fn from_service_definition(path: PathBuf) -> io::Result<Self> {
137 if !path.is_absolute() {
138 return Err(io::Error::new(
139 io::ErrorKind::InvalidInput,
140 "store root must be absolute",
141 ));
142 }
143 Ok(Self(path))
144 }
145 pub fn installation_default() -> io::Result<Self> {
148 #[cfg(windows)]
149 let path = subc_os::profile_dir()?
150 .join("AppData")
151 .join("Local")
152 .join("cortexkit")
153 .join("config");
154 #[cfg(not(windows))]
155 let path = subc_os::real_user_home_dir()?
156 .join(".local")
157 .join("share")
158 .join("cortexkit")
159 .join("config");
160 Self::from_service_definition(path)
161 }
162 pub fn path(&self) -> &Path {
163 &self.0
164 }
165}
166
167#[derive(Clone, Serialize, Deserialize)]
168struct Envelope {
169 format_version: u32,
170 revision: u64,
171 previous_digest: Option<[u8; 32]>,
172 integrity: IntegrityMode,
173 body: StoreBody,
174 #[serde(skip_serializing_if = "Option::is_none")]
175 mac: Option<[u8; 32]>,
176}
177impl Envelope {
178 fn authenticate(&self, key: &StoreKey) -> Result<[u8; 32], StoreError> {
179 let mut unsigned = self.clone();
182 unsigned.mac = None;
183 let body = serde_json::to_vec(&unsigned).map_err(StoreError::serialization)?;
184 Ok(self.mac_over_bytes(key, &body))
185 }
186 fn mac_over_bytes(&self, key: &StoreKey, body: &[u8]) -> [u8; 32] {
187 let mut mac =
188 Hmac::<Sha256>::new_from_slice(key.as_bytes()).expect("HMAC accepts 32 bytes");
189 mac.update(b"subc-config-store-v1\0");
190 mac.update(&self.revision.to_be_bytes());
191 mac.update(&[u8::from(self.previous_digest.is_some())]);
192 mac.update(&self.previous_digest.unwrap_or([0; 32]));
193 mac.update(&Sha256::digest(body));
194 mac.finalize().into_bytes().into()
195 }
196 fn valid_mac(&self, key: &StoreKey, bytes: &[u8]) -> bool {
197 use subtle::ConstantTimeEq;
198 let Some(saved) = self.mac else {
199 return false;
200 };
201 let mut suffix = b",\"mac\":".to_vec();
205 suffix.extend(serde_json::to_vec(&saved).expect("fixed byte array serializes"));
206 suffix.push(b'}');
207 let Some(prefix) = bytes.strip_suffix(suffix.as_slice()) else {
208 return false;
209 };
210 let mut unsigned = prefix.to_vec();
211 unsigned.push(b'}');
212 bool::from(saved.ct_eq(&self.mac_over_bytes(key, &unsigned)))
213 }
214}
215
216enum Backend {
217 Unsupported,
218 Os(KeychainStore),
219 Unavailable(String),
220 #[cfg(feature = "test-support")]
221 File(subc_os::config_keychain::testing::FileKeyStore),
222 #[cfg(test)]
223 Memory(std::sync::Arc<std::sync::Mutex<tests::MemoryKey>>),
224}
225impl Backend {
226 fn production() -> Self {
227 match KeychainStore::open(KEYCHAIN_SERVICE) {
228 Ok(store) => Self::Os(store),
229 Err(KeychainError::Unsupported) => Self::Unsupported,
230 Err(error) => Self::Unavailable(error.to_string()),
231 }
232 }
233 fn load(&self) -> Result<Option<KeychainState>, StoreError> {
234 let result = match self {
235 Self::Unsupported => return Ok(None),
236 Self::Unavailable(error) => {
237 return Err(StoreError::new(StoreErrorCode::StoreUnverified, error))
238 }
239 Self::Os(store) => store.load(),
240 #[cfg(feature = "test-support")]
241 Self::File(store) => store.load(),
242 #[cfg(test)]
243 Self::Memory(store) => return store.lock().unwrap().load(),
244 };
245 result.map_err(|e| StoreError::new(StoreErrorCode::StoreUnverified, e))
246 }
247 fn create(&self) -> Result<(), StoreError> {
248 let mut bytes = [0; 32];
249 getrandom::getrandom(&mut bytes).map_err(StoreError::serialization)?;
250 let result = match self {
251 Self::Os(store) => store.create(StoreKey::new(bytes)),
252 #[cfg(feature = "test-support")]
253 Self::File(store) => store.create(StoreKey::new(bytes)),
254 #[cfg(test)]
255 Self::Memory(store) => {
256 store.lock().unwrap().key = Some(bytes);
257 return Ok(());
258 }
259 _ => {
260 return Err(StoreError::new(
261 StoreErrorCode::StoreUnverified,
262 "sealing unavailable",
263 ))
264 }
265 };
266 result.map_err(|e| StoreError::new(StoreErrorCode::StoreUnverified, e))
267 }
268 fn seal_available(&self) -> bool {
269 !matches!(self, Self::Unsupported)
270 }
271 fn anchor(&self, pair: StoreAnchor, stamped: bool) -> Result<(), StoreError> {
272 let result = match self {
273 Self::Os(store) => {
274 if stamped {
275 store.update_anchor(pair)
276 } else {
277 store.clear_anchor(pair.revision)
278 }
279 }
280 #[cfg(feature = "test-support")]
281 Self::File(store) => {
282 if stamped {
283 store.update_anchor(pair)
284 } else {
285 store.clear_anchor(pair.revision)
286 }
287 }
288 #[cfg(test)]
289 Self::Memory(store) => return store.lock().unwrap().anchor(pair, stamped),
290 _ => {
291 return Err(StoreError::new(
292 StoreErrorCode::StoreUnverified,
293 "key access unavailable; restore key access",
294 ))
295 }
296 };
297 result.map_err(|e| StoreError::new(StoreErrorCode::AnchorPending, e))
298 }
299}
300
301struct UnanchoredAck {
302 visible: StoreBody,
303 tuple: Tuple,
304 generation: u64,
305}
306
307#[cfg(test)]
308pub(crate) type IoThreads =
309 std::sync::Arc<std::sync::Mutex<Vec<(&'static str, std::thread::ThreadId)>>>;
310
311pub struct ConfigStore {
315 root: StoreRoot,
316 backend: Backend,
317 envelope: Envelope,
318 state: StoreState,
319 publication_sequence: u64,
320 expected_digest: Option<[u8; 32]>,
321 pending_anchor: Option<(StoreAnchor, bool)>,
322 pending_prior_anchor: Option<AnchorState>,
323 warnings: Vec<String>,
324 activities: Vec<StoreActivity>,
325 deferred_failure: Option<StoreBody>,
326 unanchored_ack: Option<UnanchoredAck>,
330 booted_generation: Option<u64>,
332 #[cfg(test)]
333 byte_limit: usize,
334 #[cfg(test)]
335 io_threads: Option<IoThreads>,
336 #[cfg(feature = "test-support")]
337 hooks: Option<testing::TestSupport>,
338}
339impl ConfigStore {
340 pub(crate) fn publication_sequence(&self) -> u64 {
343 self.publication_sequence
344 }
345
346 #[cfg(all(test, unix))]
347 pub(crate) fn clear_delivery_snapshot_for_test(&mut self, generation: u64) {
348 let mut body = self.envelope.body.clone();
349 body.generations.get_mut(&generation).unwrap().delivery = None;
350 self.publish(body, false, wall_time_ms()).unwrap();
351 }
352 pub(crate) fn loaded_admission_state(&self) -> (StoreState, &StoreBody) {
355 (
356 self.state,
357 self.deferred_failure
358 .as_ref()
359 .or(self.unanchored_ack.as_ref().map(|ack| &ack.visible))
360 .unwrap_or(&self.envelope.body),
361 )
362 }
363
364 pub(crate) fn loaded_anchor_pending(&self) -> bool {
367 self.pending_anchor.is_some()
368 }
369 #[cfg(test)]
370 pub(crate) fn observe_io_threads(&mut self, threads: IoThreads) {
371 self.io_threads = Some(threads);
372 }
373
374 #[cfg(test)]
375 fn observe_io_thread(&self, operation: &'static str) {
376 if let Some(threads) = &self.io_threads {
377 threads
378 .lock()
379 .unwrap()
380 .push((operation, std::thread::current().id()));
381 }
382 }
383
384 #[cfg(test)]
386 pub(crate) fn open_digest_only_for_tests(root: StoreRoot) -> Self {
387 Self::load(root, Backend::Unsupported)
388 }
389 #[cfg(test)]
390 pub(crate) fn open_sealed_for_tests(root: StoreRoot, key: TestStoreKey) -> Self {
391 Self::load(root, Backend::Memory(key.0))
392 }
393 pub fn open(root: StoreRoot) -> Self {
396 Self::load(root, Backend::production())
397 }
398
399 fn load(root: StoreRoot, backend: Backend) -> Self {
400 let mut store = Self {
401 root,
402 backend,
403 envelope: Envelope {
404 format_version: STORE_FORMAT_VERSION,
405 revision: 0,
406 previous_digest: None,
407 integrity: IntegrityMode::DigestOnly,
408 body: StoreBody::default(),
409 mac: None,
410 },
411 state: StoreState::Unstamped,
412 publication_sequence: 0,
413 expected_digest: None,
414 pending_anchor: None,
415 pending_prior_anchor: None,
416 warnings: Vec::new(),
417 activities: Vec::new(),
418 deferred_failure: None,
419 unanchored_ack: None,
420 booted_generation: None,
421 #[cfg(test)]
422 byte_limit: STORE_BYTE_LIMIT,
423 #[cfg(test)]
424 io_threads: None,
425 #[cfg(feature = "test-support")]
426 hooks: None,
427 };
428 if let Err(error) = store.start_check() {
429 store.state = if error.code == StoreErrorCode::StoreMissing {
430 StoreState::StoreMissing
431 } else {
432 StoreState::StoreUnverified
433 };
434 store.tamper_activity(&error.to_string());
435 store.warnings.push(error.to_string());
436 }
437 store
438 }
439
440 fn start_check(&mut self) -> Result<(), StoreError> {
441 let key = self.backend.load()?;
442 let bytes = disk::read(&self.path())
443 .map_err(|e| StoreError::new(StoreErrorCode::StoreUnverified, e))?;
444 self.expected_digest = bytes.as_deref().map(hash);
445 if key
448 .as_ref()
449 .is_some_and(|k| k.anchor.current.is_none() && k.anchor.high_water > 0)
450 {
451 if let Some(bytes) = &bytes {
452 if let Ok(envelope) = serde_json::from_slice::<Envelope>(bytes) {
453 if envelope.format_version == STORE_FORMAT_VERSION
454 && !envelope.body.stamped
455 && envelope.revision == key.as_ref().unwrap().anchor.high_water
456 && envelope.valid_mac(&key.as_ref().unwrap().key, bytes)
457 {
458 self.envelope = envelope;
459 }
460 }
461 }
462 self.warnings
463 .push("Sealed anchor is cleared; files are authoritative".into());
464 if self.envelope.revision == 0 {
465 self.warnings.push(
466 "Lost or replayed store: generation-id continuity is not guaranteed".into(),
467 );
468 }
469 self.envelope.integrity = IntegrityMode::Sealed;
470 self.envelope.revision = key.as_ref().unwrap().anchor.high_water;
471 return Ok(());
472 }
473 let Some(bytes) = bytes else {
474 if key.as_ref().is_some_and(|k| k.anchor.current.is_some()) {
475 return Err(StoreError::new(
476 StoreErrorCode::StoreMissing,
477 "anchored store is missing",
478 ));
479 }
480 return Ok(());
481 };
482 let value = serde_json::from_slice::<serde_json::Value>(&bytes);
483 if value
484 .as_ref()
485 .ok()
486 .and_then(|v| v.get("format_version"))
487 .and_then(|v| v.as_u64())
488 .is_some_and(|v| v != u64::from(STORE_FORMAT_VERSION))
489 {
490 return Err(StoreError::new(
491 StoreErrorCode::StoreUnverified,
492 "unsupported store format",
493 ));
494 }
495 let envelope = match serde_json::from_slice::<Envelope>(&bytes) {
499 Ok(envelope) if envelope.revision > 0 => envelope,
500 _ => {
501 return Err(StoreError::new(
502 StoreErrorCode::StoreUnverified,
503 "approved store is present but unparseable",
504 ))
505 }
506 };
507 if let Some(key) = key {
508 if let Some(anchor) = key.anchor.current {
509 let exact = self.expected_digest == Some(anchor.sha256)
510 && envelope.revision == anchor.revision;
511 let next = anchor.revision.checked_add(1) == Some(envelope.revision)
512 && envelope.previous_digest == Some(anchor.sha256)
513 && envelope.valid_mac(&key.key, &bytes);
514 if envelope.integrity != IntegrityMode::Sealed || !(exact || next) {
515 return Err(StoreError::new(
516 StoreErrorCode::StoreUnverified,
517 "sealed store does not match anchor",
518 ));
519 }
520 self.envelope = envelope;
521 if next {
522 self.pending_prior_anchor = Some(key.anchor);
523 self.pending_anchor = Some((
524 StoreAnchor {
525 revision: self.envelope.revision,
526 sha256: hash(&bytes),
527 },
528 self.envelope.body.stamped,
529 ));
530 if let Err(error) = self.retry_anchor() {
531 self.warnings.push(error.to_string());
532 }
533 }
534 self.state = if self.envelope.body.stamped || self.pending_anchor.is_some() {
535 StoreState::Stamped
536 } else {
537 StoreState::Unstamped
538 };
539 return Ok(());
540 }
541 }
542 if envelope.integrity == IntegrityMode::Sealed {
543 return Err(StoreError::new(
544 StoreErrorCode::StoreUnverified,
545 "sealed key missing or unavailable; restore key access",
546 ));
547 }
548 self.state = if envelope.body.stamped {
549 StoreState::Stamped
550 } else {
551 StoreState::Unstamped
552 };
553 self.envelope = envelope;
554 if self.backend.seal_available() {
555 self.warnings
556 .push("Re-stamp would seal this digest-only store".into());
557 }
558 Ok(())
559 }
560
561 fn path(&self) -> PathBuf {
562 self.root.0.join(STORE_FILE)
563 }
564 fn tamper_activity(&mut self, detail: &str) {
565 self.activities.push(StoreActivity {
566 event: "config.tamper",
567 detail: detail.into(),
568 });
569 }
570 fn usable(&self) -> Result<(), StoreError> {
571 match self.state {
572 StoreState::StoreMissing => Err(StoreError::new(
573 StoreErrorCode::StoreMissing,
574 "recovery required",
575 )),
576 StoreState::StoreUnverified => Err(StoreError::new(
577 StoreErrorCode::StoreUnverified,
578 "recovery required",
579 )),
580 _ => Ok(()),
581 }
582 }
583 pub fn check(&mut self) -> Result<(), StoreError> {
585 self.usable()?;
586 if self.envelope.integrity == IntegrityMode::Sealed {
587 #[cfg(test)]
588 self.observe_io_thread("keychain_load");
589 let valid = self.backend.load().ok().flatten().is_some_and(|key| {
590 let current = StoreAnchor {
591 revision: self.envelope.revision,
592 sha256: self.expected_digest.unwrap_or([0; 32]),
593 };
594 let covered = if self.envelope.body.stamped {
595 key.anchor.current == Some(current)
596 } else {
597 key.anchor.current.is_none() && key.anchor.high_water == current.revision
598 };
599 let waiting =
603 self.pending_anchor.is_some() && self.pending_prior_anchor == Some(key.anchor);
604 covered || waiting
605 });
606 if !valid {
607 self.state = StoreState::StoreUnverified;
608 self.tamper_activity(
609 "Sealed anchor changed or key access was lost while daemon was running",
610 );
611 return Err(StoreError::new(
612 StoreErrorCode::StoreUnverified,
613 "restore sealed key/anchor access",
614 ));
615 }
616 }
617 if self.state == StoreState::Unstamped && self.pending_anchor.is_none() {
618 return Ok(());
619 }
620 #[cfg(test)]
621 self.observe_io_thread("store_hash");
622 let actual = disk::read(&self.path()).map(|bytes| bytes.as_deref().map(hash));
623 if !matches!(actual, Ok(digest) if digest == self.expected_digest) {
624 self.state = StoreState::StoreUnverified;
625 self.tamper_activity("Approved store changed while daemon was running");
626 return Err(StoreError::new(
627 StoreErrorCode::StoreTampered,
628 "approved store changed",
629 ));
630 }
631 Ok(())
632 }
633 pub fn body(&mut self) -> Result<&StoreBody, StoreError> {
634 self.check()?;
635 Ok(self
636 .deferred_failure
637 .as_ref()
638 .or(self.unanchored_ack.as_ref().map(|ack| &ack.visible))
639 .unwrap_or(&self.envelope.body))
640 }
641 pub fn status(&mut self) -> StoreStatus {
642 let _ = self.check();
643 self.loaded_status()
644 }
645
646 pub(crate) fn loaded_status(&self) -> StoreStatus {
649 StoreStatus {
650 state: self.state,
651 integrity: self.envelope.integrity,
652 revision: self.envelope.revision,
653 base_revision: self.envelope.body.base_revision,
654 anchor_pending: self.pending_anchor.is_some(),
655 warnings: {
656 let mut warnings = self.warnings.clone();
657 if self.envelope.integrity == IntegrityMode::DigestOnly {
658 warnings.push("Digest-only: while the daemon is stopped, rewriting the store into another well-formed store, replay, deletion and data-home relocation are not detected".into());
659 }
660 warnings.push("Deleting the sealed key and rewriting the store as digest-only bypasses sealing; pre-gate binaries ignore the store".into());
661 warnings
662 },
663 }
664 }
665 pub fn take_activities(&mut self) -> Vec<StoreActivity> {
666 std::mem::take(&mut self.activities)
667 }
668 pub(crate) fn record_program_refusal(
669 &mut self,
670 module: &str,
671 approved_base: subc_config::Digest,
672 refused_identity: subc_config::Digest,
673 held_modules: &std::collections::BTreeSet<String>,
674 ) -> Result<(), StoreError> {
675 self.delivery_ready()?;
676 if self.state != StoreState::Stamped {
677 return Ok(());
678 }
679 let refusal = ProgramRefusal {
680 module: module.into(),
681 approved_base,
682 refused_identity,
683 };
684 if self.envelope.body.program_refusals.contains(&refusal) {
685 return Ok(());
686 }
687 let mut body = self.envelope.body.clone();
688 body.program_refusals.push(refusal);
689 while body.program_refusals.len() > PROGRAM_REFUSAL_LIMIT {
690 if let Some(index) = body
691 .program_refusals
692 .iter()
693 .position(|record| !held_modules.contains(&record.module))
694 {
695 body.program_refusals.remove(index);
696 } else {
697 tracing::warn!(
698 retained = body.program_refusals.len(),
699 limit = PROGRAM_REFUSAL_LIMIT,
700 "program refusal limit exceeded: every remaining record protects a held module"
701 );
702 break;
703 }
704 }
705 let result = self.publish(body, false, wall_time_ms());
706 if result.is_ok()
707 || result
708 .as_ref()
709 .is_err_and(|error| error.code == StoreErrorCode::AnchorPending)
710 {
711 self.activities.push(StoreActivity {
712 event: "config.refused",
713 detail: format!("{module}: program_refused; covered identity is not approved"),
714 });
715 }
716 result
717 }
718 pub fn delivery_ready(&mut self) -> Result<(), StoreError> {
720 self.check()?;
721 if self.pending_anchor.is_some() {
722 return Err(StoreError::new(
723 StoreErrorCode::AnchorPending,
724 "anchor update pending",
725 ));
726 }
727 Ok(())
728 }
729 pub fn retry_anchor(&mut self) -> Result<(), StoreError> {
730 self.check()?;
731 if let Some((pair, stamped)) = self.pending_anchor {
732 self.backend.anchor(pair, stamped)?;
733 self.pending_anchor = None;
734 self.pending_prior_anchor = None;
735 if let Some(ack) = self.unanchored_ack.take() {
736 if let Some(failure) = self.deferred_failure.as_mut() {
739 let still_pending = failure.versions.iter().any(|(tuple, versions)| {
740 tuple == &ack.tuple && versions.pending == Some(ack.generation)
741 });
742 let failed_module =
743 failure
744 .generations
745 .get(&ack.generation)
746 .is_some_and(|entry| {
747 entry.generation.never_redeliver.contains(&ack.tuple.module)
748 });
749 if still_pending && !failed_module {
750 if let Some((_, approved)) = self
751 .envelope
752 .body
753 .versions
754 .iter()
755 .find(|(tuple, _)| tuple == &ack.tuple)
756 {
757 if let Some((_, visible)) = failure
758 .versions
759 .iter_mut()
760 .find(|(tuple, _)| tuple == &ack.tuple)
761 {
762 *visible = approved.clone();
763 }
764 }
765 if let Some(entry) = failure.generations.get_mut(&ack.generation) {
766 entry
767 .generation
768 .module_states
769 .insert(ack.tuple.module, subc_config::GenerationState::Active);
770 if !entry
771 .generation
772 .module_states
773 .values()
774 .any(|state| *state == subc_config::GenerationState::Failed)
775 {
776 entry.outcome = "active".into();
777 }
778 }
779 }
780 }
781 }
782 self.state = if stamped {
783 StoreState::Stamped
784 } else {
785 StoreState::Unstamped
786 };
787 }
788 if let Some(body) = self.deferred_failure.take() {
789 if let Err(error) = self.publish(body.clone(), false, wall_time_ms()) {
790 self.deferred_failure = Some(body);
791 return Err(error);
792 }
793 }
794 Ok(())
795 }
796}
797
798fn hash(bytes: &[u8]) -> [u8; 32] {
799 Sha256::digest(bytes).into()
800}
801
802impl ConfigStore {
803 fn next_revision(&self, sealed: bool, fresh: bool) -> Result<u64, StoreError> {
804 let previous = if sealed {
805 self.backend
806 .load()?
807 .ok_or_else(|| {
808 StoreError::new(StoreErrorCode::StoreUnverified, "sealing key missing")
809 })?
810 .anchor
811 .high_water
812 } else if fresh {
813 disk::read(&self.path())
816 .ok()
817 .flatten()
818 .and_then(|b| serde_json::from_slice::<Envelope>(&b).ok())
819 .map_or(0, |e| {
820 if e.revision == u64::MAX {
821 0
822 } else {
823 e.revision
824 }
825 })
826 } else {
827 self.envelope.revision
828 };
829 previous.checked_add(1).ok_or_else(|| {
830 StoreError::new(
831 StoreErrorCode::RevisionExhausted,
832 "store revision exhausted",
833 )
834 })
835 }
836
837 fn publish(&mut self, body: StoreBody, fresh: bool, now_ms: u64) -> Result<(), StoreError> {
838 if self.pending_anchor.is_some() {
839 return Err(StoreError::new(
840 StoreErrorCode::AnchorPending,
841 "anchor update pending",
842 ));
843 }
844 if !fresh {
845 self.check()?;
846 } else {
847 self.expected_digest = disk::read(&self.path())
848 .map_err(|e| StoreError::new(StoreErrorCode::StoreUnverified, e))?
849 .as_deref()
850 .map(hash);
851 }
852 let sealed = self.envelope.integrity == IntegrityMode::Sealed;
853 let revision = self.next_revision(sealed, fresh)?;
854 let mut envelope = Envelope {
855 format_version: STORE_FORMAT_VERSION,
856 revision,
857 previous_digest: self.expected_digest,
858 integrity: self.envelope.integrity,
859 body,
860 mac: None,
861 };
862 let mut prior_anchor = None;
863 let key = if sealed {
864 let key = self
865 .backend
866 .load()?
867 .ok_or_else(|| StoreError::new(StoreErrorCode::StoreUnverified, "key missing"))?;
868 prior_anchor = Some(key.anchor);
869 Some(key)
870 } else {
871 None
872 };
873 #[cfg(test)]
874 let limit = self.byte_limit;
875 #[cfg(not(test))]
876 let limit = STORE_BYTE_LIMIT;
877 let bytes = loop {
878 envelope.mac = key
879 .as_ref()
880 .map(|key| envelope.authenticate(&key.key))
881 .transpose()?;
882 let bytes = serde_json::to_vec(&envelope).map_err(StoreError::serialization)?;
883 if bytes.len() <= limit {
884 break bytes;
885 }
886 if !envelope.body.prune_oldest(now_ms) {
887 return Err(StoreError::new(StoreErrorCode::StoreTooLarge,
888 format!("candidate exceeds STORE_BYTE_LIMIT ({limit} bytes); active, recovery and pending versions cannot be pruned")));
889 }
890 };
891 let next_publication = self.publication_sequence.checked_add(1).ok_or_else(|| {
892 StoreError::new(
893 StoreErrorCode::RevisionExhausted,
894 "publication sequence exhausted",
895 )
896 })?;
897 let path = self.path();
898 let publication_sequence = &mut self.publication_sequence;
899 if let Err(error) = disk::publish(&path, &bytes, |point| {
900 if point == disk::PausePoint::AfterRename {
903 *publication_sequence = next_publication;
904 }
905 #[cfg(feature = "test-support")]
906 if let Some(hooks) = &self.hooks {
907 hooks.pause(point)?;
908 }
909 let _ = point;
910 Ok(())
911 }) {
912 self.state = StoreState::StoreUnverified;
915 return Err(error.into());
916 }
917 self.expected_digest = Some(hash(&bytes));
918 self.state = if sealed || envelope.body.stamped {
919 StoreState::Stamped
920 } else {
921 StoreState::Unstamped
922 };
923 self.envelope = envelope;
924 if sealed {
925 self.pending_prior_anchor = prior_anchor;
926 self.pending_anchor = Some((
927 StoreAnchor {
928 revision,
929 sha256: hash(&bytes),
930 },
931 self.envelope.body.stamped,
932 ));
933 #[cfg(feature = "test-support")]
934 if let Some(hooks) = &self.hooks {
935 hooks.pause(disk::PausePoint::BeforeAnchor)?;
936 }
937 self.retry_anchor()?;
938 }
939 Ok(())
940 }
941
942 pub fn commit_generation(
946 &mut self,
947 mut entry: HistoryEntry,
948 approved: Snapshot,
949 observed: Snapshot,
950 now_ms: u64,
951 ) -> Result<u64, StoreError> {
952 self.delivery_ready()?;
953 let kind = entry.kind;
954 if entry.generation.approval_channel == subc_config::ApprovalChannel::DevelopmentPlacement
955 && kind != CommitKind::Development
956 {
957 return Err(StoreError::new(
958 StoreErrorCode::InvalidState,
959 "development placement is not an approval channel for this commit",
960 ));
961 }
962 if self.state == StoreState::Unstamped && kind != CommitKind::Stamp {
963 return Err(StoreError::new(
964 StoreErrorCode::InvalidState,
965 "first commit must be a stamp",
966 ));
967 }
968 if kind == CommitKind::Stamp {
969 self.select_stamp_mode()?;
970 }
971 let id = self
972 .envelope
973 .body
974 .last_generation
975 .checked_add(1)
976 .ok_or_else(|| {
977 StoreError::new(
978 StoreErrorCode::RevisionExhausted,
979 "generation ids exhausted",
980 )
981 })?;
982 entry.generation.id = id;
983 let mut body = self.envelope.body.clone();
984 body.last_generation = id;
985 body.base_revision = self.next_revision(
986 self.envelope.integrity == IntegrityMode::Sealed,
987 kind == CommitKind::Stamp,
988 )?;
989 body.stamped = kind != CommitKind::Unstamp;
990 if matches!(kind, CommitKind::Stamp | CommitKind::Unstamp) {
993 body.daemon = DaemonPointers {
994 active: id,
995 awaiting_restart: None,
996 restart: None,
997 };
998 } else if matches!(kind, CommitKind::Approved | CommitKind::Rollback)
999 && body.awaits_restart(&entry)
1000 {
1001 body.daemon.awaiting_restart = Some(id);
1002 }
1003 if kind != CommitKind::Development {
1006 body.approved = approved;
1007 if kind == CommitKind::Unstamp {
1008 body.program_refusals.clear();
1009 } else if !body.program_refusals.is_empty() {
1010 let snapshot = crate::config_gate::GateSnapshot::from_store(&body.approved)
1011 .map_err(StoreError::serialization)?;
1012 body.program_refusals.retain(|refusal| {
1013 crate::config_gate::program::approved_base(&snapshot, &refusal.module)
1014 == refusal.approved_base
1015 });
1016 }
1017 for tuple in &entry.tuples {
1018 let index = body
1019 .versions
1020 .iter()
1021 .position(|(t, _)| t == tuple)
1022 .unwrap_or_else(|| {
1023 body.versions.push((tuple.clone(), Versions::default()));
1024 body.versions.len() - 1
1025 });
1026 body.versions[index].1.pending = Some(id);
1027 }
1028 }
1029 body.generations.insert(id, entry);
1030 body.observed = if kind == CommitKind::Unstamp {
1031 None
1032 } else {
1033 Some(observed)
1034 };
1035 if kind == CommitKind::Stamp {
1036 body.proposal = None;
1037 }
1038 let proposal_changed = body.rebase_proposal()?;
1039 body.prune(now_ms);
1040 self.publish(body, kind == CommitKind::Stamp, now_ms)?;
1041 if proposal_changed {
1042 self.proposal_activity();
1043 }
1044 Ok(id)
1045 }
1046
1047 fn select_stamp_mode(&mut self) -> Result<(), StoreError> {
1048 if self.backend.seal_available() {
1049 if self.backend.load()?.is_none() {
1050 self.backend.create()?;
1051 }
1052 self.envelope.integrity = IntegrityMode::Sealed;
1053 } else {
1054 self.envelope.integrity = IntegrityMode::DigestOnly;
1055 }
1056 Ok(())
1057 }
1058
1059 pub fn recovery_exit(
1063 &mut self,
1064 mut entry: HistoryEntry,
1065 snapshot: Snapshot,
1066 now_ms: u64,
1067 ) -> Result<u64, StoreError> {
1068 if !matches!(
1069 self.state,
1070 StoreState::StoreUnverified | StoreState::StoreMissing
1071 ) || !matches!(entry.kind, CommitKind::Stamp | CommitKind::Unstamp)
1072 {
1073 return Err(StoreError::new(
1074 StoreErrorCode::InvalidState,
1075 "not a recovery exit",
1076 ));
1077 }
1078 self.select_stamp_mode()?;
1079 let revision =
1080 self.next_revision(self.envelope.integrity == IntegrityMode::Sealed, true)?;
1081 entry.generation.id = 1;
1082 let stamped = entry.kind == CommitKind::Stamp;
1083 let mut body = StoreBody {
1084 stamped,
1085 base_revision: revision,
1086 last_generation: 1,
1087 approved: snapshot,
1088 daemon: DaemonPointers {
1089 active: 1,
1090 awaiting_restart: None,
1091 restart: None,
1092 },
1093 ..StoreBody::default()
1094 };
1095 for tuple in &entry.tuples {
1096 body.versions.push((
1097 tuple.clone(),
1098 Versions {
1099 pending: Some(1),
1100 ..Versions::default()
1101 },
1102 ));
1103 }
1104 body.generations.insert(1, entry);
1105 body.prune(now_ms);
1106 self.pending_anchor = None;
1107 self.pending_prior_anchor = None;
1108 self.deferred_failure = None;
1109 self.unanchored_ack = None;
1110 self.publish(body, true, now_ms)?;
1111 self.warnings
1112 .push("Recovery reset history and generation ids; continuity is not guaranteed".into());
1113 Ok(1)
1114 }
1115
1116 fn proposal_activity(&mut self) {
1117 self.activities.push(StoreActivity {
1118 event: "config.proposal",
1119 detail: "Pending configuration diff changed".into(),
1120 });
1121 }
1122 pub fn observe(&mut self, snapshot: Snapshot) -> Result<bool, StoreError> {
1124 self.delivery_ready()?;
1125 let mut body = self.envelope.body.clone();
1126 body.observed = Some(snapshot);
1127 let changed = body.rebase_proposal()?;
1128 let identity_changed = body.proposal != self.envelope.body.proposal;
1129 if self.state == StoreState::Stamped && identity_changed {
1130 self.publish(body, false, wall_time_ms())?;
1131 } else if self.state == StoreState::Unstamped {
1132 self.envelope.body = body;
1133 }
1134 if changed {
1135 self.proposal_activity();
1136 }
1137 Ok(changed)
1138 }
1139
1140 pub fn record_delivery(
1150 &mut self,
1151 tuple: &Tuple,
1152 generation: u64,
1153 ack: bool,
1154 ) -> Result<(), StoreError> {
1155 self.check()?;
1156 let mut body = self
1157 .deferred_failure
1158 .as_ref()
1159 .or(self.unanchored_ack.as_ref().map(|ack| &ack.visible))
1160 .unwrap_or(&self.envelope.body)
1161 .clone();
1162 let before_ack = ack.then(|| body.clone());
1163 let Some((_, versions)) = body.versions.iter_mut().find(|(t, _)| t == tuple) else {
1164 return Ok(());
1165 };
1166 if versions.pending != Some(generation) {
1167 return Ok(());
1168 }
1169 if self.pending_anchor.is_some() && ack {
1170 return Err(StoreError::new(
1171 StoreErrorCode::AnchorPending,
1172 "ACK not recorded",
1173 ));
1174 }
1175 versions.pending = None;
1176 if ack {
1177 versions.recovery = versions.active;
1178 versions.active = Some(generation);
1179 }
1180 let entry = body
1181 .generations
1182 .get_mut(&generation)
1183 .ok_or_else(|| StoreError::new(StoreErrorCode::GenerationMissing, generation))?;
1184 entry.generation.module_states.insert(
1185 tuple.module.clone(),
1186 if ack {
1187 subc_config::GenerationState::Active
1188 } else {
1189 subc_config::GenerationState::Failed
1190 },
1191 );
1192 if !ack && !entry.generation.never_redeliver.contains(&tuple.module) {
1193 entry.generation.never_redeliver.push(tuple.module.clone());
1194 }
1195 entry.outcome = if ack { "active" } else { "failed" }.into();
1196 if self.pending_anchor.is_some() {
1197 self.deferred_failure = Some(body);
1198 if !self.warnings.iter().any(|w| w.contains("redeliver")) {
1199 self.warnings.push(
1200 "Failure held in memory while anchor is pending; restart may redeliver once"
1201 .into(),
1202 );
1203 }
1204 return Err(StoreError::new(
1205 StoreErrorCode::AnchorPending,
1206 "failure restored in memory; durable mark pending",
1207 ));
1208 }
1209 let result = self.publish(body, false, wall_time_ms());
1210 if ack && result.is_err() && self.pending_anchor.is_some() {
1211 self.unanchored_ack = before_ack.map(|visible| UnanchoredAck {
1212 visible,
1213 tuple: tuple.clone(),
1214 generation,
1215 });
1216 }
1217 result
1218 }
1219
1220 pub fn rollback_configuration(&mut self, generation: u64) -> Result<Snapshot, StoreError> {
1221 let body = self.body()?;
1222 if body.pruned.contains_key(&generation) {
1223 return Err(StoreError::new(
1224 StoreErrorCode::GenerationPruned,
1225 generation,
1226 ));
1227 }
1228 body.generations
1229 .get(&generation)
1230 .map(|e| e.configuration.clone())
1231 .ok_or_else(|| StoreError::new(StoreErrorCode::GenerationMissing, generation))
1232 }
1233}
1234
1235impl ConfigStore {
1236 pub fn resume_delivery(&mut self, tuple: &Tuple, generation: u64) -> Result<bool, StoreError> {
1239 self.delivery_ready()?;
1240 let mut body = self.envelope.body.clone();
1241 if !body
1242 .versions
1243 .iter()
1244 .any(|(t, v)| t == tuple && v.pending == Some(generation))
1245 {
1246 return Ok(false);
1247 }
1248 let entry = body
1249 .generations
1250 .get_mut(&generation)
1251 .ok_or_else(|| StoreError::new(StoreErrorCode::GenerationMissing, generation))?;
1252 if entry.generation.never_redeliver.contains(&tuple.module) {
1253 return Ok(false);
1254 }
1255 entry.outcome = "resumed".into();
1256 self.publish(body, false, wall_time_ms())?;
1257 Ok(true)
1258 }
1259}
1260
1261fn mark_daemon_failed(entry: &mut HistoryEntry) {
1262 entry
1263 .generation
1264 .module_states
1265 .insert(DAEMON_MODULE.into(), subc_config::GenerationState::Failed);
1266 if !entry
1267 .generation
1268 .never_redeliver
1269 .iter()
1270 .any(|module| module == DAEMON_MODULE)
1271 {
1272 entry.generation.never_redeliver.push(DAEMON_MODULE.into());
1273 }
1274 entry.outcome = "failed".into();
1275}
1276
1277impl ConfigStore {
1280 pub(crate) fn enter_recovery(&mut self, detail: &str) {
1283 self.state = StoreState::StoreUnverified;
1284 self.warnings
1285 .push(format!("Recovery required at daemon start: {detail}"));
1286 }
1287
1288 pub(crate) fn booted_generation(&self) -> Option<u64> {
1290 self.booted_generation
1291 }
1292
1293 pub(crate) fn select_boot_generation(&mut self) -> Result<u64, StoreError> {
1298 self.delivery_ready()?;
1299 let mut body = self.envelope.body.clone();
1300 let mut warm_up = None;
1301 let changed = match body.daemon.restart {
1302 None => false,
1303 Some(intent) if intent.attempted => {
1304 if let Some(entry) = body.generations.get_mut(&intent.generation) {
1305 mark_daemon_failed(entry);
1306 }
1307 self.warnings.push(format!(
1308 "Daemon restart into generation {} never became ready; it is marked failed",
1309 intent.generation
1310 ));
1311 body.daemon.restart = None;
1312 true
1313 }
1314 Some(intent) => {
1315 if body.bootable_generation(intent.generation)
1316 && Some(intent.generation) > body.active_daemon_generation()
1317 {
1318 warm_up = Some(intent.generation);
1319 body.daemon.restart = Some(RestartIntent {
1320 attempted: true,
1321 ..intent
1322 });
1323 } else {
1324 body.daemon.restart = None;
1325 }
1326 true
1327 }
1328 };
1329 let selected = warm_up.or_else(|| body.active_daemon_generation());
1330 if changed {
1331 self.publish(body, false, wall_time_ms())?;
1332 }
1333 let selected = selected.ok_or_else(|| {
1334 StoreError::new(
1335 StoreErrorCode::GenerationMissing,
1336 "no bootable approved daemon generation",
1337 )
1338 })?;
1339 self.booted_generation = Some(selected);
1340 Ok(selected)
1341 }
1342
1343 pub(crate) fn record_daemon_ready(&mut self) -> Result<(), StoreError> {
1346 let Some(booted) = self.booted_generation else {
1347 return Ok(());
1348 };
1349 let attempted = RestartIntent {
1350 generation: booted,
1351 attempted: true,
1352 };
1353 if self.state != StoreState::Stamped || self.envelope.body.daemon.restart != Some(attempted)
1354 {
1355 return Ok(());
1356 }
1357 let mut body = self.envelope.body.clone();
1358 body.daemon = DaemonPointers {
1359 active: booted,
1360 awaiting_restart: body.first_awaiting_restart_after(booted),
1361 restart: None,
1362 };
1363 self.publish(body, false, wall_time_ms())
1364 }
1365
1366 pub(crate) fn assign_daemon_restart(&mut self) -> Result<Option<u64>, StoreError> {
1369 self.delivery_ready()?;
1370 if self.state != StoreState::Stamped {
1371 return Ok(None);
1372 }
1373 let Some(generation) = self.envelope.body.restart_candidate() else {
1374 return Ok(None);
1375 };
1376 let intent = RestartIntent {
1377 generation,
1378 attempted: false,
1379 };
1380 if self.envelope.body.daemon.restart != Some(intent) {
1381 let mut body = self.envelope.body.clone();
1382 body.daemon.restart = Some(intent);
1383 self.publish(body, false, wall_time_ms())?;
1384 }
1385 Ok(Some(generation))
1386 }
1387}