use std::collections::{BTreeMap, BTreeSet};
use alien_error::AlienError;
use chrono::{DateTime, Duration, Utc};
use serde::{Deserialize, Serialize};
use crate::envelope::{Kind, Opened, Role, SignedStatement};
use crate::error::{ErrorData, Result};
use crate::key::PublicKey;
pub const MAX_SIGNERS: usize = 256;
pub const MAX_LIST_LIFETIME_DAYS: i64 = 90;
const CLOCK_SKEW_HOURS: i64 = 24;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum SignerKind {
Ci,
Device,
Recovery,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Signer {
pub id: String,
pub key: String,
pub kind: SignerKind,
pub roles: Vec<Role>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub label: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SignerListBody {
pub previous: Option<String>,
pub admin_threshold: u32,
pub signers: Vec<Signer>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub deny: Vec<String>,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub recovered: bool,
}
#[derive(Debug, Clone)]
pub struct TrustedList {
pub version: u64,
pub digest: String,
pub not_after: DateTime<Utc>,
pub body: SignerListBody,
keys: BTreeMap<String, (PublicKey, BTreeSet<Role>)>,
}
impl TrustedList {
pub fn signer(&self, id: &str) -> Option<(&PublicKey, &BTreeSet<Role>)> {
self.keys.get(id).map(|(key, roles)| (key, roles))
}
pub fn is_expired(&self, now: DateTime<Utc>) -> bool {
now > self.not_after
}
pub fn signer_kind(&self, id: &str) -> Option<SignerKind> {
self.body
.signers
.iter()
.find(|signer| signer.id == id)
.map(|signer| signer.kind)
}
pub fn denies(&self, digest: &str) -> bool {
self.body.deny.iter().any(|denied| denied == digest)
}
pub fn check_signatures(&self, opened: &Opened, role: Role) -> Result<BTreeSet<String>> {
let mut signers = BTreeSet::new();
for signature in &opened.signatures {
let (key, roles) = self.signer(&signature.signer).ok_or_else(|| {
refused_signature(
&signature.signer,
format!("not on signer list version {}", self.version),
)
})?;
if !roles.contains(&role) {
return Err(refused_signature(
&signature.signer,
format!("does not hold the '{}' role", role.as_str()),
));
}
key.verify(&opened.bytes, &signature.sig)
.map_err(|error| refused_signature(&signature.signer, error.message))?;
if !signers.insert(signature.signer.clone()) {
return Err(refused_signature(
&signature.signer,
"signed twice".to_string(),
));
}
}
if signers.is_empty() {
return Err(AlienError::new(ErrorData::Unsigned {
role: role.as_str().to_string(),
}));
}
Ok(signers)
}
fn admin_count(&self) -> usize {
self.keys
.values()
.filter(|(_, roles)| roles.contains(&Role::Admin))
.count()
}
}
#[derive(Debug, Clone)]
pub struct SignerChain {
project: String,
statements: Vec<SignedStatement>,
digests: Vec<String>,
current: TrustedList,
}
impl SignerChain {
pub fn genesis(
fingerprint: &str,
statement: &SignedStatement,
now: DateTime<Utc>,
) -> Result<Self> {
let opened = statement.open()?;
let version = opened.sequence;
let expected = fingerprint_digest(fingerprint)?;
let project = opened.project.clone();
if opened.digest != expected {
return Err(list_refused(
version,
format!(
"its digest {} does not match the pinned fingerprint {fingerprint}",
opened.digest
),
));
}
let list = parse_list(&project, &opened, 1, now)?;
if list.body.previous.is_some() {
return Err(list_refused(1, "version 1 names a previous version"));
}
if list.body.recovered {
return Err(list_refused(1, "version 1 can't be a recovery"));
}
let signers = list.check_signatures(&opened, Role::Admin)?;
if signers.len() < list.body.admin_threshold as usize {
return Err(list_refused(
1,
format!(
"signed by {} of its own admins, below its threshold of {}",
signers.len(),
list.body.admin_threshold
),
));
}
Ok(Self {
project,
statements: vec![statement.clone()],
digests: vec![opened.digest],
current: list,
})
}
pub fn from_statements(
fingerprint: &str,
statements: &[SignedStatement],
now: DateTime<Utc>,
) -> Result<Self> {
let mut opened = statements
.iter()
.map(|statement| statement.open().map(|opened| (opened.sequence, statement)))
.collect::<Result<Vec<_>>>()?;
opened.sort_by_key(|(sequence, _)| *sequence);
let ((_, first), rest) = opened
.split_first()
.ok_or_else(|| list_refused(1, "the chain is empty"))?;
let mut chain = Self::genesis(fingerprint, first, now)?;
let rest: Vec<SignedStatement> = rest
.iter()
.map(|(_, statement)| (*statement).clone())
.collect();
chain.extend(&rest, now)?;
Ok(chain)
}
pub fn digest_of(&self, version: u64) -> Option<&str> {
version
.checked_sub(1)
.and_then(|index| self.digests.get(index as usize))
.map(String::as_str)
}
pub fn current(&self) -> &TrustedList {
&self.current
}
pub fn project(&self) -> &str {
&self.project
}
pub fn statements(&self) -> &[SignedStatement] {
&self.statements
}
pub fn extend(&mut self, statements: &[SignedStatement], now: DateTime<Utc>) -> Result<bool> {
let mut opened = statements
.iter()
.map(|statement| statement.open().map(|opened| (opened, statement)))
.collect::<Result<Vec<_>>>()?;
opened.sort_by_key(|(opened, _)| opened.sequence);
let before = self.current.version;
for (opened, statement) in opened {
if opened.kind != Kind::SignerList {
return Err(list_refused(
opened.sequence,
format!("it is a '{}' statement", opened.kind),
));
}
let version = opened.sequence;
if version <= self.current.version {
if self.digest_of(version) != Some(opened.digest.as_str()) {
return Err(list_refused(
version,
"a different list with this version is already trusted",
));
}
continue;
}
self.advance(&opened, statement, now)?;
}
Ok(self.current.version > before)
}
fn advance(
&mut self,
opened: &Opened,
statement: &SignedStatement,
now: DateTime<Utc>,
) -> Result<()> {
let version = opened.sequence;
if version != self.current.version + 1 {
return Err(list_refused(
version,
format!(
"version {} is missing; the chain is at version {}",
self.current.version + 1,
self.current.version
),
));
}
let next = parse_list(&self.project, opened, self.current.version, now)?;
if next.body.previous.as_deref() != Some(self.current.digest.as_str()) {
return Err(list_refused(
version,
format!("it does not name version {}'s digest", self.current.version),
));
}
let signers = self.current.check_signatures(opened, Role::Admin)?;
let threshold = self.current.body.admin_threshold as usize;
if signers.len() < threshold {
return Err(list_refused(
version,
format!(
"signed by {} admins of version {}, below its threshold of {threshold}",
signers.len(),
self.current.version
),
));
}
let by_recovery = signers
.iter()
.any(|signer| self.current.signer_kind(signer) == Some(SignerKind::Recovery));
if by_recovery != next.body.recovered {
return Err(list_refused(
version,
if by_recovery {
"the recovery key signed it, but it isn't marked recovered"
} else {
"it is marked recovered, but the recovery key didn't sign it"
},
));
}
self.statements.push(statement.clone());
self.digests.push(opened.digest.clone());
self.current = next;
Ok(())
}
}
pub fn fingerprint(digest: &str) -> String {
format!(
"SHA256:{}",
digest.strip_prefix("sha256:").unwrap_or(digest)
)
}
pub fn display_fingerprint(fingerprint: &str) -> String {
let hex_part = fingerprint.strip_prefix("SHA256:").unwrap_or(fingerprint);
hex_part
.as_bytes()
.chunks(4)
.take(8)
.map(|chunk| String::from_utf8_lossy(chunk).to_uppercase())
.collect::<Vec<_>>()
.join(" ")
}
pub fn is_fingerprint(fingerprint: &str) -> bool {
fingerprint_digest(fingerprint).is_ok()
}
fn fingerprint_digest(fingerprint: &str) -> Result<String> {
let hex_part = fingerprint
.strip_prefix("SHA256:")
.filter(|hex_part| {
hex_part.len() == 64
&& hex_part
.bytes()
.all(|byte| matches!(byte, b'0'..=b'9' | b'a'..=b'f'))
})
.ok_or_else(|| {
AlienError::new(ErrorData::SettingsInvalid {
reason: format!("fingerprint '{fingerprint}' is not SHA256:<64 lowercase hex>"),
})
})?;
Ok(format!("sha256:{hex_part}"))
}
fn parse_list(
project: &str,
opened: &Opened,
authorizing_version: u64,
now: DateTime<Utc>,
) -> Result<TrustedList> {
let version = opened.sequence;
if opened.kind != Kind::SignerList {
return Err(list_refused(
version,
format!("it is a '{}' statement", opened.kind),
));
}
if opened.project != project || project.is_empty() {
return Err(AlienError::new(ErrorData::WrongProject {
expected: project.to_string(),
actual: opened.project.clone(),
}));
}
if opened.install.is_some() {
return Err(list_refused(version, "a signer list names no install"));
}
let not_after = opened
.not_after
.ok_or_else(|| list_refused(version, "it has no expiry"))?;
let latest = now + Duration::days(MAX_LIST_LIFETIME_DAYS) + Duration::hours(CLOCK_SKEW_HOURS);
if not_after > latest {
return Err(list_refused(
version,
format!(
"it expires at {}, more than {MAX_LIST_LIFETIME_DAYS} days from now",
not_after.to_rfc3339()
),
));
}
if version == 0 {
return Err(list_refused(version, "versions start at 1"));
}
if opened.signer_list_version != authorizing_version {
return Err(list_refused(
version,
format!(
"it says it is authorized by version {}, not {authorizing_version}",
opened.signer_list_version
),
));
}
let body: SignerListBody = opened.body()?;
if body.signers.len() > MAX_SIGNERS {
return Err(list_refused(
version,
format!("more than {MAX_SIGNERS} signers"),
));
}
let mut keys = BTreeMap::new();
let mut key_texts = BTreeSet::new();
for signer in &body.signers {
if !valid_signer_id(&signer.id) {
return Err(list_refused(
version,
format!("signer id '{}' is not 1-64 of [a-z0-9-]", signer.id),
));
}
let key = PublicKey::parse(&signer.key).map_err(|error| {
list_refused(
version,
format!("signer '{}': {}", signer.id, error.message),
)
})?;
if !key_texts.insert(key.as_str().to_string()) {
return Err(list_refused(
version,
format!("signer '{}' reuses a key already on the list", signer.id),
));
}
let roles: BTreeSet<Role> = signer.roles.iter().copied().collect();
if roles.is_empty() || roles.len() != signer.roles.len() {
return Err(list_refused(
version,
format!("signer '{}' has no roles or repeats one", signer.id),
));
}
if keys.insert(signer.id.clone(), (key, roles)).is_some() {
return Err(list_refused(
version,
format!("signer id '{}' appears twice", signer.id),
));
}
}
let list = TrustedList {
version,
digest: opened.digest.clone(),
not_after,
body,
keys,
};
let admins = list.admin_count();
let threshold = list.body.admin_threshold as usize;
if threshold == 0 || threshold > admins {
return Err(list_refused(
version,
format!("admin threshold {threshold} must be between 1 and its {admins} admins"),
));
}
Ok(list)
}
fn valid_signer_id(id: &str) -> bool {
(1..=64).contains(&id.len())
&& id
.bytes()
.all(|byte| matches!(byte, b'a'..=b'z' | b'0'..=b'9' | b'-'))
}
fn list_refused(version: u64, reason: impl Into<String>) -> AlienError<ErrorData> {
AlienError::new(ErrorData::SignerListRefused {
version,
reason: reason.into(),
})
}
fn refused_signature(signer: &str, reason: String) -> AlienError<ErrorData> {
AlienError::new(ErrorData::SignatureRefused {
signer: signer.to_string(),
reason,
})
}