Compare commits

...
2 Commits
6 changed files with 121 additions and 10 deletions
Generated
+1
View File
@@ -74,6 +74,7 @@ version = "0.1.0"
dependencies = [
"alkane-artifacts",
"alkane-core",
"sha2",
"thiserror",
]
+3
View File
@@ -12,6 +12,9 @@
The CI badge shows the last completed attempt for this branch while newer
runs are queued. Badge SVGs are stored in a private, machine-maintained branch.
The code-quality letter requires warnings-denied Clippy and measured test plus
UI self-test line coverage: A at 90%, B at 80%, C at 70%, D at 60%, and F
below 60%. A missing coverage measurement displays pending.
A cross-platform desktop toolkit for discovering, monitoring, and re-flashing
ASIC miners. It scans a fleet over the network, shows live health and hashrate
+19 -2
View File
@@ -11,6 +11,7 @@ Metrics not passed on the command line are computed here (LOC from the source
tree, dependency count from Cargo.lock, license from Cargo.toml).
"""
import argparse
import math
import os
import re
import sys
@@ -130,6 +131,17 @@ def cov_color(pct: float) -> str:
return "red"
def quality_grade(clippy: str, coverage: float | None) -> str:
if clippy != "clean":
return "F"
if coverage is None:
return "pending"
for minimum, grade in ((90, "A"), (80, "B"), (70, "C"), (60, "D")):
if coverage >= minimum:
return grade
return "F"
def human(n: int) -> str:
suffixes = ("", "K", "M", "G")
value = float(n)
@@ -160,6 +172,9 @@ def main() -> int:
ap.add_argument("--bench-delta", default=None)
ap.add_argument("--clippy", default="clean")
args = ap.parse_args()
for value in (args.coverage, args.bench_coverage):
if value is not None and (not math.isfinite(value) or not 0 <= value <= 100):
ap.error("coverage must be a finite percentage between 0 and 100")
os.makedirs(os.path.join(args.root, args.out), exist_ok=True)
@@ -176,8 +191,10 @@ def main() -> int:
write("loc", "lines of code", human(loc), loc_color(loc))
write("license", "license", lic, "blue")
write("dependencies", "dependencies", str(deps), "blue")
grade = "A" if args.clippy == "clean" else "F"
write("quality", "code quality", grade, "brightgreen" if grade == "A" else "red")
grade = quality_grade(args.clippy, args.coverage)
write("quality", "code quality", grade,
{"A": "brightgreen", "B": "yellowgreen", "C": "yellow",
"D": "orange", "F": "red", "pending": "lightgrey"}[grade])
if args.tests is not None:
write("tests", "tests", f"{args.tests} passing", "brightgreen")
if args.coverage is not None:
+20 -4
View File
@@ -52,6 +52,11 @@ impl VerifiedArtifact {
pub fn reader(&mut self) -> &mut File {
&mut self.file
}
/// Recheck the same descriptor immediately before a guarded write.
pub fn revalidate(&mut self) -> Result<(), VerifyError> {
verify_open_file(&mut self.file, &self.record)
}
}
pub fn seed_manifest() -> Result<Vec<ArtifactRecord>, VerifyError> {
@@ -118,9 +123,18 @@ fn signature_matches(format: &str, first: &[u8]) -> Result<bool, VerifyError> {
pub fn verify_file(path: &Path, record: &ArtifactRecord) -> Result<VerifiedArtifact, VerifyError> {
let mut file = File::open(path)?;
verify_open_file(&mut file, record)?;
Ok(VerifiedArtifact {
file,
record: record.clone(),
})
}
fn verify_open_file(file: &mut File, record: &ArtifactRecord) -> Result<(), VerifyError> {
if file.metadata()?.len() != record.size_bytes {
return Err(VerifyError::Size);
}
file.seek(SeekFrom::Start(0))?;
let mut first = [0_u8; 16];
let length = file.read(&mut first)?;
if !signature_matches(&record.format, &first[..length])? {
@@ -147,10 +161,7 @@ pub fn verify_file(path: &Path, record: &ArtifactRecord) -> Result<VerifiedArtif
return Err(VerifyError::Digest);
}
file.seek(SeekFrom::Start(0))?;
Ok(VerifiedArtifact {
file,
record: record.clone(),
})
Ok(())
}
#[cfg(test)]
@@ -189,9 +200,14 @@ mod tests {
applicability: "test".to_owned(),
};
let mut verified = verify_file(&path, &record).unwrap();
verified.revalidate().unwrap();
let mut replay = Vec::new();
verified.reader().read_to_end(&mut replay).unwrap();
assert_eq!(replay, bytes);
std::fs::write(&path, b"PK\x03\x04changed").unwrap();
assert!(matches!(verified.revalidate(), Err(VerifyError::Digest)));
std::fs::write(&path, bytes).unwrap();
verified.revalidate().unwrap();
record.size_bytes += 1;
assert!(matches!(
verify_file(&path, &record),
+1
View File
@@ -7,4 +7,5 @@ license.workspace = true
[dependencies]
alkane-core = { path = "../alkane-core" }
alkane-artifacts = { path = "../alkane-artifacts" }
sha2.workspace = true
thiserror.workspace = true
+77 -4
View File
@@ -3,6 +3,7 @@
//! Board transport adapters must supply serial, recovery and readback evidence.
use alkane_artifacts::VerifiedArtifact;
use sha2::{Digest, Sha256};
use std::io::{Read, Seek, SeekFrom};
use thiserror::Error;
@@ -65,6 +66,10 @@ pub enum FlashError {
ReadbackMismatch,
#[error("verified image has an invalid digest")]
InvalidDigest,
#[error("image changed since verification")]
ArtifactChanged,
#[error("writer did not consume the complete image")]
IncompleteWrite,
#[error("write transport: {0}")]
Write(String),
#[error("readback transport: {0}")]
@@ -85,6 +90,24 @@ fn digest_bytes(hex: &str) -> Result<[u8; 32], FlashError> {
Ok(result)
}
struct DigestReader<'a> {
inner: &'a mut dyn Read,
remaining: u64,
digest: Sha256,
}
impl Read for DigestReader<'_> {
fn read(&mut self, buffer: &mut [u8]) -> std::io::Result<usize> {
let limit = buffer
.len()
.min(usize::try_from(self.remaining).unwrap_or(usize::MAX));
let length = self.inner.read(&mut buffer[..limit])?;
self.remaining -= length as u64;
self.digest.update(&buffer[..length]);
Ok(length)
}
}
/// Stop before reboot. The caller must still prove live boot and persistence.
pub fn write_verified<W: Writer, R: IndependentReadback>(
partition: &PartitionSpec,
@@ -119,6 +142,9 @@ pub fn write_verified<W: Writer, R: IndependentReadback>(
return Err(FlashError::RecoveryRequired);
}
}
artifact
.revalidate()
.map_err(|_| FlashError::ArtifactChanged)?;
let backup = writer
.backup(partition)
.map_err(|e| FlashError::Write(e.to_string()))?;
@@ -133,9 +159,21 @@ pub fn write_verified<W: Writer, R: IndependentReadback>(
.reader()
.seek(SeekFrom::Start(0))
.map_err(|e| FlashError::ArtifactIo(e.to_string()))?;
let mut stream = DigestReader {
inner: artifact.reader(),
remaining: size,
digest: Sha256::new(),
};
writer
.write(partition, artifact.reader(), size)
.write(partition, &mut stream, size)
.map_err(|e| FlashError::Write(e.to_string()))?;
if stream.remaining != 0 {
return Err(FlashError::IncompleteWrite);
}
let written_digest: [u8; 32] = stream.digest.finalize().into();
if written_digest != expected {
return Err(FlashError::ArtifactChanged);
}
let actual = readback
.sha256(partition, size)
.map_err(|e| FlashError::Readback(e.to_string()))?;
@@ -162,6 +200,7 @@ mod tests {
serial: bool,
recovery: bool,
backup_bytes: u64,
max_read: Option<u64>,
writes: usize,
contents: Vec<u8>,
}
@@ -192,9 +231,16 @@ mod tests {
_: u64,
) -> Result<(), Self::Error> {
self.writes += 1;
image
.read_to_end(&mut self.contents)
.map_err(|_| "read failed")?;
if let Some(limit) = self.max_read {
image
.take(limit)
.read_to_end(&mut self.contents)
.map_err(|_| "read failed")?;
} else {
image
.read_to_end(&mut self.contents)
.map_err(|_| "read failed")?;
}
Ok(())
}
}
@@ -236,6 +282,7 @@ mod tests {
serial: true,
recovery: true,
backup_bytes: 4096,
max_read: None,
writes: 0,
contents: Vec::new(),
}
@@ -322,4 +369,30 @@ mod tests {
assert_eq!(writer.contents, IMAGE);
std::fs::remove_file(path).unwrap();
}
#[test]
fn refuses_changed_or_partially_consumed_artifacts() {
let (path, mut image) = artifact("changed");
let target = partition();
let mut writer = writer();
let mut readback = MockReadback {
channel: "serial",
digest: digest_bytes(SHA).unwrap(),
};
std::fs::write(&path, b"PK\x03\x04changed").unwrap();
assert!(matches!(
write_verified(&target, &mut image, &mut writer, &mut readback),
Err(FlashError::ArtifactChanged)
));
assert_eq!(writer.writes, 0);
std::fs::write(&path, IMAGE).unwrap();
writer.max_read = Some(4);
assert!(matches!(
write_verified(&target, &mut image, &mut writer, &mut readback),
Err(FlashError::IncompleteWrite)
));
assert_eq!(writer.writes, 1);
std::fs::remove_file(path).unwrap();
}
}