use alloc::format;
use alloc::string::String;
use alloc::vec::Vec;
use paperpaw_sdk::install::marks::{From, Marks};
use paperpaw_sdk::install::{self, Progress};
use paperpaw_sdk::native::{self, Author, check_file, keys};
use paperpaw_sdk::{Commands, Env, Storage};
use crate::INSTALLER;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum Refusal {
Damaged,
OtherBuild,
Older,
Unsigned,
NotTheAuthor,
Unsupported,
Taken,
NoRoom,
KeyChanged,
}
impl Refusal {
pub(crate) fn key(self) -> &'static str {
match self {
Refusal::Damaged => "store.refused.damaged",
Refusal::OtherBuild => "store.refused.other-build",
Refusal::Older => "store.refused.older",
Refusal::Unsigned => "store.refused.unsigned",
Refusal::NotTheAuthor => "store.refused.not-the-author",
Refusal::Unsupported => "store.refused.unsupported",
Refusal::Taken => "store.refused.taken",
Refusal::NoRoom => "store.refused.no-room",
Refusal::KeyChanged => "store.refused.key-changed",
}
}
}
pub(crate) fn refusal_key(env: &Env<'_>, refusal: Refusal) -> &'static str {
if refusal == Refusal::NoRoom
&& crate::room::Room::of(env, None)
.code
.as_ref()
.is_some_and(crate::room::stock_flash)
{
return "store.refused.no-room-flash";
}
refusal.key()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum Verdict {
Install {
code: Option<Code>,
},
Refused(Refusal),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct Code {
pub(crate) author: [u8; 32],
pub(crate) sha256: [u8; 32],
pub(crate) recovery: Option<[u8; 32]>,
}
fn expected_path() -> String {
format!("{}/author.txt", Env::plugin_dir(crate::PLUGIN.as_str()))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Named {
pub(crate) author: [u8; 32],
pub(crate) recovery: Option<[u8; 32]>,
pub(crate) rotations: Vec<Rotation>,
}
pub(crate) const MAX_STEPS: usize = 8;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct Rotation {
pub(crate) to: [u8; 32],
pub(crate) signature: [u8; 64],
}
pub(crate) fn expect(storage: &dyn Storage, plugin: &str, named: Option<&Named>) {
let Some(named) = named else {
let _ = storage.remove(&expected_path());
return;
};
let hex = paperpaw_sdk::digest::hex::encode;
let mut text = format!("{plugin}\nauthor {}\n", hex(&named.author));
if let Some(recovery) = &named.recovery {
text.push_str(&format!("recovery {}\n", hex(recovery)));
}
for rotation in named.rotations.iter().take(MAX_STEPS) {
let (to, signature) = (hex(&rotation.to), hex(&rotation.signature));
text.push_str(&format!("rotation {to} {signature}\n"));
}
let _ = storage.write(&expected_path(), text.as_bytes());
}
fn expected(storage: &dyn Storage, plugin: &str) -> Option<Named> {
let text = paperpaw_sdk::read_file(storage, &expected_path(), 2048).ok()?;
let text = core::str::from_utf8(&text).ok()?;
let mut lines = text.lines();
if lines.next()? != plugin {
return None;
}
let (mut author, mut recovery, mut rotations) = (None, None, Vec::new());
for line in lines {
let mut words = line.split(' ');
match (words.next(), words.next(), words.next()) {
(Some("author"), Some(key), None) => author = bytes(key),
(Some("recovery"), Some(key), None) => recovery = bytes(key),
(Some("rotation"), Some(to), Some(signature)) if rotations.len() < MAX_STEPS => {
rotations.push(Rotation {
to: bytes(to)?,
signature: bytes(signature)?,
});
}
_ => {}
}
}
Some(Named {
author: author?,
recovery,
rotations,
})
}
fn bytes<const N: usize>(hex: &str) -> Option<[u8; N]> {
paperpaw_sdk::digest::hex::decode(hex)?.try_into().ok()
}
fn follow(storage: &dyn Storage, plugin: &str, key: &[u8; 32], steps: &[Rotation]) -> bool {
let Some(last) = steps.iter().position(|step| step.to == *key) else {
return false;
};
let mut moved = false;
for step in &steps[..=last] {
match keys::accept_rotation(storage, plugin, &step.to, &step.signature) {
Ok(()) => moved = true,
Err(_) if !moved => {}
Err(_) => return false,
}
}
native::known_author(storage, plugin) == Some(*key)
}
pub(crate) fn verdict(env: &Env<'_>, plugin: &str, folder: &str) -> Verdict {
let storage = env.storage();
let code = paperpaw_sdk::native::CODE_FILES
.iter()
.map(|name| format!("{folder}/{name}"))
.find(|path| storage.exists(path));
if !crate::catalog::may_install(env.plugins(), plugin, code.is_some()) {
return Verdict::Refused(Refusal::Taken);
}
let Some(code) = code else {
return Verdict::Install { code: None };
};
let Some(native) = env.native().filter(|native| code.ends_with(&*native.file)) else {
return Verdict::Refused(Refusal::Unsupported);
};
let (header, signature) = match check_file(storage, &code) {
Ok(checked) => checked,
Err(paperpaw_sdk::native::Problem::OlderFormat) => {
return Verdict::Refused(Refusal::Older);
}
Err(paperpaw_sdk::native::Problem::NewerFormat) => {
return Verdict::Refused(Refusal::OtherBuild);
}
Err(_) => return Verdict::Refused(Refusal::Damaged),
};
if !native.fits(&header) {
return Verdict::Refused(Refusal::OtherBuild);
}
let room = crate::room::Room::of(env, Some(plugin));
if let Some(code_room) = room.code {
let need = code_room.needs(u64::from(header.image_len), header.align);
if !code_room.fits(room.taken, room.plugins, need) {
return Verdict::Refused(Refusal::NoRoom);
}
}
let Some(signature) = signature else {
return Verdict::Refused(Refusal::Unsigned);
};
let key = signature.key;
let code = Code {
author: key,
sha256: header.sha256,
recovery: None,
};
match native::author(storage, plugin, &key) {
Author::Known => Verdict::Install { code: Some(code) },
Author::Other => match expected(storage, plugin) {
Some(named) if follow(storage, plugin, &key, &named.rotations) => {
Verdict::Install { code: Some(code) }
}
_ => Verdict::Refused(Refusal::KeyChanged),
},
Author::New => match expected(storage, plugin) {
Some(named) if named.author == key => Verdict::Install {
code: Some(Code {
recovery: named.recovery,
..code
}),
},
_ => Verdict::Refused(Refusal::NotTheAuthor),
},
_ => Verdict::Refused(Refusal::NotTheAuthor),
}
}
pub(crate) fn install(env: &Env<'_>, code: Option<Code>, out: &mut Commands) -> Option<Progress> {
let folder = INSTALLER.folder(env.storage())?;
install::adopt(env);
let from = match install::folder_version(env.storage(), &folder) {
Some(version) => From::Store(version),
None => From::Local,
};
let mut marks = Marks::new(from);
if let Some(code) = code {
marks = marks.code(code.sha256).author(code.author);
if let Some(recovery) = code.recovery {
marks = marks.recovery(recovery);
}
}
if install::marks::write(env.storage(), &folder, &marks).is_err() {
return None;
}
let _ = env.storage().remove(&expected_path());
INSTALLER.install(env, out)
}
fn told_path() -> String {
format!("{}/code-told", Env::plugin_dir(crate::PLUGIN.as_str()))
}
pub(crate) fn told(storage: &dyn Storage) -> bool {
storage.exists(&told_path())
}
pub(crate) fn tell(storage: &dyn Storage) {
let _ = storage.create_dir(&Env::plugin_dir(crate::PLUGIN.as_str()));
let _ = storage.write(&told_path(), b"");
}