use std::collections::BTreeSet;
use anyhow::{Context, Result, anyhow, ensure};
use ed25519_dalek::{Signature, Signer, SigningKey, VerifyingKey};
use rusqlite::{Connection, OptionalExtension, params};
use serde::{Deserialize, Serialize};
use super::identity::{Epoch, IdentityTag};
use super::record::put_str;
use super::recovery_fingerprint;
use super::revocation::EpochCause;
use super::tables::query_envelopes;
use crate::sqlite_store::SqliteStore;
const RETIREMENT_DOMAIN: &[u8] = b"second-brain recovery retirement v1";
const RETIRED_PREFIX: &str = "recovery_retired:";
const RETIRED_END: &str = "recovery_retired;";
const FINGERPRINT_LEN: usize = 16;
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
pub struct Retirement {
pub identity_tag: String,
pub retirer: String,
pub fingerprint: String,
pub created_at_micros: i64,
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
pub struct SignedRetirement {
pub retirement: Retirement,
#[serde(with = "super::record::hex_array")]
pub signature: [u8; 64],
}
#[derive(Serialize, Deserialize)]
struct StoredRetirement {
identity_tag: String,
fingerprint: String,
signed: Option<SignedRetirement>,
#[serde(default)]
rotates: bool,
}
pub fn valid_fingerprint(text: &str) -> bool {
text.len() == FINGERPRINT_LEN
&& text
.bytes()
.all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))
}
impl Retirement {
pub fn signing_bytes(&self) -> Vec<u8> {
let mut out = Vec::with_capacity(96);
out.extend_from_slice(RETIREMENT_DOMAIN);
put_str(&mut out, &self.identity_tag);
put_str(&mut out, &self.retirer);
put_str(&mut out, &self.fingerprint);
out.extend_from_slice(&self.created_at_micros.to_be_bytes());
out
}
pub fn sign(self, key: &SigningKey) -> SignedRetirement {
let signature: Signature = key.sign(&self.signing_bytes());
SignedRetirement {
retirement: self,
signature: signature.to_bytes(),
}
}
}
impl SignedRetirement {
pub fn verify(&self, retirer_key: &VerifyingKey) -> Result<()> {
retirer_key
.verify_strict(
&self.retirement.signing_bytes(),
&Signature::from_bytes(&self.signature),
)
.map_err(|_| {
anyhow!(
"the retirement of recovery phrase {} by {} does not verify under the \
retirer's key",
self.retirement.fingerprint,
self.retirement.retirer
)
})
}
}
impl SqliteStore {
pub fn put_retirement(
&self,
signed: &SignedRetirement,
retirer_key: &VerifyingKey,
) -> Result<bool> {
signed.verify(retirer_key)?;
let retirement = &signed.retirement;
ensure!(
valid_fingerprint(&retirement.fingerprint),
"{:?} is not a recovery phrase fingerprint",
retirement.fingerprint
);
let key = retired_key(&retirement.identity_tag, &retirement.fingerprint);
self.with_txn(|tx| {
let mut stored = match read_retirement(tx, &key)? {
Some(stored) if stored.signed.is_some() => return Ok(false),
Some(stored) => stored,
None => StoredRetirement {
identity_tag: retirement.identity_tag.clone(),
fingerprint: retirement.fingerprint.clone(),
signed: None,
rotates: false,
},
};
stored.signed = Some(signed.clone());
write_retirement(tx, &key, &stored)?;
Ok(true)
})
}
pub fn note_named_retirements(&self, tag: &IdentityTag) -> Result<Vec<String>> {
let named: BTreeSet<String> = self
.key_epochs(tag)?
.into_iter()
.map(|stored| EpochCause::from_stored(stored.cause.as_deref()))
.collect::<Result<Vec<_>>>()?
.into_iter()
.flat_map(|cause| cause.retirements)
.filter(|fingerprint| valid_fingerprint(fingerprint))
.collect();
self.with_txn(|tx| {
let mut noted = Vec::new();
for fingerprint in named {
let key = retired_key(tag.as_str(), &fingerprint);
if read_retirement(tx, &key)?.is_some() {
continue;
}
let stored = StoredRetirement {
identity_tag: tag.as_str().to_string(),
fingerprint: fingerprint.clone(),
signed: None,
rotates: false,
};
write_retirement(tx, &key, &stored)?;
noted.push(fingerprint);
}
Ok(noted)
})
}
pub fn retirements(&self, tag: &IdentityTag) -> Result<Vec<SignedRetirement>> {
Ok(self
.retired_under(tag)?
.into_iter()
.filter_map(|(_, signed)| signed)
.collect())
}
pub fn retired_under(
&self,
tag: &IdentityTag,
) -> Result<Vec<(String, Option<SignedRetirement>)>> {
Ok(read_retirements(&self.reader())?
.into_iter()
.filter(|stored| stored.identity_tag == tag.as_str())
.map(|stored| (stored.fingerprint, stored.signed))
.collect())
}
pub fn retired_fingerprints(&self) -> Result<BTreeSet<String>> {
Ok(read_retirements(&self.reader())?
.into_iter()
.map(|stored| stored.fingerprint)
.collect())
}
pub fn rotating_retirements(&self, tag: &IdentityTag) -> Result<BTreeSet<String>> {
Ok(read_retirements(&self.reader())?
.into_iter()
.filter(|stored| stored.rotates && stored.identity_tag == tag.as_str())
.map(|stored| stored.fingerprint)
.collect())
}
pub fn mark_rotating_retirements(&self, tag: &IdentityTag) -> Result<Vec<String>> {
let listed: BTreeSet<String> = self
.device_records()?
.into_iter()
.filter(|row| !row.revoked && row.current.record.identity_tag == tag.as_str())
.flat_map(|row| row.current.record.recovery_fingerprints)
.collect();
let trusted = self.recovery_fingerprints_wrapped_to()?;
self.with_txn(|tx| {
let mut newly = Vec::new();
for mut stored in read_retirements(tx)? {
if stored.rotates
|| stored.identity_tag != tag.as_str()
|| !(listed.contains(&stored.fingerprint)
|| trusted.contains(&stored.fingerprint))
{
continue;
}
stored.rotates = true;
write_retirement(
tx,
&retired_key(&stored.identity_tag, &stored.fingerprint),
&stored,
)?;
newly.push(stored.fingerprint);
}
Ok(newly)
})
}
pub fn epochs_wrapped_to_retired(&self, tag: &IdentityTag) -> Result<Vec<Epoch>> {
let retired = self.retired_fingerprints()?;
let envelopes = query_envelopes(
&self.reader(),
"identity_tag = ?1 AND machine_id IS NULL",
params![tag.as_str()],
)?;
let mut epochs = Vec::new();
for envelope in envelopes {
if retired.contains(&recovery_fingerprint(&envelope.recipient))
&& !epochs.contains(&envelope.epoch)
{
epochs.push(envelope.epoch);
}
}
Ok(epochs)
}
pub fn delete_retired_envelopes(&self) -> Result<usize> {
let retired = self.retired_fingerprints()?;
if retired.is_empty() {
return Ok(0);
}
let recipients = self.recovery_recipient_texts()?;
self.with_txn(|tx| {
let mut deleted = 0;
for recipient in recipients
.iter()
.filter(|r| retired.contains(&recovery_fingerprint(r)))
{
deleted += tx.execute(
"DELETE FROM key_envelopes WHERE recipient = ?1 AND machine_id IS NULL",
params![recipient],
)?;
}
Ok(deleted)
})
}
fn recovery_fingerprints_wrapped_to(&self) -> Result<BTreeSet<String>> {
Ok(self
.recovery_recipient_texts()?
.iter()
.map(|r| recovery_fingerprint(r))
.collect())
}
fn recovery_recipient_texts(&self) -> Result<Vec<String>> {
let conn = self.reader();
let mut stmt =
conn.prepare("SELECT DISTINCT recipient FROM key_envelopes WHERE machine_id IS NULL")?;
let texts = stmt
.query_map([], |r| r.get::<_, String>(0))?
.collect::<rusqlite::Result<Vec<_>>>()?;
Ok(texts)
}
}
fn retired_key(identity_tag: &str, fingerprint: &str) -> String {
format!("{RETIRED_PREFIX}{identity_tag}:{fingerprint}")
}
fn read_retirement(conn: &Connection, key: &str) -> Result<Option<StoredRetirement>> {
let value: Option<String> = conn
.query_row(
"SELECT value FROM index_meta WHERE key = ?1",
params![key],
|r| r.get(0),
)
.optional()?;
value
.map(|text| serde_json::from_str(&text).with_context(|| format!("decoding stored {key}")))
.transpose()
}
fn write_retirement(conn: &Connection, key: &str, stored: &StoredRetirement) -> Result<()> {
conn.execute(
"INSERT OR REPLACE INTO index_meta (key, value) VALUES (?1, ?2)",
params![key, serde_json::to_string(stored)?],
)?;
Ok(())
}
fn read_retirements(conn: &Connection) -> Result<Vec<StoredRetirement>> {
let mut stmt = conn
.prepare("SELECT key, value FROM index_meta WHERE key >= ?1 AND key < ?2 ORDER BY key")?;
let rows = stmt.query_map(params![RETIRED_PREFIX, RETIRED_END], |r| {
Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?))
})?;
let mut out = Vec::new();
for row in rows {
let (key, value) = row?;
out.push(serde_json::from_str(&value).with_context(|| format!("decoding stored {key}"))?);
}
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::keys::{DeviceKeys, IdentityKey, RecoveryPhrase, wrap, wrap_for_recovery};
const TAG: &str = "f-tag";
fn key(seed: u8) -> SigningKey {
SigningKey::from_bytes(&[seed; 32])
}
fn retirement(fingerprint: &str) -> Retirement {
Retirement {
identity_tag: TAG.to_string(),
retirer: "a".to_string(),
fingerprint: fingerprint.to_string(),
created_at_micros: 1_000,
}
}
fn tag() -> IdentityTag {
IdentityTag::from(TAG.to_string())
}
#[test]
fn a_signed_retirement_verifies_and_tampering_any_field_breaks_it() {
let signed = retirement("0123456789abcdef").sign(&key(1));
signed.verify(&key(1).verifying_key()).unwrap();
assert!(signed.verify(&key(2).verifying_key()).is_err());
let cases: [(&str, fn(&mut Retirement)); 4] = [
("identity", |r| r.identity_tag = "f-other".into()),
("retirer", |r| r.retirer = "b".into()),
("fingerprint", |r| r.fingerprint = "0123456789abcdee".into()),
("time", |r| r.created_at_micros += 1),
];
for (field, tamper) in cases {
let mut edited = signed.clone();
tamper(&mut edited.retirement);
assert!(
edited.verify(&key(1).verifying_key()).is_err(),
"tampered {field} still verifies"
);
}
let text = serde_json::to_string(&signed).unwrap();
assert_eq!(
serde_json::from_str::<SignedRetirement>(&text).unwrap(),
signed
);
}
#[test]
fn only_a_fingerprint_shape_is_accepted() {
for (text, valid) in [
("0123456789abcdef", true),
("0123456789ABCDEF", false),
("0123456789abcde", false),
("0123456789abcdefa", false),
("0123456789abcdeg", false),
] {
assert_eq!(valid_fingerprint(text), valid, "{text}");
}
let store = SqliteStore::in_memory("a".to_string()).unwrap();
let bad = retirement("not-hex").sign(&key(1));
assert!(store.put_retirement(&bad, &key(1).verifying_key()).is_err());
assert!(store.retired_fingerprints().unwrap().is_empty());
}
#[test]
fn the_first_retirement_of_a_fingerprint_stays() {
let store = SqliteStore::in_memory("a".to_string()).unwrap();
let first = retirement("0123456789abcdef").sign(&key(1));
assert!(
store
.put_retirement(&first, &key(9).verifying_key())
.is_err()
);
assert!(
store
.put_retirement(&first, &key(1).verifying_key())
.unwrap()
);
let again = Retirement {
retirer: "b".to_string(),
..retirement("0123456789abcdef")
}
.sign(&key(2));
assert!(
!store
.put_retirement(&again, &key(2).verifying_key())
.unwrap()
);
assert_eq!(store.retirements(&tag()).unwrap(), vec![first]);
assert!(
store
.retirements(&IdentityTag::from("f-other".to_string()))
.unwrap()
.is_empty()
);
assert_eq!(
store.retired_fingerprints().unwrap(),
BTreeSet::from(["0123456789abcdef".to_string()])
);
}
#[test]
fn a_fingerprint_a_cause_names_is_retired_unsigned_until_its_retirement_arrives() {
let store = SqliteStore::in_memory("a".to_string()).unwrap();
let tag = tag();
let identity = IdentityKey::generate().unwrap();
let epoch = Epoch {
number: 2,
key_id: identity.key_id(),
};
let named = "0123456789abcdef";
let cause = EpochCause {
retirements: [named.to_string(), "junk".to_string()].into(),
..Default::default()
};
store
.put_key_epoch(&tag, &epoch, Some(&cause.to_json().unwrap()), 1)
.unwrap();
assert_eq!(store.note_named_retirements(&tag).unwrap(), vec![named]);
assert!(store.note_named_retirements(&tag).unwrap().is_empty());
assert_eq!(
store.retired_fingerprints().unwrap(),
BTreeSet::from([named.to_string()]),
"a malformed fingerprint is dropped"
);
assert_eq!(
store.retired_under(&tag).unwrap(),
vec![(named.to_string(), None)]
);
assert!(store.retirements(&tag).unwrap().is_empty());
let signed = retirement(named).sign(&key(1));
assert!(
store
.put_retirement(&signed, &key(1).verifying_key())
.unwrap()
);
assert_eq!(store.retirements(&tag).unwrap(), vec![signed]);
}
#[test]
fn a_fingerprint_retired_under_an_earlier_identity_is_retired_again_under_the_next() {
let store = SqliteStore::in_memory("a".to_string()).unwrap();
let earlier = Retirement {
identity_tag: "f-earlier".to_string(),
..retirement("0123456789abcdef")
}
.sign(&key(1));
store
.put_retirement(&earlier, &key(1).verifying_key())
.unwrap();
let now = retirement("0123456789abcdef").sign(&key(1));
assert!(store.put_retirement(&now, &key(1).verifying_key()).unwrap());
assert_eq!(store.retirements(&tag()).unwrap(), vec![now]);
}
#[test]
fn a_retired_phrase_is_trusted_by_no_wrap_and_its_envelopes_go() {
let store = SqliteStore::in_memory("a".to_string()).unwrap();
let identity = IdentityKey::generate().unwrap();
let tag = tag();
let epoch = Epoch {
number: 1,
key_id: identity.key_id(),
};
let device = DeviceKeys::generate().unwrap();
store
.put_envelope(
&wrap(
&identity,
1,
&tag,
&device.age_recipient(),
Some("a".into()),
)
.unwrap(),
)
.unwrap();
let (kept, retired) = (
RecoveryPhrase::generate().unwrap(),
RecoveryPhrase::generate().unwrap(),
);
let recipients = [kept.recipient().unwrap(), retired.recipient().unwrap()];
let held = [(epoch, &identity)];
assert_eq!(
wrap_for_recovery(&store, &tag, &held, &recipients).unwrap(),
2
);
let signed = retirement(&retired.fingerprint().unwrap()).sign(&key(1));
store
.put_retirement(&signed, &key(1).verifying_key())
.unwrap();
assert_eq!(store.epochs_wrapped_to_retired(&tag).unwrap(), vec![epoch]);
assert_eq!(
store.recovery_recipients(&tag).unwrap(),
vec![kept.recipient().unwrap()],
"a retired phrase leaves the trusted set at once"
);
assert_eq!(store.delete_retired_envelopes().unwrap(), 1);
assert!(store.epochs_wrapped_to_retired(&tag).unwrap().is_empty());
assert!(
store
.recovery_envelopes(&retired.recipient().unwrap())
.unwrap()
.is_empty()
);
assert_eq!(store.envelopes_for_machine("a").unwrap().len(), 1);
let second = Epoch {
number: 2,
key_id: identity.key_id(),
};
let held = [(second, &identity)];
assert_eq!(
wrap_for_recovery(&store, &tag, &held, &recipients).unwrap(),
1,
"only the phrase still trusted"
);
assert!(
store
.recovery_envelopes(&retired.recipient().unwrap())
.unwrap()
.is_empty()
);
}
#[test]
fn a_retirement_rotates_once_listed_or_trusted_and_stays_marked() {
let store = SqliteStore::in_memory("a".to_string()).unwrap();
let tag = tag();
let identity = IdentityKey::generate().unwrap();
let trusted = RecoveryPhrase::generate().unwrap();
let epoch = Epoch {
number: 1,
key_id: identity.key_id(),
};
wrap_for_recovery(
&store,
&tag,
&[(epoch, &identity)],
&[trusted.recipient().unwrap()],
)
.unwrap();
let made_up = "0123456789abcdef";
for fingerprint in [made_up.to_string(), trusted.fingerprint().unwrap()] {
store
.put_retirement(
&retirement(&fingerprint).sign(&key(1)),
&key(1).verifying_key(),
)
.unwrap();
}
assert_eq!(
store.mark_rotating_retirements(&tag).unwrap(),
vec![trusted.fingerprint().unwrap()]
);
store.delete_retired_envelopes().unwrap();
assert!(store.mark_rotating_retirements(&tag).unwrap().is_empty());
assert_eq!(
store.rotating_retirements(&tag).unwrap(),
BTreeSet::from([trusted.fingerprint().unwrap()]),
"the mark outlives the envelopes it was decided by"
);
}
}