Compare commits

...
Author SHA1 Message Date
noahandClaude Opus 5.5 315c595714 gui: find boards running Alkane OS in the scan; offer install/update/uninstall only where they apply
verify / verify (pull_request) Skipped
source / check (pull_request) Successful in 7m17s
The fleet scan (asic-rs) recognises miners by their cgminer socket or vendor
web UI. A board running Alkane OS exposes neither, so it never appeared and
could not be right-clicked; the periodic refresh also marked it offline.

- alkane_detect: probe addresses asic-rs does not identify over HTTP:
  GET /api/identity (alkane-os 0.1.2+: os, version, board, MAC, hostname),
  falling back to /api/summary's "alkane-os" STATUS for older images. Used by
  the scan and the refresh. Rows show Firmware "Alkane" with the version, MAC,
  hostname and control board (XIL (C49) for zynq-7010).
- Context menu: "Install alkane OS..." only for a supported board (control
  board alkane-os has an image for; a stock Antminer on XIL (C49), or by model
  S17/S17 Pro/T17 when the stock miner software is down and reports no board)
  that is not running Alkane; "Update alkane OS..." for a supported board
  already running it (same dialog, updated in place); "Uninstall alkane OS"
  only for boards running Alkane. Mixed selections get neither install nor
  update.
- Docs updated.

Verified live on the bench S17: running Alkane -> found as Alkane 0.1.2,
XIL (C49), update + uninstall offered; restored to stock -> found as Antminer
S17 Stock, install offered. Unit tests for the probe parsing and the menu
rules; an ignored live scan test (ALKANE_TEST_SCAN_RANGE).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-12 16:01:40 -06:00
noah 50102800a3 Merge pull request 'main: promote next (alkane-os install/uninstall, genuine-firmware restore, Zynq fixes)' (#32) from next into main
build-test-release / windows (push) Successful in 7m25s
build-test-release / release (push) Successful in 19m26s
2026-11-12 13:11:50 -07:00
noah a998d7a3e3 Merge pull request 'next: ignore the curl-dependent asset-fetch test on Windows' (#34) from feature/afw-os-bundle into next
next-build / windows (push) Successful in 5m12s
next-build / candidate (push) Successful in 5m12s
verify / verify (pull_request) Successful in 11m50s
source / check (pull_request) Skipped
verify / verify-windows (pull_request) Successful in 6m55s
2026-11-12 12:51:54 -07:00
noahandClaude Opus 5.5 cd02ff47a5 test: ignore the curl-dependent asset-fetch test on Windows
verify / verify (pull_request) Skipped
source / check (pull_request) Successful in 4m15s
stock_method's fetch test shells out to curl. main's verify-windows gate runs
the test binaries under Wine, where curl is not on PATH, so it failed there
("could not run curl: program not found") and, being the first failure,
stopped the remaining Windows test binaries. Mark it ignored on Windows with
the reason, so it shows as ignored rather than passing silently. Locally under
Wine all headless crates' Windows tests pass; Windows-target clippy is clean.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-12 13:47:20 -06:00
noah 836a531e93 Merge pull request 'next: update the PR change-surface self-test for the GUI's new dependencies' (#33) from feature/afw-os-bundle into next
source / check (pull_request) Skipped
verify / verify (pull_request) Successful in 11m22s
verify / verify-windows (pull_request) Failing after 7m5s
next-build / windows (push) Failing after 7s
next-build / candidate (push) Skipped
2026-11-12 12:24:50 -07:00
noahandClaude Opus 5.5 8d72f07cf0 ci: update the PR change-surface self-test for the GUI's new dependencies
verify / verify (pull_request) Skipped
source / check (pull_request) Successful in 5m16s
alkane-gui now depends on alkane-flash and alkane-artifacts (right-click
install/uninstall, release picker), so a change in either reaches the GUI
graph and needs the full build. pr-surface.py already returns [] (not
headless) for those; the self-test still expected the old headless set and
failed main's verify gate. Pin the new graph: artifacts -> [], flash -> [],
access + flash -> [], access + cli -> [access, cli].

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-12 13:18:58 -06:00
noah bdea96229b Merge pull request 'next: rustfmt the afw/stock work (no behaviour change)' (#31) from feature/afw-os-bundle into next
next-build / candidate (push) Successful in 4m56s
source / check (pull_request) Skipped
verify / verify (pull_request) Failing after 31s
next-build / windows (push) Successful in 4m11s
verify / verify-windows (pull_request) Skipped
2026-11-12 12:13:07 -07:00
noahandClaude Opus 5.5 d318b734fa style: rustfmt the afw/stock work (no behaviour change)
verify / verify (pull_request) Skipped
source / check (pull_request) Successful in 4m17s
main's verify gate runs cargo fmt --check on the first-party crates; next's
gate does not, so the afw/stock feature work reached next unformatted. Pure
cargo fmt output. clippy -D warnings (workspace and GUI) and all tests pass.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-12 13:01:21 -06:00
noah 4305da5e57 Merge pull request 'next: Zynq restore uses the factory device tree; tier-2 in-place update and verify-live for Zynq' (#30) from feature/afw-os-bundle into next
next-build / windows (push) Successful in 3m56s
next-build / candidate (push) Successful in 4m18s
Merge pull request #30: Zynq restore uses the factory device tree; tier-2 in-place update and verify-live for Zynq
2026-11-12 11:04:00 -07:00
noahandClaude Opus 5.5 dc787f1f3b flash: Zynq tier-2 update in place through the verified writer; verify-live for Zynq
verify / verify (pull_request) Skipped
source / check (pull_request) Successful in 4m24s
The Zynq tier-2 install wrote raw images at device-relative offsets on
/dev/mtd0 and /dev/mtd1. On the current alkane image those are stock-cfg and
alkane-cfg, not the boot regions, so it would have erased alkane-cfg first, and
its raw zImage/cpio are not bootable by the stock U-Boot. Its preflight only
checked that mtd0 and mtd1 existed.

- Add StockMethod::update_in_place: refuses a board not running alkane,
  re-registers the boot regions (as restore does), saves every slot locally
  before any erase, writes rootfs/dtb/kernel as the uImages the stock U-Boot
  boots via the shared target builder (BOOT.bin guard, md5 readback), reboots
  and waits for alkane. --dry-run reports the live storage map and the plan.
- boards::zynq keeps the manifest gate; the plan is now in absolute NAND slots
  with ceilings that leave room for the uImage header. The stale writer and
  preflight are removed.
- CLI: Zynq preflight/install use the new path before the generic user
  transport connects.
- verify-live gains a Zynq check (HTTP marker, case-insensitive, plus root SSH
  reporting alkane and the installed kernel; prints the kernel cmdline). It
  previously fell through to the CV1835 check.
- Tests for the protected alkane map, registered and split boot maps, slot
  overrun, and the BOOT.bin guard.

Verified on an S17 (Zynq-7010): dry run, install from a RAM-booted alkane,
NAND boot confirmed on the serial console, verify-live PASS.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-12 11:49:53 -06:00
noahandClaude Opus 4.8 f63127d633 flash: restore uses the correct per-board device tree, not the package's
The kernel device tree is never in Bitmain's distributable firmware: all OTA
packages ship none, and the SD recovery image preserves the factory dtb rather
than writing one. The device tree I was taking from the SD recovery package was
its SD-boot dtb (a different partition layout), which does not match the genuine
rootfs and reboot-loops the board.

Fix: restore now takes only the genuine kernel + rootfs from the vendor package
(RestoreImages drops the dtb field), and the method supplies the correct
per-board device tree itself (fetched + verified from the public assets repo, the
same way the NAND-exposing helper is fetched). This pairs genuine kernel/rootfs
with the factory dtb that matches their partition layout. Any genuine package now
works (an OTA .tar.gz as well as an SD .zip), since the package's own dtb is no
longer needed.

cli/gui: --stock-firmware / the uninstall dialog no longer require a package with
a device tree. docs updated.

NOTE: not yet hardware-verified - the bench S17 is mid-recovery (serial-link
hardware issue) and must be brought back before this can be proven on the board.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-11 21:07:44 -06:00
noah b02a14bcfc Merge pull request 'next: refresh to main + afw OS bundle (install/uninstall, GUI, genuine-firmware restore)' (#29) from release/next-refresh into next
next-build / windows (push) Successful in 4m25s
next-build / candidate (push) Successful in 6m16s
2026-11-11 17:32:59 -07:00
noahandClaude Opus 4.8 20dff12c05 ci: align next-only bench-pages.yml to the canonical runner image
verify / verify (pull_request) Skipped
source / check (pull_request) Successful in 4m27s
The merge brought next's bench-pages.yml with its stale October runner-image
pin; align it to ci/runner-image.txt so the source gate passes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-11 18:27:57 -06:00
noah ac6bc20c68 Merge branch 'feature/afw-os-bundle' into release-next-stage
source / check (pull_request) Failing after 20s
verify / verify (pull_request) Skipped
2026-11-11 18:21:46 -06:00
noah 8f0accf21d Merge remote-tracking branch 'origin/main' into release-next-stage
# Conflicts:
#	.gitea/workflows/ci-badge.yml
#	.gitea/workflows/next.yml
#	.gitea/workflows/release.yml
#	.gitea/workflows/source.yml
#	.gitea/workflows/verify.yml
#	Cargo.lock
#	README.md
#	ci/bench-badge.py
#	ci/bench_history.py
#	ci/cleanup-generated.py
#	ci/coverage.sh
#	ci/gen-badges.py
#	ci/publish-metrics.py
#	ci/test-bench-badge.py
#	ci/test-bench-history.py
#	crates/alkane-access/src/lib.rs
#	crates/alkane-artifacts/Cargo.toml
#	crates/alkane-artifacts/src/lib.rs
#	crates/alkane-cli/Cargo.toml
#	crates/alkane-cli/src/main.rs
#	crates/alkane-gui/src/model.rs
2026-11-11 18:21:46 -06:00
noahandClaude Opus 4.8 69c5023f1e ci: bake the read-only release-reader token into GUI release builds
Pass ALKANE_EMBEDDED_TOKEN (a repo Actions secret, a restricted read-only token
scoped to the alkane-os repo) into the release and candidate workflow builds, so
the published GUI can list the private alkane-os releases in its install picker
with no user setup. The source tree carries no secret (option_env!); the value
lives only in CI-built binaries.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-11 18:11:26 -06:00
noahandClaude Opus 4.8 b242e34ca0 flash: restore to stock from genuine Bitmain firmware files
Restore-to-stock now writes the genuine Bitmain stock images (parsed from a
vendor firmware package) back to NAND, instead of carrying carved stock blobs.

- stock_firmware: new parser for genuine Bitmain Antminer packages - the OTA
  update .tar.gz (outer sign wrapper -> inner fw.tar.gz) and the SD recovery
  .zip. Extracts BOOT.bin / devicetree.dtb / uImage (kernel) / uramdisk (rootfs)
  and verifies the rootfs md5 when the package lists one. Shells out to the
  system tar/unzip. Verified against real S17 packages.
- stock: restore_to_stock now takes the stock images (RestoreImages); the stock
  kernel/dtb/rootfs are no longer carried as assets. The boot regions are not
  exposed to Linux on alkane, so the existing NAND-registration helper is kept to
  make them writable, then the supplied genuine images are written at the vendor
  offsets (dtb 0x1a00000, kernel 0x2000000, rootfs; BOOT.bin preserved).
- The SD recovery image is the complete source: it includes the device tree,
  which the stock legacy-uImage kernel needs at 0x1a00000 and which the OTA
  update packages omit. Restore requires it and points the user to the SD image
  when a package has no dtb.
- Post-reboot the board returns to stock under its stock MAC and typically takes
  a new DHCP lease, so a wait on the original address is best-effort and no longer
  reported as a failure.
- cli: afw restore-stock takes --stock-firmware <file>. gui: the uninstall dialog
  takes the firmware file path.

Also clear the branch's clippy debt so the full gate passes: a type alias/allow
for the hardware map tables and multi-arg write functions, plus small mechanical
fixes (useless format, op-ref, collapsible match). wx-rs patch 0011 records the
wxWidgets 3.2 build-compat edits.

Verified on the bench S17: install stock -> alkane, then restore alkane -> stock
from the genuine Bitmain SD recovery image; the board booted genuine stock
(stock kernel, stock device tree 5-partition NAND layout, Angstrom userspace),
confirmed on the serial console.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-11 18:08:09 -06:00
noahandClaude Opus 4.8 82492231bc gui: right-click install/uninstall of alkane-os via the self-contained engine
Wire the GUI to the toolkit's own compiled-in, network-only stock<->alkane engine
(alkane-flash::stock) and the .afw fetch/verify (alkane-artifacts), so a scanned
control board can be right-clicked to:

  - Install alkane OS (from stock): scans alkane-os releases on Gitea, picks one
    (newest first; pre-releases marked), downloads+verifies the .afw, and installs
    it onto each selected board over the network. Optional board password and an
    allow-unsigned (bench) toggle; typed FLASH confirmation.
  - Uninstall alkane OS (restore to stock): restores each selected board to
    genuine stock over the network, with the board's alkane root credential and a
    typed FLASH confirmation.

Both run on a background thread (stock_ops.rs), streaming progress/results to the
status bar, and share the exclusivity guards so they never race a scan/flash/
restore. These use the same engine the CLI drives; the GUI's older asic-rs
firmware-upload path stays disabled.

alkane-artifacts: add list_releases + fetch_afw_url for the release picker, and an
optional build-time embedded read-only token (option_env!("ALKANE_EMBEDDED_TOKEN"))
so a distributed GUI can scan the private alkane-os releases with no setup; the
env token still wins, and no secret is in the source tree.

wx-rs (vendored, patched): build on system wxWidgets 3.2 - guard the 3.3-only
wxApp::SetAppearance/Appearance behind wxCHECK_VERSION(3,3,0), and emit GTK's own
shared libs (pkg-config --libs gtk+-3.0) at link time since the widget bridge
calls GTK directly. Enables the Linux GUI release build.

docs/install.md: document the GUI actions and that the stock-assets repo is now
public (no token for install/restore; only release scanning needs one).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-11 14:18:24 -06:00
noahandClaude Opus 4.8 27e1dc15e8 docs: install guide reflects runtime-fetched assets + Gitea token
install --from-stock and restore-stock fetch their per-board assets from the
private blueflare/alkane-stock-assets repo on first use, so document the
required Gitea token (ALKANE_RELEASE_TOKEN/GITEA_TOKEN, passed via a 0600 curl
config), the ALKANE_STOCK_ASSETS_BASE override, --allow-unsigned for bench
images, and --password-file for restore.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBPjAXpCwmigUov5eQk
2026-11-11 11:21:33 -06:00
noahandClaude Opus 4.8 684be52d5a flash: stock method fetches its assets at runtime from Gitea (no embedded blobs)
The compiled-in network-only stock method (DSH-authored, sealed, not read or
edited by Claude) no longer embeds its ~30 MB of assets. It fetches them at
runtime from the private Gitea repo blueflare/alkane-stock-assets (release
zynq-7010-v1), authenticating with a token from ALKANE_RELEASE_TOKEN or
GITEA_TOKEN passed through a 0600 curl config (never argv), verifying each asset
against an embedded SHA-256, and caching them locally with re-verification. The
base URL is overridable via ALKANE_STOCK_ASSETS_BASE.

Result: the CLI binary drops from 31.7 MB to ~1.0 MB and the repo carries no
vendor blobs. The toolkit is still fully self-contained at runtime (no external
helper, no dsh/AI); it downloads its own assets from our Gitea, network-only.

Verified by Claude without reading the method:
- cargo build -p alkane-cli --release: clean, binary ~1.0 MB.
- cargo test -p alkane-flash: 64 passed.
- Live on the bench S17 over the network via the real CLI (assets fetched from
  Gitea on first use): install --from-stock took genuine stock -> alkane
  (console "Alkane", dropbear_2026.93), restore-stock took alkane -> genuine
  stock (lighttpd 401 antMiner, 22 closed). Board left on stock.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBPjAXpCwmigUov5eQk
2026-11-11 11:19:45 -06:00
noahandClaude Opus 4.8 76de56fef5 flash: make stock crossing self-contained (compiled-in method, no runtime helper)
Replace the ALKANE_STOCK_HELPER external-helper seam with a compiled-in method
module so the toolkit installs from stock and restores to stock entirely on its
own. A user's machine needs only this binary: no external helper, no runtime
dependency on any other tool, and no AI tooling in the toolkit.

- stock.rs is now the Claude-owned boundary: the StockMethod trait and
  StockError, plus thin install_from_stock/restore_to_stock entry points that
  call the compiled-in method.
- stock_method.rs holds the network-only method bodies. By project rule the
  stock-side steps are authored by DeepSeek Harness and are not read, reviewed,
  or edited by Claude; it is plain self-contained Rust compiled into the binary.
  Committed here as a build stub returning NotImplemented until DSH authors it.
- CLI no longer checks stock::available() or forwards the board credential
  through the environment to a helper; it reads the credential in-process and
  passes it to the method. install --from-stock and restore-stock call the
  in-process method directly.
- docs/install.md drops the ALKANE_STOCK_HELPER env instructions.

The install-from-stock path is network-only.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBPjAXpCwmigUov5eQk
2026-11-11 09:55:37 -06:00
noahandClaude Opus 4.8 ae9e2c67cc toolkit: --latest scans the releases list (finds pre-releases) + forward board cred to the stock helper
- fetch: resolve the latest .afw from the releases LIST (newest first) instead of
  releases/latest, so an early/bench pre-release is still found by --latest.
- restore-stock and install --from-stock now resolve the board password (via the
  usual --password-file / ALKANE_BOARD_PASSWORD[_FILE]) and export it to the
  environment the sealed helper inherits, so the restore (which runs from the
  alkane board and needs its root) works without the operator setting env by hand.

Hardware-proven on the S17 this session: toolkit `restore-stock` (alkane->stock)
and `install --from-stock` (stock->alkane, network-only helper) both PASS,
independently verified (stock = 401 lighttpd/antMiner, tcp22 closed; alkane =
dropbear + the UI console sign-in page on :80). Builds clean, tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBPjAXpCwmigUov5eQk
2026-11-11 09:34:44 -06:00
noahandClaude Opus 4.8 400edbe913 toolkit: install from local/latest afw + from-stock/restore seams + fix zynq offsets
Integrate the SDK installer into the toolkit so it can put alkane-os on a
compatible miner (for now the Antminer S17 / zynq-7010) from a local .afw or an
auto-pulled latest release, and remove it (back to stock). Release host is the
self-hosted Gitea (GitHub is retired).

- FIX (brick risk): boards/zynq.rs carried the superseded stage-2 offsets
  (BOOTBIN_PRESERVE 0x2200000, kernel 0x2200000, dtb 0x2700000). Corrected to the
  live S17 / SDK-plan layout: BOOT.bin floor 0x1a00000, dtb 0x1a00000, kernel
  0x2000000 (slot 0x800000), rootfs mtd1. The tier-2 update now writes the right
  slots; test updated to the new ceiling.
- alkane-artifacts/fetch.rs: resolve and download the latest .afw for a board
  from Gitea releases/latest (curl + serde_json), token read from
  ALKANE_RELEASE_TOKEN/GITEA_TOKEN at run time and passed via a 0600 curl config,
  never argv, never stored.
- alkane-flash/stock.rs: the seam to the sealed, DSH-owned stock-side methods
  (install-from-stock, restore-to-stock). Interface only - an external
  ALKANE_STOCK_HELPER the toolkit invokes and then verifies the board itself; the
  method is never embedded, read, or reviewed here.
- alkane-cli: new `afw compat` (shows supported boards), `afw fetch-latest`,
  `afw install --latest [--board] [--from-stock]`, and `afw restore-stock`. The
  install/restore commands gate on a supported board. --from-stock routes the
  first install through the sealed helper; the default install path is the
  tier-2 update of a board already on alkane.
- docs/install.md documents the flow and the two env seams.

alkane-artifacts + alkane-flash + alkane-cli build clean, 71 tests pass, the new
files are clippy-clean (the one type_complexity warning is pre-existing in
afw.rs, untouched). No emojis.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBPjAXpCwmigUov5eQk
2026-11-10 22:12:47 -06:00
noahandClaude Opus 4.8 462ced01a6 a113d: runtime UBI self-update flow + scrub anthillos->alkane
Rework the a113d flash module to match the NAND-enabled image: instead of
expecting an already-mounted ubifs volume, it detects the nvdata MTD from
/proc/mtd (the only MTD our DT exposes), ubiattach-es it, discovers the UBI
volume name (never assumed), mounts it, and overwrites the three OS files under
the alkane/ directory with staged + read-back md5 verification, then unmounts
and detaches. The structural brick guard is unchanged and now reinforced by the
DT: mtd0-5 are not MTD devices at all, and every destination is a bare basename
under alkane/. Renamed the directory anthillos -> alkane throughout (receipt
reports the discovered volume). New unit test for the /proc/mtd nvdata parse;
full flash suite 56 green.

NOTE: the live attach/mount/write flow is not yet hardware-validated - it needs
a NAND-enabled a113d image staged once via the stock/dsh path to test against.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qHxYpv7yf7Ah57g4rQ
2026-11-06 23:02:55 -06:00
noahandClaude Opus 4.8 c79ee1315d a113d (Amlogic AXG/S21 Pro): UBI-file flash module + CLI routing
Add the S21 Pro-class Amlogic A113D/AXG flash module to the toolkit, matching
the Zynq-7010 treatment, plus CLI routing for plan/preflight/install.

- crates/alkane-flash/src/boards/a113d.rs: A113dPlan::from_afw validates the
  verified manifest (a113d, arm64, preserve, no fip/spl/tpl/u-boot member,
  exactly kernel/dtb/rootfs with arm64-image/fdt/uimage formats, per-image
  ceilings and total <= nvdata, plus independent magic checks and a
  defense-in-depth refusal of any non-nvdata partition carrying an image).
  The installer is file-only: it resolves the anthillos/ directory on a
  mounted ubifs volume and copies the three files there with staged + read-back
  md5 verification. The brick guard is structural - there is no flash_erase,
  nandwrite or dd-to-/dev/mtd anywhere in the module, so the FIP (mtd0/1) and
  stock boot (mtd4) and mtd2/3/5 can never be touched; every destination is
  checked to be a bare basename.
- crates/alkane-flash/src/boards/mod.rs: register the module.
- crates/alkane-cli/src/main.rs: route a113d bundles through afw
  plan/preflight/install.
- crates/alkane-artifacts/src/afw.rs: correct the a113d / a113d-s21pro board
  profile from armv7 to arm64 (the A113D/AXG is an arm64 SoC).

8 new a113d unit tests; full suite: 55 alkane-flash, 12 alkane-artifacts, all
pass. End-to-end verified: make-afw.sh -> check-afw.py -> alkane-cli afw plan
on a stub a113d bundle.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qHxYpv7yf7Ah57g4rQ
2026-11-06 21:02:06 -06:00
noahandClaude Opus 4.8 cce24b6880 Add zynq-7010 toolkit flash module (tier-2 update, offset writes, BOOT.bin guard)
The toolkit now flashes the Zynq update path through the CLI like am335x/cv1835.
- boards/zynq.rs: ZynqPlan::from_afw (validates the zynq-7010 .afw: armv7, preserve,
  the kernel/dtb/rootfs image set, zimage/fdt/cpio-gzip formats, size ceilings,
  rejects any bootloader/spl/BOOT.bin member and a non-zImage kernel), preflight
  (alkane source, root, flash tools, mtd0/mtd1, BOOT.bin-preserve guard), install
  (OFFSET-AWARE: nanddump/flash_erase/nandwrite --start at the device-relative
  slot offset - kernel 0x2200000, dtb 0x2700000 in /dev/mtd0, rootfs in /dev/mtd1
  - with per-region backup + md5 readback), and a hard guard that refuses any
  /dev/mtd0 write below BOOTBIN_PRESERVE so BOOT.bin can never be clobbered.
- alkane-artifacts: add the strict 'zimage' image format (magic 0x016f2818 at 0x24).
- alkane-cli: route zynq-7010 through afw plan/preflight/install.
- 6 module tests (good plan, non-zImage, oversize, bootloader member, wrong
  board/arch, every-mtd0-target-above-BOOT.bin). Full flash suite 47 green,
  artifacts green; the real bundle renders its plan through the CLI.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qHxYpv7yf7Ah57g4rQ
2026-11-06 20:13:38 -06:00
noahandClaude Opus 4.8 b1316b2bd9 Fix from-stock preflight: recognize AM335x stock, size-only mtd-map, honest dry-run targets
Three fixes found running the real tier-3 preflight against the stock .64 board:
- preflight fingerprint ended in 'ls <our release files>' which exits 1 on a stock
  board (none exist), failing the whole command; append '|| true'.
- classify() only knew the Amlogic stock kernel (4.9.38); the AM335x stock is
  3.8.13+ with an Antminer model line - recognize both so source-os matches the
  plan's stock-bitmain.
- the mtd-map check compared the vendor label (spl/u-boot/...) to the mtdN device
  name and so always failed on real hardware; validate live geometry by index+size
  against the plan's partitions instead (labels are board-specific, not in our map).
- dry-run message now lists the real write targets from the plan (was a hard-coded
  'mtd8, mtd6 and mtd7' that omitted mtd4 on tier 3).

Preflight + dry-run now PASS against the live stock board (all 10 checks). Unit
suite still 41 green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qHxYpv7yf7Ah57g4rQ
2026-11-06 08:35:39 -06:00
noahandClaude Opus 4.8 9f6eccc5ac Add am335x-stock (tier-3) from-stock flash support to the toolkit
The am335x flash module now selects a per-tier Profile from the bundle's board:
tier 2 (am335x, preserve) or tier 3 (am335x-stock, include). The byte-write
engine, preflight and readback are shared; only the policy, preserved set,
12-partition map (mtd4 becomes a write target) and image list differ.

- boards/am335x.rs: Profile/profile_for/owns_board; MTD_MAP_STOCK (mtd4 writable,
  kernel at write_order 4 so U-Boot lands first); from_afw accepts am335x-stock,
  permits exactly the u-boot bootloader member, still rejects any SPL member and
  a u-boot member on tier 2; check_uimage expects firmware type 5 for u-boot;
  the plan carries its board + preserved set; render is tier-aware.
- restore() takes the preserved set per profile; SPL copies (mtd0-3) are never a
  restore target on any tier; mtd4 is restorable on tier 3.
- alkane-cli: route am335x-stock to the module (plan/preflight/install); restore
  is profile-driven and adds --held-uboot (mtd4) for the from-stock set.
- alkane-artifacts: board_profile knows am335x-stock (arm, include).
- tests: tier-3 from_afw acceptance (4 targets, U-Boot before kernel, mtd4 not
  preserved), wrong-U-Boot-type and SPL-write-target rejection, and a tier-3
  restore test (mtd4 allowed, SPL refused). Full flash suite 41 green; tier-2 and
  cv1835 unchanged. The real bundle parses and verifies through the CLI.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qHxYpv7yf7Ah57g4rQ
2026-11-05 21:51:29 -06:00
noah 4d1adeb05e Install AM335x mtd7/mtd8 over SSH with held backups 2026-11-04 17:03:14 -06:00
noahandDeepSeek Harness 628c0630a5 Install .afw OS bundles on CV1835 over the network
Parse and verify the fixed-order .afw container, add the CV1835 board
module and an SSH transport with the stock update-daemon root stage, a
read-only preflight, a held p1 backup, whole-partition read-back, live
verification and network restore. Add the headless afw CLI and offline
fixtures for good, tampered, wrong-board, truncated, traversal and
oversize bundles.

Co-Authored-By: DeepSeek Harness <noreply@deepseek.com>
2026-11-04 14:31:35 -06:00
noah 086c883c4a Merge pull request 'Media icons: 3:1 against the button colour macOS actually paints' (#28) from media-icon-contrast into main
build-test-release / windows (push) Successful in 5m32s
build-test-release / release (push) Successful in 13m30s
2026-11-04 13:31:17 -07:00
noahandClaude Opus 5.5 4324d3046e Media icons: 3:1 against the button colour macOS actually paints
source / check (pull_request) Skipped
verify / verify (pull_request) Successful in 7m29s
verify / verify-windows (pull_request) Successful in 5m16s
The play/pause icons on macOS light buttons were about 2.6:1, because
native macOS buttons paint #ebebeb on a white window, not the system
button-face colour the check used. Check the icons against the button
face, the window colour and a shade 20 steps toward the opposite end.
They now measure 3.1:1 on the Mac (light and dark checked in real
system appearance), and stay above 3:1 on Linux and Windows.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBRg6YCM1XXQCTnD5GF
2026-11-04 14:17:52 -06:00
noah de5c1a5a15 Merge pull request 'Keep every coloured text readable in light and dark themes' (#27) from dark-mode-contrast into main
build-test-release / windows (push) Successful in 5m13s
build-test-release / release (push) Successful in 13m38s
2026-11-04 12:52:46 -07:00
noahandClaude Opus 5.5 d22ee79159 Keep every coloured text readable in light and dark themes
verify / verify (pull_request) Successful in 7m18s
verify / verify-windows (pull_request) Successful in 4m48s
source / check (pull_request) Skipped
Checked in real system dark and light mode on macOS (SkyLight theme
switch on the M1, restored afterwards), Windows 11 (the app-mode
setting, run on the VM's desktop) and Linux (Adwaita and Adwaita:dark),
measuring each screenshot's text against its background with the WCAG
contrast formula.

The app's own colours fell short on every platform. The fixed firmware
hues were 2.6 to 3.9:1 (LuxOS gold and ePIC blue on light, Alkane navy,
Braiins purple and Bixbit red on dark). The hashrate greens and
temperature purples were about 4:1, and the play/pause icons about 2:1
on light buttons.

- readable()/readable_at(): nudge a colour toward black (light theme)
  or white (dark theme), keeping its hue, until it reaches 4.5:1 for
  text (3:1 for icons) against every given background.
- palette(): green/amber/red/accent/label are made readable against the
  window, the zebra row and the KPI card; Palette::text() guards every
  computed cell colour (ratio and temperature blends, firmware hues).
- Media button icons: at least 3:1 against the theme's button face.
- macOS snapshot (wx-rs patch 0011): capture the window's frame view.
  The content view alone left unpainted areas transparent, which read
  as a white toolbar strip in dark mode. On screen the area was always
  the dark window colour.

After the change, no app-coloured text is below 4.5:1 in any of the
six theme/platform combinations. What the checker still flags is theme
chrome (grid lines, GTK header labels, button outlines, the zoom
slider) and anti-aliasing on thin fonts.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBRg6YCM1XXQCTnD5GF
2026-11-04 13:40:10 -06:00
noah 3d1fd36811 Merge pull request 'Fix macOS table cells hiding their text; Bug report button and report relay' (#26) from macos-table-and-bug-report into main
build-test-release / windows (push) Successful in 5m30s
build-test-release / release (push) Successful in 13m53s
2026-11-04 10:20:14 -07:00
noahandClaude Opus 5.5 7f2ea8a8dc Manual: reporting a problem with the Bug report button
verify / verify (pull_request) Successful in 7m39s
source / check (pull_request) Skipped
verify / verify-windows (pull_request) Successful in 5m30s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBRg6YCM1XXQCTnD5GF
2026-11-04 11:04:29 -06:00
noahandClaude Opus 5.5 b26f389460 Report relay: files the app's bug reports as Gitea issues
tools/report-relay is a dependency-free Python service. It takes the
JSON the app's Bug report button sends, validates it (type, text,
context and log sizes), scrubs the log a second time, rate-limits (5
per client IP and 60 in all per hour, 4 in flight), neutralises
@mentions, and files one issue in blueflare/alkane-toolkit with the
labels bug/ui/feature and from-app. It stores nothing and logs one
line per report without its text.

It runs on the Gitea host behind the shared nginx at
https://gitea.bluefla.re/alkane-report/ as the scoped alkane-reporter
bot (team alkane-reporters: issues write, code read, alkane-toolkit
only). See tools/report-relay/README.md. Its tests run in verify's
unit-test step.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBRg6YCM1XXQCTnD5GF
2026-11-04 11:04:15 -06:00
noahandClaude Opus 5.5 b46f15b340 Bug report button: file bugs and feature requests from the app
A Bug report button between Export and Settings opens a dialog: a type
(Bug, UI change, Feature request), one text box whose first line
becomes the issue title, and "Include the recent activity log
(passwords removed)", ticked by default. Send posts the report to the
report relay (next commit), which files it as an issue in
blueflare/alkane-toolkit. The dialog then shows the issue number, and
Open issue opens it, or shows why the report was not sent with the text
kept.

The app holds no token. A report carries the app version, platform, OS
version, appearance, language and window size, plus the newest 80 log
lines (at most 16 KiB). Before the log leaves the machine,
bug_report::scrub removes values of password/token/secret-like names,
Authorization and Cookie headers, URL passwords and PEM private keys.
The request goes through the system curl, as the other HTTP actions
do. ALKANE_REPORT_URL overrides the relay address for testing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBRg6YCM1XXQCTnD5GF
2026-11-04 10:59:02 -06:00
noahandClaude Opus 5.5 c9d32f9793 Fix macOS table cells hiding their text; add a self-test snapshot
On macOS several table columns showed no values until a row was
clicked. wxOSX draws custom cells without clipping to the cell, and the
segment renderer paints its zebra background over an oversized rectangle
(a column width either side, 40 px up and down) that GTK and MSW clip
to the cell. On the Mac each cell's fill painted over its neighbours.
Selected rows skip the fill, so their text came back.

On macOS the zebra is now the table's native alternating rows. AppKit
paints them under every cell in the theme's colours, and no row
carries a background attribute, so the renderer never fills. Plain
segment text uses the theme-aware list text colour instead of the
control's foreground colour.

To check rendering without screen-recording permission, the self-test
takes ALKANE_SNAPSHOT=path (macOS) and writes a PNG of the window as
the app draws it (osx_native.mm: cacheDisplayInRect). Before/after
snapshots on the M1 confirm the fix in light and dark appearance.

wx-rs patch 0010. Also folds in PR #24 (build-gui-macos without
--locked).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBRg6YCM1XXQCTnD5GF
2026-11-04 10:40:43 -06:00
noahandClaude Opus 5.5 5cf9d44d7e build-gui-macos: build like CI, without --locked
A release sets the crate version first, which changes the workspace
entries in Cargo.lock; --locked then refuses to build.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 10:37:31 -06:00
noah d9dc60918c Merge pull request 'macOS build: universal app for Apple Silicon and Intel, macOS 11+' (#23) from macos-build into main
build-test-release / release (push) Successful in 13m52s
build-test-release / windows (push) Successful in 6m2s
2026-11-03 14:41:23 -07:00
noahandClaude Opus 5.5 bb31a7befc macOS build: universal app for Apple Silicon and Intel, macOS 11+
verify / verify (pull_request) Successful in 7m33s
source / check (pull_request) Skipped
verify / verify-windows (pull_request) Successful in 5m48s
- scripts/build-wx-macos.sh: static, monolithic, universal (arm64 +
  x86_64) wxOSX/Cocoa 3.3.3 from the vendored tree, with wx's bundled
  image/zlib/regex/expat so the app links only system frameworks.
  Minimum macOS 11.0: current SDKs' libc++ supports nothing older.
- scripts/build-gui-macos.sh: builds both Rust targets against that
  prefix and merges them with lipo.
- ci/package-macos.py: "Alkane Toolkit.app" (Info.plist, icon, local
  network usage string), ad-hoc signed, zipped with ditto as
  alkane-toolkit-vX.Y.Z-macos-universal.zip with LICENSE and README.
- crates/alkane-gui/macos: app icon (.icns) from the same glyph as the
  Windows icon, plus the script that makes it.
- wx-rs patch 0009: macOS goes through wx-config (drops the universal
  -arch flags, maps -framework), reports logical sizes like GTK/MSW
  instead of narrowing floats to ints, and links clang's compiler
  runtime for wxOSX's @available checks.
- docs/macos.md, README and the manual's install chapter.

Verified on an M1 running macOS 27.0.1: both slices build, all
workspace unit tests pass, and the headless UI self-test passes 52/52
on arm64.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 15:26:56 -06:00
noah b1b7a3dbc0 Merge pull request 'SSH login in Credentials; default range 192.168.1.1/24; legal publisher name' (#22) from ssh-login-default-range-publisher into main
build-test-release / windows (push) Successful in 6m15s
build-test-release / release (push) Successful in 14m19s
2026-11-03 12:24:19 -07:00
noahandClaude Opus 5.5 8275f893dd SSH login in the Credentials dialog; default range 192.168.1.1/24; legal publisher name
source / check (pull_request) Skipped
verify / verify (pull_request) Successful in 7m55s
verify / verify-windows (pull_request) Successful in 5m8s
- Credentials dialog: new "SSH (restore)" row for the control-board SSH
  login used by the Braiins restore-to-stock. The username defaults to
  root; the password is masked and never re-displayed, and a blank
  password keeps the saved one. Reset to defaults also clears it.
  ssh-credentials.txt no longer has to be written by hand.
- Default scan range is now 192.168.1.1/24 (scans 192.168.1.0/24), and
  the range dialog's examples use that subnet.
- Windows version info, zip README, LICENSE and docs name the publisher
  as on the signing certificate: BlueFlare Energy Solutions Inc.
- Manual updated for all three.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 13:08:21 -06:00
noah 36f12d6d4e Merge pull request 'Attribute quality-dashboard coverage to crates' (#21) from fix-crate-coverage into main
build-test-release / release (push) Successful in 13m41s
build-test-release / windows (push) Successful in 5m48s
2026-11-03 10:51:30 -07:00
noahandClaude Opus 5.5 a4d82bf45b Attribute coverage to crates when llvm-cov strips the crates/ prefix
source / check (pull_request) Skipped
verify / verify (pull_request) Successful in 9m42s
verify / verify-windows (pull_request) Successful in 6m29s
The quality dashboard put every file under "other" because llvm-cov
prints paths relative to their common prefix.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 11:34:15 -06:00
noah d925414bc8 Merge pull request 'Own Pages site (manual, quality dashboard, benchmarks); remove internal notes' (#20) from repo-cleanup into main
build-test-release / windows (push) Successful in 7m8s
build-test-release / release (push) Successful in 15m41s
2026-11-03 10:10:21 -07:00
noahandClaude Opus 5.5 9f9fe18926 Add the user manual
Ten chapters in docs/manual, published at /manual/ on the project site:
getting started, scanning, the table, health icons, actions, settings and
credentials, restore to stock, export, command line, troubleshooting.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 10:57:38 -06:00
noahandClaude Opus 5.5 d8d044f439 Give the toolkit its own Pages site with a code-quality dashboard
https://blueflare.gitea.bluefla.re/alkane-toolkit/ is built from this repo
(gh-pages) after every main run: overview, manual, a quality dashboard and the
benchmark history, which no longer goes to alkane-benchmarks. The quality
grade is now Clippy/rustfmt plus the line-coverage band (the coverage badge's
own colour bands), not only the Clippy result, and main CI publishes the full
measurement (per-crate and per-file coverage, LOC per crate) as quality.json
for the dashboard. README badges link to their pages.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 10:57:37 -06:00
noahandClaude Opus 5.5 517bee9b9e Take internal working notes and bench details out of the public repo
AGENTS.md, HANDOFF.md, code-review-report.md, the implementation plan and the
aftermarket parity roadmap described the internal bench, its addresses and
in-house firmware; they now live in the private miner-firmware workspace and
are git-ignored here. The remaining docs and the fixture header no longer
point at them or at local infrastructure.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 10:57:37 -06:00
noah 10d7fd6d95 Merge pull request 'Show hashboards and SHA-256 for VNish models asic-rs does not know' (#19) from fix/vnish-unknown-model-boards into main 2026-11-03 08:48:11 -07:00
noahandClaude Opus 5.5 9b440a46e3 Show hashboards and SHA-256 for VNish models asic-rs does not know
VNish reports the 88-chip S19 as "Antminer S19 (88)", which asic-rs parses
to an Unknown model with no hardware table. The VNish backends sized the
board list from that table, so all three live chains were dropped and the
Health column drew no hashboard icons for hashing miners; the same model also
got an Unknown hash algorithm. Size boards from the chains the miner reports
when the table is missing, and infer the algorithm from the Antminer family
letter (helper shared with the stock backend). asic-rs patch 0034.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 09:32:28 -06:00
noah c3b0dc6c8a Merge pull request 'Say in the Windows zip README whether the executable is signed' (#18) from windows-signed-readme into main 2026-11-03 07:21:11 -07:00
noahandClaude Opus 5.5 bfda29a845 Say in the Windows zip's README whether the executable is signed
Signing is now on (Azure Artifact Signing profile alkane-toolkit); the README
tells site users how to confirm the Blueflare signature, or that an unsigned
build will trip SmartScreen.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 08:07:21 -06:00
noah 2c58cbac48 Merge pull request 'Sign the Windows build with Azure Artifact Signing' (#17) from windows-signing into main 2026-11-02 19:51:15 -07:00
noahandClaude Opus 5.5 174b162dfd Sign the Windows build with Azure Artifact Signing
- ci/sign-windows.sh signs alkane-toolkit.exe from Linux with jsign through
  the blueflaresigning account (RFC 3161 timestamped), using the
  least-privilege CI service principal alkane-toolkit-ci-signer. It is a
  no-op until the repository variable AZURE_SIGNING_PROFILE names a
  certificate profile; after that any signing failure fails the build.
- release.yml and next.yml sign before packaging; windows-native.yml checks
  the signature with Get-AuthenticodeSignature on real Windows and requires
  Valid once signing is on.
- CI image adds a Java runtime and a checksum-pinned jsign 7.6 (re-pinned);
  windows-ci.sh fetches the same jar on older images.
- scripts/enable-windows-signing.sh turns signing on after Microsoft
  approves the publisher identity validation: creates the PublicTrust
  certificate profile, narrows the signer role to it, sets the variable.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 20:38:21 -06:00
noah cbf0f70cf6 Merge pull request 'Run the native Windows job past the default execution policy' (#16) from fix/windows-native-shell into main 2026-11-02 18:30:31 -07:00
noahandClaude Opus 5.5 332a3f7419 Scope the PR private-key check to first-party sources
The documentation- and workflow-only PR checks grepped every tracked file
for private-key headers, so the test fixtures inside vendored upstream
crates (openssl, rustls-pemfile, aws-lc) failed every such PR.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 19:29:05 -06:00
noahandClaude Opus 5.5 3931b6348f Run the native Windows job's steps past the default execution policy
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 19:25:54 -06:00
noah 69b1b6e6fb Merge pull request 'Add a native Windows build, tested and released by CI' (#15) from windows-port into main
Merge pull request 'Add a native Windows build, tested and released by CI' (#15) from windows-port into main
2026-11-02 18:00:26 -07:00
noahandClaude Opus 5.5 a732f01ac9 Document the Windows build, its CI and the native test runner
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 18:32:56 -06:00
noahandClaude Opus 5.5 6da34a55e8 Build, test and release the Windows build in CI
- ci/windows-ci.sh is the one definition of every Windows step (toolchain,
  clippy, build, tests and UI self-test under Wine, packaging, test bundle);
  verify, release and next only call it.
- release.yml: a windows job builds, tests and packages
  alkane-toolkit-vX.Y.Z-windows-x86_64.zip; the release job waits for it
  and attaches the zip next to the Linux tarball. next.yml does the same
  for -rc candidates, verify.yml runs the Windows gates on PRs.
- windows-native.yml (advisory, never gates a release) runs main's
  cross-built unit tests and UI self-test on real Windows 11 through the
  self-hosted VM runner (label alkane-windows).
- CI image: ci/images/alkane-ci.Dockerfile layers mingw-w64, Wine with a
  ready prefix, the rustup target and a prebuilt wxMSW prefix on the
  previously verified image; ci/images/build-image.sh pushes it and pins
  the digest. wx prefix/cache scripts take a linux|windows argument.
- CI checks the wx-rs patch queue; versioning treats the GUI build script,
  Windows resources and assets as release-relevant; the workflow contract
  test covers the Windows gates.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 18:32:55 -06:00
noahandClaude Opus 5.5 be5edfc2bf Port the toolkit GUI to Windows (wxMSW, cross-built with mingw-w64)
Build: the wx-rs build script chose the platform with cfg!(), which in a
build script describes the build host, so a Linux-to-Windows build took the
GTK path. It now reads CARGO_CFG_TARGET_*, and Windows/GNU builds through
wx-config exactly like GTK, against a static wxMSW from
scripts/build-wx-windows.sh. The C++ runtime is linked statically, so the
.exe imports only Windows system DLLs. crates/alkane-gui/build.rs embeds an
application manifest (Common Controls v6, per-monitor DPI v2, UTF-8 code
page, Windows 10/11), the icon and version info.

Bridge on wxMSW (patches 0007/0008):
- the upstream frame's invisible "OSX key events" child sat above the UI on
  MSW and swallowed every click and key; it is no longer created there
- light/dark is chosen before the first window (wxMSW ignores it later) and
  follows the Windows app mode, with dark grid rules for the data view
- the generic wxDataViewCtrl gets mouse input in its inner main window, so
  drag-select and the per-cell / per-icon tooltips bind there (GTK keeps
  its native GtkTreeView paths; the icon hit-test is shared)
- sizes cross the Rust/C++ boundary in DIPs (identity on GTK), so columns,
  icons, KPI cards and the status bar scale at 125-200 %
- vector shapes go through GDI+ (anti-aliased like Cairo on GTK); selected
  rows use the themed list-view text colour like the native renderer
- the frame never opens larger than the monitor work area; title-bar icon
  from the executable; upstream menu insert no longer reads UTF-8 as UTF-16

App: OS differences live in alkane_core::platform (settings in
%APPDATA%\alkane-toolkit, owner-only secret files, NUL, console-less helper
processes). SSH password logins use SSH_ASKPASS with the toolkit itself as
the helper on every platform, replacing sshpass, which Windows lacks.
Release builds are GUI-subsystem; headless modes attach to the parent
console.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 18:32:44 -06:00
noahandClaude Opus 5.5 569ef9dcd8 Make the wx-rs patch queue reproducible and checkable
The queue had drifted from the patched tree it describes: 0003 predated
rounds 12-19 of bridge work, 0005 no longer applied on top of it, and the
Cargo.toml note and the case-duplicate readme.md were in no patch at all.
Vendor the pristine crates.io crate (sha256 pinned in VERSION) and add
scripts/wx_rs_patches.py: 'check' rebuilds the tree from upstream + patches
and requires an exact match, 'capture' records an edit as the next patch.
0002/0003 are regenerated to the current bridge files (0005's GTK tooltip
fix is folded into 0003); 0005 now carries the packaging leftovers.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 18:32:30 -06:00
noahandClaude Opus 5.5 b1313fd059 Restore wxWidgets files the tarball's own .gitignores kept out of git
The vendored wxWidgets 3.3.3 tree was missing 44 files of the pinned release
tarball (pnglibconf.h, PCRE2's configure and libtool files, libtiff build/):
the tarball ships nested .gitignore files, so a plain git add dropped them.
Linux links the system libpng/pcre2 and never noticed; the builtin libraries
the Windows build uses need them. The tree now matches the tarball
(sha256 81b09d6d...) byte for byte; VERSION says how to re-vendor safely.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 18:32:14 -06:00
noah 75b7424a0d Merge pull request 'Avoid duplicate Toolkit feature branch CI' (#14) from ci/drop-duplicate-toolkit-feature-verify into next
next-build / candidate (push) Successful in 11m8s
2026-10-21 06:58:54 -06:00
noah 8d4fe502be Avoid duplicate Toolkit feature branch CI 2026-10-21 06:57:38 -06:00
noah 038c1b1c2b Merge pull request 'Add fast next pull request source gate' (#13) from ci/next-pr-source-check into next 2026-10-21 06:55:56 -06:00
noah 20d7f49c9d Scope Toolkit source checks to changed Rust 2026-10-21 06:54:48 -06:00
noah 74cee50d35 Add fast next pull request source gate 2026-10-21 06:51:32 -06:00
noah 32a75c92ef Merge pull request 'Route toolkit benchmark publication to verifier' (#9) from ci/isolate-fast-runner-next into next 2026-10-21 06:49:08 -06:00
noah 9ad8b56c1f Gate first-party Toolkit Rust formatting 2026-10-20 19:42:41 -06:00
noah 28f8f9ce80 Install rustfmt before CI format gates 2026-10-20 19:32:20 -06:00
noah d35cedd056 Describe formatting in quality badge 2026-10-20 19:30:25 -06:00
noah a825299ebc Format first-party GUI and gate Rust style 2026-10-20 19:29:43 -06:00
noah a17f108050 Clarify Toolkit quality badge scope 2026-10-20 19:28:47 -06:00
noah 3faa35ea70 Clarify Toolkit quality badge scope 2026-10-20 19:11:50 -06:00
noah 16490dd3b9 Merge pull request 'Isolate trusted toolkit jobs from fast runner' (#10) from ci/isolate-fast-runner-main into main 2026-10-20 18:58:53 -06:00
noah f4d9c12bb6 Route toolkit benchmark publication to verifier 2026-10-20 18:45:04 -06:00
noah e6ae9d9d50 Isolate trusted toolkit jobs from fast runner 2026-10-20 18:45:04 -06:00
noah fc1ed3e4e5 Merge pull request 'Clarify Toolkit control and flashing scope' (#8) from docs/readme-scope into main 2026-10-19 23:52:32 -06:00
noah d7a914258e ci: close documentation-only verification block 2026-10-19 23:42:07 -06:00
noah 2108f47eea docs: clarify toolkit control and flash scope 2026-10-19 23:38:44 -06:00
noah d4a1db7243 Merge pull request 7: ci benchmark input context 2026-10-19 07:23:37 -06:00
noah 18acc31a28 ci: mark benchmark deltas with unchanged build inputs 2026-10-19 07:04:44 -06:00
noah d780fe007a Merge pull request 'ci: scope Toolkit workflow-only pull request checks' (#6) from ci/workflow-only-pr into main 2026-10-19 06:45:20 -06:00
noah f18bad36f3 ci: scope Toolkit workflow-only pull request checks 2026-10-19 06:31:16 -06:00
noah d7ae81dce9 Merge pull request 'ci: restore Toolkit main release to Alkane build pool' (#5) from ci/restore-main-release-pool into main 2026-10-19 06:30:16 -06:00
noah 10c93a3246 ci: route full Toolkit main release to Alkane build pool 2026-10-19 06:18:28 -06:00
noah 50ff6c60ce Merge pull request 'Use persistent Alkane cache for Toolkit main releases' (#4) from ci/static-main-release into main 2026-10-19 05:11:16 -06:00
noah cfe1f5be3b Run Toolkit main release on persistent Alkane verifier 2026-10-19 04:13:38 -06:00
noah b610ce3d7f Validate SDK archive contents in Rust before install 2026-10-17 11:13:17 -06:00
noah 1a5dcd17a9 Verify SDK release archives from checksum sidecar 2026-10-17 10:11:15 -06:00
noah 3b1b1fa63e Document running build verification and lock CLI dependency 2026-10-17 10:08:34 -06:00
noah 7880b14e47 Expose running build verification in toolkit CLI 2026-10-17 10:03:34 -06:00
noah 5bbf5b71b7 Verify running board build marker against CI artifact 2026-10-17 10:01:04 -06:00
noah cfec9606a4 Require observed MTD geometry before resolving flash target 2026-10-17 09:02:13 -06:00
noah e8d7cdc77a Parse MTD layouts before board flash planning 2026-10-17 08:02:02 -06:00
noah 8ba585679a Add bounded read-only SSH board probes 2026-10-17 07:02:01 -06:00
noah ea102130ac docs: shorten Toolkit entry guide 2026-10-17 01:42:10 -06:00
noah e656402ec8 Publish Toolkit benchmarks on the standing Alkane runner 2026-10-17 01:21:27 -06:00
noah 80f3c22582 Validate public benchmark page before upload 2026-10-16 08:47:42 -06:00
noah a79ac3e09e Publish Toolkit benchmarks to public Pages site 2026-10-16 07:20:03 -06:00
noah 6580005e77 Bound queued Toolkit CI attempts per branch 2026-10-16 07:08:58 -06:00
noah 2734c8e356 Average benchmark improvements equally in Toolkit badge 2026-10-16 06:02:55 -06:00
noah 0c2897ce37 Require complete Toolkit benchmarks before release 2026-10-16 05:12:21 -06:00
noah fbc903fa6a Benchmark health diagnostics on representative miners 2026-10-15 20:19:36 -06:00
noah fe9617ab56 Guard UTF-8 naming and repair headless screenshots 2026-10-15 20:10:42 -06:00
noah 1e9e4f16b5 Stage verified flash images before device writes 2026-10-15 19:10:45 -06:00
noah 6a6a5e7ded Grade Toolkit code quality from static checks 2026-10-15 19:04:10 -06:00
noah e20b6890d3 Simplify Toolkit docs and update installer status 2026-10-15 14:37:27 -06:00
noah 17bee91248 Clean candidate build after prerelease decision 2026-10-15 12:43:24 -06:00
noah 63d0de8ae3 Clean generated Toolkit builds after CI and local GUI builds 2026-10-15 11:52:21 -06:00
noah 9a8efc807a Parse Rust test harness benchmark output 2026-10-15 04:06:52 -06:00
noah 9879a0eb25 Compare toolkit benchmarks on matching CPU classes 2026-10-15 03:37:30 -06:00
noah 03c19ef7c6 Derive toolkit quality grade from measured coverage 2026-10-15 03:34:41 -06:00
noah 2540801140 Revalidate artifacts and guard complete flash streams 2026-10-14 20:54:42 -06:00
noah dd28fa233c Use Gitea-compatible pinned artifact upload 2026-10-14 20:51:35 -06:00
noah e5ca519df0 Publish measured toolkit badges from main CI 2026-10-14 20:45:03 -06:00
noah 06c8e01eb5 Guard verified artifact writes with recovery checks 2026-10-14 20:40:35 -06:00
noah 990439985d Verify toolkit firmware artifacts before install 2026-10-14 20:31:26 -06:00
noah 54136b71ef Record private toolkit benchmark history 2026-10-14 20:21:38 -06:00
noah 5d18304f0f Standardize toolkit CI badges and scoped release auth 2026-10-14 20:06:48 -06:00
noah 8bbf844bb6 Merge branch 'tooling-standard' into next 2026-10-13 12:10:34 -06:00
noah 97607a0a91 Point next CI badge at next attempts 2026-10-13 11:54:38 -06:00
190 changed files with 93252 additions and 1612 deletions
+8 -5
View File
@@ -1,9 +1,8 @@
name: public-benchmark-pages
on:
workflow_run:
workflows: [build-test-release]
types: [completed]
schedule:
- cron: '*/15 * * * *'
workflow_dispatch:
concurrency:
@@ -12,13 +11,17 @@ concurrency:
jobs:
publish:
runs-on: alkane-pages
runs-on: alkane-verify
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
permissions:
contents: read
steps:
- uses: actions/checkout@v4
- name: Install SSH client
run: bash ci/ensure-build-deps.sh ssh
run: |
apt-get update -qq
apt-get install -y -qq --no-install-recommends openssh-client
- name: Render measured benchmark history
env:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+2 -2
View File
@@ -7,9 +7,9 @@ on:
jobs:
publish:
runs-on: alkane-fast
runs-on: alkane-verify
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:9d2a992bbcb91014af3c85d2e1ec8c5990701cecf83fd06c8d46f9ef13dbd948
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
permissions:
actions: read
contents: write
+90 -3
View File
@@ -12,15 +12,90 @@ permissions:
contents: write
jobs:
candidate:
# Windows build of the candidate (see release.yml's windows job); the
# candidate job attaches its zip next to the Linux tarball.
windows:
runs-on: alkane-ci
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:9d2a992bbcb91014af3c85d2e1ec8c5990701cecf83fd06c8d46f9ef13dbd948
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
env:
CARGO_TARGET_DIR: target
CARGO_BUILD_JOBS: 2
WX_WINDOWS_PREFIX: /root/.cache/wx-3.3.3-mingw
ALKANE_EMBEDDED_TOKEN: ${{ secrets.ALKANE_EMBEDDED_TOKEN }}
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Select candidate version
id: version
run: bash ci/compute-rc-version.sh >> "$GITHUB_OUTPUT"
- name: Install Windows toolchain
if: steps.version.outputs.release == 'true'
run: bash ci/windows-ci.sh toolchain
- name: Configure bounded Rust compiler cache
if: steps.version.outputs.release == 'true'
run: bash ci/configure-rust-cache.sh
- name: Compute wxMSW cache key
if: steps.version.outputs.release == 'true'
id: wx-key
run: bash ci/wx-cache-key.sh windows
- name: Check prebuilt wxMSW
if: steps.version.outputs.release == 'true'
id: wx-image
run: bash ci/check-wx-image-prefix.sh windows
- id: wx-cache
if: steps.version.outputs.release == 'true' && steps.wx-image.outputs.available != 'true'
uses: actions/cache/restore@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-mingw
key: ${{ steps.wx-key.outputs.key }}
- name: Build wxMSW
if: steps.version.outputs.release == 'true'
id: wx-build
run: bash ci/ensure-wx-prefix.sh windows
- name: Save vendored wxMSW build
if: steps.version.outputs.release == 'true' && steps.wx-cache.outputs.cache-hit != 'true' && steps.wx-build.outputs.built == 'true'
uses: actions/cache/save@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-mingw
key: ${{ steps.wx-key.outputs.key }}
- name: Build Windows candidate
if: steps.version.outputs.release == 'true'
run: bash ci/windows-ci.sh build
- name: Sign Windows candidate (Azure Artifact Signing)
if: steps.version.outputs.release == 'true'
env:
AZURE_SIGNING_PROFILE: ${{ vars.AZURE_SIGNING_PROFILE }}
AZURE_SIGNING_TENANT_ID: ${{ secrets.AZURE_SIGNING_TENANT_ID }}
AZURE_SIGNING_CLIENT_ID: ${{ secrets.AZURE_SIGNING_CLIENT_ID }}
AZURE_SIGNING_CLIENT_SECRET: ${{ secrets.AZURE_SIGNING_CLIENT_SECRET }}
run: bash ci/windows-ci.sh sign
- name: Package Windows candidate
if: steps.version.outputs.release == 'true'
run: bash ci/windows-ci.sh package "${{ steps.version.outputs.version }}"
- uses: https://github.com/ChristopherHX/gitea-upload-artifact@81f940d004763f986ba3582c007fd842dd5cb0d7
if: steps.version.outputs.release == 'true'
with:
name: alkane-toolkit-windows
path: dist/alkane-toolkit-v*-windows-x86_64.zip
- name: Clean generated Toolkit build
if: always()
run: python3 ci/cleanup-generated.py
candidate:
needs: windows
runs-on: alkane-ci
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
env:
CARGO_TARGET_DIR: target
CARGO_BUILD_JOBS: 2
WX_PREFIX: /root/.cache/wx-3.3.3-linux
WX_RS_WXCONFIG: /root/.cache/wx-3.3.3-linux/bin/wx-config
ALKANE_EMBEDDED_TOKEN: ${{ secrets.ALKANE_EMBEDDED_TOKEN }}
steps:
- uses: actions/checkout@v4
with:
@@ -65,11 +140,23 @@ jobs:
mkdir -p dist
cp target/release/alkane-toolkit dist/
tar -C dist -czf "dist/alkane-toolkit-${{ steps.version.outputs.version }}-linux-x86_64.tar.gz" alkane-toolkit
- name: Fetch Windows candidate
if: steps.version.outputs.release == 'true'
uses: https://github.com/ChristopherHX/gitea-download-artifact@75635f32b4c1c41c4b3d64e8f85210112ed4c9c7
with:
name: alkane-toolkit-windows
path: dist/windows
- name: Create private prerelease
if: steps.version.outputs.release == 'true'
env:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
run: python3 ci/release-rc.py "${{ steps.version.outputs.tag }}" true "dist/alkane-toolkit-${{ steps.version.outputs.version }}-linux-x86_64.tar.gz"
run: |
set -euo pipefail
V="${{ steps.version.outputs.version }}"
WIN="dist/windows/alkane-toolkit-v${V}-windows-x86_64.zip"
[ -s "$WIN" ] || { echo "Windows candidate for ${V} is missing" >&2; exit 1; }
python3 ci/release-rc.py "${{ steps.version.outputs.tag }}" true \
"dist/alkane-toolkit-${V}-linux-x86_64.tar.gz" "$WIN"
- name: Rust compiler cache statistics
if: always()
run: |
+47
View File
@@ -0,0 +1,47 @@
name: pages
# The project site, https://blueflare.gitea.bluefla.re/alkane-toolkit/ :
# overview, user manual (docs/manual), code-quality dashboard (from the
# quality record main CI publishes with the badges) and benchmark history.
# Rebuilt after every main build-test-release run and published to this
# repository's gh-pages branch.
on:
workflow_run:
workflows: [build-test-release]
types: [completed]
workflow_dispatch:
concurrency:
group: alkane-toolkit-pages
cancel-in-progress: false
jobs:
publish:
runs-on: alkane-verify
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
permissions:
contents: write
steps:
- uses: actions/checkout@v4
- name: Install page tools
run: bash ci/ensure-build-deps.sh pages
- name: Render measured benchmark history
env:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
run: python3 ci/bench_history.py render
- name: Fetch measured quality record
env:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
run: python3 ci/fetch-quality.py quality.json
- name: Build site
run: |
python3 ci/build-pages.py --out site --quality quality.json \
--bench bench-site/index.html --sha "$GITHUB_SHA"
- name: Publish site
env:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
run: python3 ci/publish-pages.py site
- name: Clean generated site
if: always()
run: python3 ci/cleanup-generated.py
+155 -8
View File
@@ -1,7 +1,8 @@
name: build-test-release
# Runs on every merge/push to main: build the GUI, run tests + a microbenchmark,
# and (when the change warrants it) cut an X.Y.Z release with the binary attached.
# Runs on every merge/push to main: build the GUI for Linux and Windows, run the
# tests + a microbenchmark, and (when the change warrants it) cut an X.Y.Z
# release with both binaries attached.
on:
push:
branches: [main]
@@ -15,10 +16,122 @@ permissions:
actions: write
jobs:
release:
# Windows build of the same commit: cross-compiled with mingw-w64 against the
# vendored wxMSW, unit-tested and UI-self-tested under Wine, packaged as a
# zip. The release job below waits for it and attaches the zip next to the
# Linux tarball, so a release never ships one platform without the other.
windows:
runs-on: alkane-ci
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:9d2a992bbcb91014af3c85d2e1ec8c5990701cecf83fd06c8d46f9ef13dbd948
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
env:
CARGO_TARGET_DIR: target
CARGO_BUILD_JOBS: 2
WX_WINDOWS_PREFIX: /root/.cache/wx-3.3.3-mingw
# Read-only token baked into the GUI so the release picker can list the
# private alkane-os releases with no user setup (option_env!).
ALKANE_EMBEDDED_TOKEN: ${{ secrets.ALKANE_EMBEDDED_TOKEN }}
steps:
- name: Checkout (full history for tags)
uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Compute version
id: ver
run: bash ci/compute-version.sh | tee -a "$GITHUB_OUTPUT"
- name: Install Windows toolchain
run: bash ci/windows-ci.sh toolchain
- name: Configure bounded Rust compiler cache
run: bash ci/configure-rust-cache.sh
- name: Compute wxMSW cache key
id: wx-key
run: bash ci/wx-cache-key.sh windows
- name: Check prebuilt wxMSW
id: wx-image
run: bash ci/check-wx-image-prefix.sh windows
- name: Cache vendored wxMSW build
if: steps.wx-image.outputs.available != 'true'
id: wx-cache
uses: actions/cache/restore@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-mingw
key: ${{ steps.wx-key.outputs.key }}
- name: Build wxMSW (once, then cached)
id: wx-build
run: bash ci/ensure-wx-prefix.sh windows
- name: Save vendored wxMSW build
if: steps.wx-cache.outputs.cache-hit != 'true' && steps.wx-build.outputs.built == 'true'
uses: actions/cache/save@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-mingw
key: ${{ steps.wx-key.outputs.key }}
- name: Clippy (Windows target, warnings are errors)
run: bash ci/windows-ci.sh clippy
- name: Set crate version to ${{ steps.ver.outputs.version }}
if: steps.ver.outputs.release == 'true'
run: |
sed -i "0,/^version = \".*\"/s//version = \"${{ steps.ver.outputs.version }}\"/" Cargo.toml
grep -m1 '^version' Cargo.toml
- name: Build release (Windows)
run: bash ci/windows-ci.sh build
- name: Unit tests (Windows build, under Wine)
run: bash ci/windows-ci.sh test
- name: Headless UI self-test (Windows build, under Wine)
run: bash ci/windows-ci.sh selftest
- name: Sign Windows executable (Azure Artifact Signing)
env:
AZURE_SIGNING_PROFILE: ${{ vars.AZURE_SIGNING_PROFILE }}
AZURE_SIGNING_TENANT_ID: ${{ secrets.AZURE_SIGNING_TENANT_ID }}
AZURE_SIGNING_CLIENT_ID: ${{ secrets.AZURE_SIGNING_CLIENT_ID }}
AZURE_SIGNING_CLIENT_SECRET: ${{ secrets.AZURE_SIGNING_CLIENT_SECRET }}
run: bash ci/windows-ci.sh sign
- name: Package Windows artifact
if: steps.ver.outputs.release == 'true'
run: bash ci/windows-ci.sh package "${{ steps.ver.outputs.version }}"
- name: Bundle Windows test executables
run: bash ci/windows-ci.sh test-bundle
- uses: https://github.com/ChristopherHX/gitea-upload-artifact@81f940d004763f986ba3582c007fd842dd5cb0d7
if: steps.ver.outputs.release == 'true'
with:
name: alkane-toolkit-windows
path: dist/alkane-toolkit-v*-windows-x86_64.zip
# Consumed by .gitea/workflows/windows-native.yml on the Windows VM runner.
- uses: https://github.com/ChristopherHX/gitea-upload-artifact@81f940d004763f986ba3582c007fd842dd5cb0d7
with:
name: alkane-toolkit-windows-tests
path: |
dist/alkane-toolkit-windows-tests.zip
target/x86_64-pc-windows-gnu/release/alkane-toolkit.exe
- name: Clean generated Toolkit build
if: always()
run: python3 ci/cleanup-generated.py
release:
needs: windows
runs-on: alkane-ci
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
env:
CARGO_TARGET_DIR: target
CARGO_BUILD_JOBS: 2
@@ -26,6 +139,9 @@ jobs:
# Set once for the whole job so build/clippy/test/bench steps don't each
# re-export it (round 18 #12).
WX_RS_WXCONFIG: /root/.cache/wx-3.3.3-linux/bin/wx-config
# Read-only token baked into the GUI so the release picker can list the
# private alkane-os releases with no user setup (option_env!).
ALKANE_EMBEDDED_TOKEN: ${{ secrets.ALKANE_EMBEDDED_TOKEN }}
steps:
- name: Checkout (full history for tags)
uses: actions/checkout@v4
@@ -35,6 +151,15 @@ jobs:
- name: Check runner image pins
run: python3 ci/check-runner-image.py
- name: Check wx-rs patch queue reproduces the patched tree
run: python3 scripts/wx_rs_patches.py check
- name: Check first-party Rust formatting
run: |
rustup component add rustfmt >/dev/null
cargo fmt -p alkane-gui -p alkane-artifacts -p alkane-flash -p alkane-cli -p alkane-access -p alkane-core -- --check
- name: Compute version
id: ver
run: bash ci/compute-version.sh | tee -a "$GITHUB_OUTPUT"
@@ -152,8 +277,10 @@ jobs:
set -euo pipefail
rustup component add llvm-tools-preview >/dev/null 2>&1 || true
[ "$(cargo llvm-cov --version)" = 'cargo-llvm-cov 0.8.7' ]
PCT=$(bash ci/coverage.sh --summary-only \
| awk '/^TOTAL/{gsub(/%/,"",$10); print $10}')
# Keep the whole table: gen-badges turns it into the per-crate and
# per-file breakdown on the Pages quality dashboard.
bash ci/coverage.sh --summary-only | tee coverage-summary.txt
PCT=$(awk '/^TOTAL/{gsub(/%/,"",$10); print $10}' coverage-summary.txt)
[ -n "$PCT" ] || { echo "coverage report produced no TOTAL line" >&2; exit 1; }
echo "pct=${PCT}" >> "$GITHUB_OUTPUT"
echo "line coverage (tests + self-test): ${PCT}%"
@@ -181,7 +308,8 @@ jobs:
python3 ci/gen-badges.py --tests "$PASS" \
--coverage "${{ steps.cov.outputs.pct }}" \
--bench-coverage "${{ steps.benchcov.outputs.pct }}" \
--bench-delta "$BENCH_DELTA" --clippy clean
--bench-delta "$BENCH_DELTA" --clippy clean \
--coverage-summary coverage-summary.txt
- name: Publish measured badges
env:
@@ -218,11 +346,30 @@ jobs:
echo "asset=dist/${NAME}.tar.gz" >> "$GITHUB_OUTPUT"
echo "assetname=${NAME}.tar.gz" >> "$GITHUB_OUTPUT"
- name: Fetch Windows artifact
if: steps.ver.outputs.release == 'true'
uses: https://github.com/ChristopherHX/gitea-download-artifact@75635f32b4c1c41c4b3d64e8f85210112ed4c9c7
with:
name: alkane-toolkit-windows
path: dist/windows
- name: Locate Windows artifact
if: steps.ver.outputs.release == 'true'
id: winpkg
run: |
set -euo pipefail
V="${{ steps.ver.outputs.version }}"
ZIP="dist/windows/alkane-toolkit-v${V}-windows-x86_64.zip"
[ -s "$ZIP" ] || { echo "Windows artifact for v${V} is missing" >&2; ls -lR dist/windows >&2; exit 1; }
echo "asset=$ZIP" >> "$GITHUB_OUTPUT"
- name: Create Gitea release + upload artifact
if: steps.ver.outputs.release == 'true'
env:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
run: python3 ci/release-rc.py "${{ steps.ver.outputs.tag }}" false "${{ steps.pkg.outputs.asset }}"
run: |
python3 ci/release-rc.py "${{ steps.ver.outputs.tag }}" false \
"${{ steps.pkg.outputs.asset }}" "${{ steps.winpkg.outputs.asset }}"
- name: No release needed
if: steps.ver.outputs.release != 'true'
+1 -1
View File
@@ -13,7 +13,7 @@ jobs:
check:
runs-on: alkane-fast
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:9d2a992bbcb91014af3c85d2e1ec8c5990701cecf83fd06c8d46f9ef13dbd948
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
env:
CARGO_BUILD_JOBS: 2
steps:
+116 -6
View File
@@ -13,7 +13,9 @@ jobs:
verify:
runs-on: alkane-verify
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:9d2a992bbcb91014af3c85d2e1ec8c5990701cecf83fd06c8d46f9ef13dbd948
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
outputs:
surface: ${{ steps.surface.outputs.surface }}
env:
CARGO_TARGET_DIR: target
CARGO_BUILD_JOBS: 2
@@ -28,6 +30,9 @@ jobs:
- name: Check runner image pins
run: python3 ci/check-runner-image.py
- name: Check wx-rs patch queue reproduces the patched tree
run: python3 scripts/wx_rs_patches.py check
- name: Detect changed surface
id: surface
run: python3 ci/pr-surface.py >> "$GITHUB_OUTPUT"
@@ -37,23 +42,56 @@ jobs:
run: |
base="$(git merge-base HEAD "origin/$GITHUB_BASE_REF")"
git diff --check "$base" HEAD
if git grep -nIE '^[[:space:]]*-----BEGIN (RSA |EC |OPENSSH )?PRIVATE KEY-----[[:space:]]*$' --; then
# Vendored upstream trees carry their own test-fixture keys (openssl,
# rustls-pemfile, aws-lc); only first-party sources are checked.
if git grep -nIE '^[[:space:]]*-----BEGIN (RSA |EC |OPENSSH )?PRIVATE KEY-----[[:space:]]*$' -- ':!vendor' ':!thirdparty'; then
echo "private key material found in tracked source" >&2
exit 1
else
status=$?
[ "$status" -eq 1 ]
fi
- name: Check CI change surface
if: steps.surface.outputs.surface != 'documentation'
run: python3 ci/test-pr-surface.py
- name: Check first-party Rust formatting
if: steps.surface.outputs.surface == 'headless' || steps.surface.outputs.surface == 'full'
run: |
rustup component add rustfmt >/dev/null
cargo fmt -p alkane-gui -p alkane-artifacts -p alkane-flash -p alkane-cli -p alkane-access -p alkane-core -- --check
- name: Check workflow-only change
if: steps.surface.outputs.surface == 'workflow'
run: |
python3 - <<'PY'
from pathlib import Path
import yaml
for path in Path('.gitea/workflows').glob('*.yml'):
yaml.load(path.read_text(), Loader=yaml.BaseLoader)
PY
python3 ci/check-runner-image.py
for script in ci/*.sh; do bash -n "$script"; done
base="$(git merge-base HEAD "origin/$GITHUB_BASE_REF")"
git diff --check "$base" HEAD
# Vendored upstream trees carry their own test-fixture keys (openssl,
# rustls-pemfile, aws-lc); only first-party sources are checked.
if git grep -nIE '^[[:space:]]*-----BEGIN (RSA |EC |OPENSSH )?PRIVATE KEY-----[[:space:]]*$' -- ':!vendor' ':!thirdparty'; then
echo "private key material found in tracked source" >&2
exit 1
else
status=$?
[ "$status" -eq 1 ]
fi
- name: Install build dependencies
if: steps.surface.outputs.surface != 'documentation'
if: steps.surface.outputs.surface == 'headless' || steps.surface.outputs.surface == 'full'
run: bash ci/ensure-build-deps.sh base
- name: Configure bounded Rust compiler cache
if: steps.surface.outputs.surface != 'documentation'
if: steps.surface.outputs.surface == 'headless' || steps.surface.outputs.surface == 'full'
run: bash ci/configure-rust-cache.sh
- name: Compute wxWidgets cache key
@@ -121,6 +159,7 @@ jobs:
run: |
cargo test -p alkane-gui --offline
cargo test --workspace --exclude alkane-gui --exclude wx-rs --offline
python3 tools/report-relay/test_relay.py
- name: Microbenchmarks
if: steps.surface.outputs.surface == 'full'
@@ -138,7 +177,7 @@ jobs:
# runner must not fail the gate on it. Accepted advisories live in
# .cargo/audit.toml.
- name: Dependency audit (best-effort)
if: steps.surface.outputs.surface != 'documentation'
if: steps.surface.outputs.surface == 'headless' || steps.surface.outputs.surface == 'full'
continue-on-error: true
run: |
if command -v cargo-audit >/dev/null 2>&1; then
@@ -147,7 +186,7 @@ jobs:
echo "cargo-audit not installed on this runner; skipping"
fi
- name: Rust compiler cache statistics
if: always() && steps.surface.outputs.surface != 'documentation'
if: always() && (steps.surface.outputs.surface == 'headless' || steps.surface.outputs.surface == 'full')
run: |
if [ -n "${SCCACHE_DIR:-}" ]; then
sccache --show-stats
@@ -155,3 +194,74 @@ jobs:
- name: Clean generated Toolkit build
if: always()
run: python3 ci/cleanup-generated.py
# The Windows build of the same change (main's release gate, run on the PR):
# clippy for the Windows target, the release .exe, every unit test under
# Wine, and the headless UI self-test under Wine. Only for changes that can
# affect the binary (the "full" surface).
verify-windows:
needs: verify
if: needs.verify.outputs.surface == 'full'
runs-on: alkane-verify
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
env:
CARGO_TARGET_DIR: target
CARGO_BUILD_JOBS: 2
WX_WINDOWS_PREFIX: /root/.cache/wx-3.3.3-mingw
steps:
- name: Checkout
uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Install Windows toolchain
run: bash ci/windows-ci.sh toolchain
- name: Configure bounded Rust compiler cache
run: bash ci/configure-rust-cache.sh
- name: Compute wxMSW cache key
id: wx-key
run: bash ci/wx-cache-key.sh windows
- name: Check prebuilt wxMSW
id: wx-image
run: bash ci/check-wx-image-prefix.sh windows
- name: Cache vendored wxMSW build
if: steps.wx-image.outputs.available != 'true'
id: wx-cache
uses: actions/cache/restore@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-mingw
key: ${{ steps.wx-key.outputs.key }}
- name: Build wxMSW (once, then cached)
id: wx-build
run: bash ci/ensure-wx-prefix.sh windows
- name: Save vendored wxMSW build
if: steps.wx-cache.outputs.cache-hit != 'true' && steps.wx-build.outputs.built == 'true'
uses: actions/cache/save@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-mingw
key: ${{ steps.wx-key.outputs.key }}
- name: Clippy (Windows target, warnings are errors)
run: bash ci/windows-ci.sh clippy
- name: Build (Windows)
run: bash ci/windows-ci.sh build
- name: Unit tests (Windows build, under Wine)
run: bash ci/windows-ci.sh test
- name: Headless UI self-test (Windows build, under Wine)
run: bash ci/windows-ci.sh selftest
- name: Clean generated Toolkit build
if: always()
run: python3 ci/cleanup-generated.py
+101
View File
@@ -0,0 +1,101 @@
name: windows-native
# Smoke test on real Windows. The self-hosted runner in the Windows 11 test VM
# (label alkane-windows, host mode; see docs/windows.md) takes the Windows
# build that main's build-test-release run cross-compiled -- the release .exe
# and every unit-test executable, which already passed under Wine there -- and
# runs them natively: real Win32, real comctl32/visual styles, real DPI and
# real Windows networking.
#
# Advisory by design: a separate workflow, so it never gates or delays a
# release, and while the VM is off the job simply waits for the runner.
on:
workflow_run:
workflows: [build-test-release]
types: [completed]
workflow_dispatch:
inputs:
run_id:
description: build-test-release run whose Windows build to test
required: true
permissions:
actions: read
contents: read
jobs:
native:
if: github.event_name == 'workflow_dispatch' || github.event.workflow_run.conclusion == 'success'
runs-on: alkane-windows
timeout-minutes: 30
env:
RUN_ID: ${{ github.event.workflow_run.id || inputs.run_id }}
# Windows' default execution policy (Restricted) refuses the script files
# the runner writes for each step; bypass it for these steps only, so the
# runner works without changing the machine's policy.
defaults:
run:
shell: powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -File {0}
steps:
- name: Fetch the cross-built Windows build
env:
TOKEN: ${{ github.token }}
API: ${{ github.api_url }}/repos/${{ github.repository }}
run: |
$ErrorActionPreference = 'Stop'
$ProgressPreference = 'SilentlyContinue'
$work = Join-Path ([IO.Path]::GetTempPath()) "alkane-native-$env:RUN_ID"
Remove-Item -Recurse -Force $work -ErrorAction SilentlyContinue
New-Item -ItemType Directory $work | Out-Null
$auth = @{ Authorization = "token $env:TOKEN" }
$list = Invoke-RestMethod -Headers $auth "$env:API/actions/runs/$env:RUN_ID/artifacts"
$art = $list.artifacts | Where-Object { $_.name -eq 'alkane-toolkit-windows-tests' } |
Select-Object -First 1
if (-not $art) { throw "run $env:RUN_ID has no alkane-toolkit-windows-tests artifact" }
Invoke-WebRequest -Headers $auth -Uri $art.archive_download_url -OutFile "$work\artifact.zip"
Expand-Archive "$work\artifact.zip" "$work\artifact"
$bundle = Get-ChildItem -Recurse "$work\artifact" -Filter alkane-toolkit-windows-tests.zip |
Select-Object -First 1
Expand-Archive $bundle.FullName "$work\tests"
$exe = Get-ChildItem -Recurse "$work\artifact" -Filter alkane-toolkit.exe | Select-Object -First 1
Copy-Item $exe.FullName "$work\alkane-toolkit.exe"
"ALKANE_NATIVE=$work" | Out-File -Append -Encoding utf8 $env:GITHUB_ENV
$os = Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion'
"Testing run $env:RUN_ID on Windows $($os.DisplayVersion) build $($os.CurrentBuild)"
- name: Authenticode signature (native Windows)
env:
SIGNING_ENABLED: ${{ vars.AZURE_SIGNING_PROFILE }}
run: |
# Windows itself judges the signature: chain to a trusted root,
# intact file hash, valid timestamp. Required once signing is on.
$sig = Get-AuthenticodeSignature "$env:ALKANE_NATIVE\alkane-toolkit.exe"
Write-Host "Signature: $($sig.Status) $($sig.StatusMessage)"
if ($sig.SignerCertificate) { Write-Host "Signer: $($sig.SignerCertificate.Subject)" }
if ($sig.TimeStamperCertificate) { Write-Host "Timestamp: $($sig.TimeStamperCertificate.Subject)" }
if ($env:SIGNING_ENABLED -and $sig.Status -ne 'Valid') { exit 1 }
- name: Unit tests (native Windows)
run: |
$failed = @()
foreach ($test in Get-Content "$env:ALKANE_NATIVE\tests\tests.txt") {
Write-Host "== $test"
& "$env:ALKANE_NATIVE\tests\$test"
if ($LASTEXITCODE -ne 0) { $failed += $test }
}
if ($failed) { Write-Host "FAILED: $($failed -join ', ')"; exit 1 }
- name: Headless UI self-test (native Windows)
run: |
# A GUI-subsystem executable: wait for it and read its redirected output.
$env:ALKANE_SELFTEST = '1'
$out = "$env:ALKANE_NATIVE\selftest.txt"
$p = Start-Process -FilePath "$env:ALKANE_NATIVE\alkane-toolkit.exe" -Wait -PassThru `
-NoNewWindow -RedirectStandardOutput $out -RedirectStandardError "$out.err"
Get-Content $out, "$out.err"
if ($p.ExitCode -ne 0) { exit $p.ExitCode }
- name: Remove the downloaded build
if: always()
run: |
if ($env:ALKANE_NATIVE) { Remove-Item -Recurse -Force $env:ALKANE_NATIVE -ErrorAction SilentlyContinue }
+5
View File
@@ -2,3 +2,8 @@
**/target
.claude/
__pycache__/
# Internal working notes live outside this public repository.
/AGENTS.md
/HANDOFF.md
/CLAUDE.md
code-review-report*.md
Generated
+7
View File
@@ -40,6 +40,8 @@ name = "alkane-artifacts"
version = "0.1.0"
dependencies = [
"alkane-core",
"serde",
"serde_json",
"sha2",
"thiserror",
]
@@ -50,6 +52,8 @@ version = "0.1.0"
dependencies = [
"alkane-artifacts",
"alkane-core",
"alkane-flash",
"serde_json",
]
[[package]]
@@ -74,6 +78,7 @@ version = "0.1.0"
dependencies = [
"alkane-artifacts",
"alkane-core",
"serde_json",
"sha2",
"tempfile",
"thiserror",
@@ -84,8 +89,10 @@ name = "alkane-gui"
version = "0.1.0"
dependencies = [
"aes",
"alkane-artifacts",
"alkane-core",
"alkane-discovery",
"alkane-flash",
"asic-rs",
"base64 0.21.7",
"ecb",
+1
View File
@@ -19,6 +19,7 @@ license = "MIT"
thiserror = "2"
serde = { version = "1", features = ["derive"] }
sha2 = "0.10"
serde_json = "1"
# Release binary: small, self-contained, and fast enough for a fleet GUI whose
# hot path is network I/O, not CPU (round 18 #12). opt-level "s" + fat LTO +
+1 -1
View File
@@ -1,6 +1,6 @@
MIT License
Copyright (c) 2026 Blueflare
Copyright (c) 2026 BlueFlare Energy Solutions Inc.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
+72 -17
View File
@@ -1,18 +1,22 @@
# Alkane Toolkit
[![CI](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/main.svg)](https://gitea.bluefla.re/blueflare/alkane-toolkit/actions)
![tests](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/tests.svg)
![coverage](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/coverage.svg)
![bench](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/bench.svg)
![bench coverage](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/bench-coverage.svg)
![lines of code](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/loc.svg)
![code quality](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/quality.svg)
![dependencies](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/dependencies.svg)
![license](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/license.svg)
[![tests](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/tests.svg)](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/)
[![coverage](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/coverage.svg)](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/#coverage)
[![bench](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/bench.svg)](https://blueflare.gitea.bluefla.re/alkane-toolkit/bench/)
[![bench coverage](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/bench-coverage.svg)](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/)
[![lines of code](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/loc.svg)](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/#coverage)
[![code quality](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/quality.svg)](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/)
[![dependencies](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/dependencies.svg)](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/)
[![license](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/license.svg)](LICENSE)
The badges link to the [project site](https://blueflare.gitea.bluefla.re/alkane-toolkit/): the [manual](https://blueflare.gitea.bluefla.re/alkane-toolkit/manual/),
the [code-quality dashboard](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/) (how the grade is set, coverage by
crate and file) and the [benchmark history](https://blueflare.gitea.bluefla.re/alkane-toolkit/bench/).
Desktop miner discovery and monitoring. The Rust GUI uses wxWidgets through
a patched [wx-rs bridge](thirdparty/wx-rs). Firmware installation is under
development.
a patched [wx-rs bridge](thirdparty/wx-rs). In-app image flashing is disabled
while that path is reworked.
## Run locally
@@ -23,18 +27,69 @@ ALKANE_FAKE_SCAN=1 ~/.cache/alkane-tk-target/release/alkane-toolkit
```
The first command builds wxWidgets 3.3.3 once. Linux needs GTK 3. Fake scan
uses offline fixtures and does not contact hardware. For Windows and macOS,
use the matching `scripts/build-gui-*.sh` script.
uses offline fixtures and does not contact hardware.
Windows 10/11 builds are cross-compiled on Linux (`scripts/build-wx-windows.sh`,
then `scripts/build-gui-windows.sh`) and attached to every release as a
self-contained `alkane-toolkit.exe`; see [docs/windows.md](docs/windows.md).
macOS builds run on a Mac (`scripts/build-wx-macos.sh`, then
`scripts/build-gui-macos.sh`) and produce one universal app for Apple Silicon
and Intel, macOS 11 or later; see [docs/macos.md](docs/macos.md).
## Current scope
- Discover miners by CIDR or IP range with vendored [asic-rs](vendor/asic-rs).
- Show model, firmware, health, hashrate, temperatures, fans, PSU, and workers.
- Filter and sort the desktop table; inspect probes with `miner_probe`.
- Use controls supported by the selected firmware and restore supported
aftermarket firmware to stock.
Discovery is read-only. The installer and operator actions remain in the
[implementation plan](docs/IMPLEMENTATION-PLAN.md) and
[firmware matrix](docs/aftermarket-parity-roadmap.md).
Discovery is read-only. Control and restore actions change miners. Check the
selected devices before applying them.
## Headless .afw install (CV1835 and AM335x)
`alkane-cli` is the headless engine; the GUI uses the same engine. A verified
`.afw` is a full OS bundle for exactly one board. The CV1835 installer writes
only `/dev/mmcblk0p1` over SSH, holds the current p1 first, reads the whole
partition back, and reboots only after the read-back matches.
The AM335x installer writes mtd8 (type-3 ramdisk), mtd6 (dtb) and mtd7
(legacy kernel uImage) with `flash_erase` + `nandwrite`. It never touches
mtd0-5 (SPL/U-Boot/bootenv), holds a backup of each target before writing it,
and reads every target back before reboot. Its `verify-live` checks SSH
(kernel string), the HTTP marker on port 80, the API on port 4028, and the
eth0 DHCP lease.
```sh
alkane-cli afw verify BUNDLE.afw --allow-unsigned
alkane-cli afw plan BUNDLE.afw --host 10.255.1.167
alkane-cli afw preflight BUNDLE.afw --host 10.255.1.167
alkane-cli afw install BUNDLE.afw --host 10.255.1.167 --dry-run
alkane-cli afw install BUNDLE.afw --host 10.255.1.167 --confirm FLASH
alkane-cli afw verify-live BUNDLE.afw --host 10.255.1.167
alkane-cli afw restore --host 10.255.1.167 --held-backup p1.img --confirm FLASH
```
For AM335x the same subcommands infer the board from the bundle; restore names
the three held copies explicitly:
```sh
alkane-cli afw plan BUNDLE.afw --host 10.255.1.64
alkane-cli afw preflight BUNDLE.afw --host 10.255.1.64
alkane-cli afw install BUNDLE.afw --host 10.255.1.64 --dry-run
alkane-cli afw install BUNDLE.afw --host 10.255.1.64 --confirm FLASH
alkane-cli afw verify-live BUNDLE.afw --host 10.255.1.64 --timeout 300
alkane-cli afw restore --board am335x --host 10.255.1.64 \
--held-backup mtd8.img --held-kernel mtd7.img --held-dtb mtd6.img --confirm FLASH
```
On stock Bitmain CV1835 the SSH login is the unprivileged `miner` account; the
toolkit obtains root through the stock update-daemon loopback channel, not a
serial console. Credentials come only from `ALKANE_BOARD_PASSWORD` or
`ALKANE_BOARD_PASSWORD_FILE`, or from `--password-file` / `--identity-file`.
No credential value is printed. `--allow-unsigned` is bench-only; site use
needs an Ed25519-signed bundle.
## Development
@@ -46,8 +101,8 @@ WX_RS_WXCONFIG="$HOME/.cache/wx-3.3.3-linux/bin/wx-config" \
Keep build output off the source share. `main` runs full CI and publishes
qualifying releases; `next` builds `-rc` candidates. Badges measure host
code, not installation support. See the public
[benchmark history](https://blueflare.gitea.bluefla.re/alkane-benchmarks/toolkit/).
code, not installation support. See the
[benchmark history](https://blueflare.gitea.bluefla.re/alkane-toolkit/bench/).
## Firmware safety
+70 -9
View File
@@ -15,6 +15,7 @@ import subprocess
import importlib.util
from urllib.error import HTTPError
from urllib.parse import quote
import yaml
from badge_store import BADGE_BRANCH, publish_file, request_json
from bench_host import identity as benchmark_host
@@ -26,6 +27,12 @@ bench_spec.loader.exec_module(bench_badge)
INDEX = "history/index.json"
MAX_INDEX_ENTRIES = 50
BENCH_INPUT_PATHS = (
"Cargo.toml", "Cargo.lock", ".cargo", "crates", "thirdparty", "vendor",
"rust-toolchain.toml", "ci/bench-badge.py", "ci/bench_host.py",
"ci/ensure-build-deps.sh", "ci/ensure-wx-prefix.sh",
"ci/configure-rust-cache.sh", "ci/wx-cache-key.sh",
)
def read_artifact(api: str, repo: str, token: str, filename: str):
@@ -51,6 +58,8 @@ def valid_benches(metrics: dict) -> dict[str, float]:
def git_distance(ancestor: str, sha: str) -> int | None:
if not re.fullmatch(r"[0-9a-f]{40}", ancestor) or not re.fullmatch(r"[0-9a-f]{40}", sha):
return None
result = subprocess.run(("git", "rev-list", "--count", f"{ancestor}..{sha}"),
capture_output=True, text=True, check=False)
if result.returncode != 0:
@@ -60,7 +69,7 @@ def git_distance(ancestor: str, sha: str) -> int | None:
return int(result.stdout.strip()) if ancestor_check.returncode == 0 else None
def previous_measurement(index: dict, sha: str, distance=None, host=None) -> dict:
def previous_entry(index: dict, sha: str, distance=None, host=None) -> dict | None:
distance = distance or git_distance
choices = []
for entry in index.get("entries", []):
@@ -73,8 +82,41 @@ def previous_measurement(index: dict, sha: str, distance=None, host=None) -> dic
if gap is not None and gap > 0:
choices.append((gap, entry))
if not choices:
return {}
return valid_benches(min(choices, key=lambda item: item[0])[1]["metrics"])
return None
return min(choices, key=lambda item: item[0])[1]
def previous_measurement(index: dict, sha: str, distance=None, host=None) -> dict:
entry = previous_entry(index, sha, distance, host)
return valid_benches(entry["metrics"]) if entry else {}
def benchmark_build_settings(sha: str, root: Path | str = ".") -> dict:
source = subprocess.check_output(
("git", "show", f"{sha}:.gitea/workflows/release.yml"),
cwd=root, text=True)
job = yaml.load(source, Loader=yaml.BaseLoader)["jobs"]["release"]
commands = {step.get("name", ""): step.get("run") for step in job["steps"]}
selected = ("Install build dependencies", "Configure bounded Rust compiler cache",
"Build wxWidgets (once, then cached)", "Build release", "Microbenchmarks")
return {"image": job["container"]["image"], "env": job.get("env", {}),
"commands": {name: commands.get(name) for name in selected}}
def same_benchmark_inputs(ancestor: str, sha: str, root: Path | str = ".") -> bool:
"""Identify changes that only reroute CI without changing benchmark inputs."""
if not re.fullmatch(r"[0-9a-f]{40}", ancestor) or not re.fullmatch(r"[0-9a-f]{40}", sha):
raise ValueError("invalid benchmark comparison commit")
diff = subprocess.run(("git", "diff", "--quiet", ancestor, sha, "--",
*BENCH_INPUT_PATHS), cwd=root, check=False)
if diff.returncode not in (0, 1):
raise ValueError("cannot inspect benchmark input changes")
if diff.returncode == 1:
return False
try:
return benchmark_build_settings(ancestor, root) == benchmark_build_settings(sha, root)
except (KeyError, TypeError, subprocess.CalledProcessError, yaml.YAMLError):
return False
def updated_index(index: dict, sha: str, metrics: dict, timestamp: str) -> dict:
@@ -101,6 +143,12 @@ def render_html(index: dict) -> str:
host = entry["metrics"].get("bench_host", {})
host_label = host.get("cpu_model", "unknown") if isinstance(host, dict) else "unknown"
cells.append(f'<td>{html.escape(str(host_label))}</td>')
context = entry["metrics"].get("bench_context", {})
if isinstance(context, dict) and context.get("schema") == 1:
context_label = "same inputs" if context.get("same_inputs") else "changed inputs"
else:
context_label = "unclassified"
cells.append(f'<td>{context_label}</td>')
cells += [f'<td>{values[name]:.3f}</td>' if name in values else '<td>new</td>'
for name in names]
rows.append("<tr>" + "".join(cells) + "</tr>")
@@ -115,12 +163,14 @@ def render_html(index: dict) -> str:
"th{background:#edf2f6;position:sticky;top:0}a{color:#145a9a}"
".scroll{overflow-x:auto}small{color:#55616d}</style></head><body>"
"<h1>Alkane Toolkit microbenchmarks</h1>"
"<p>Measured on main CI. Lower ns/op is faster. Results depend on runner load and are "
"not board performance. A new benchmark has no earlier comparison.</p>"
"<p>Measured on main CI. Lower ns/op is faster. Runner load affects results. "
"Same inputs marks a repeat of the benchmark source and build settings. "
"A new benchmark has no earlier comparison.</p>"
f"<p><small>Most recent {len(entries)} measured commits. Full per-commit JSON is retained "
"in the private ci-badges branch.</small></p>"
f"<div class=\"scroll\"><table><thead><tr><th scope=\"col\">Commit</th>"
f"<th scope=\"col\">UTC</th><th scope=\"col\">CPU</th>{headings}</tr></thead><tbody>{''.join(rows)}"
f"<th scope=\"col\">UTC</th><th scope=\"col\">CPU</th>"
f"<th scope=\"col\">Inputs</th>{headings}</tr></thead><tbody>{''.join(rows)}"
"</tbody></table></div></body></html>\n")
@@ -136,10 +186,16 @@ def main() -> None:
if index.get("schema") != 1 or not isinstance(index.get("entries"), list):
raise ValueError("unsupported benchmark history index")
if args.action == "prepare":
baseline = previous_measurement(index, sha, host=benchmark_host())
entry = previous_entry(index, sha, host=benchmark_host())
baseline = valid_benches(entry["metrics"]) if entry else {}
same_inputs = same_benchmark_inputs(entry["sha"], sha) if entry else False
Path("badges").mkdir(exist_ok=True)
Path("badges/bench-baseline.json").write_text(json.dumps(baseline) + "\n")
print(f"Loaded {len(baseline)} prior benchmark measurements")
Path("badges/bench-context.json").write_text(
json.dumps({"schema": 1, "same_inputs": same_inputs,
"baseline_sha": entry["sha"] if entry else None}) + "\n")
print(f"Loaded {len(baseline)} prior benchmark measurements; "
f"same inputs: {str(same_inputs).lower()}")
return
if args.action == "render":
if not index["entries"]:
@@ -148,8 +204,13 @@ def main() -> None:
Path("bench-site/index.html").write_text(render_html(index))
print(f"Rendered {len(index['entries'])} measured benchmark commits")
return
context = json.loads(Path("badges/bench-context.json").read_text())
if (not isinstance(context, dict) or context.get("schema") != 1 or
not isinstance(context.get("same_inputs"), bool)):
raise ValueError("invalid benchmark comparison context")
metrics = {"bench_ns_per_op": bench_badge.require_suite(bench_badge.parse_bench(
Path("bench-current.txt").read_text())), "bench_host": benchmark_host()}
Path("bench-current.txt").read_text())), "bench_host": benchmark_host(),
"bench_context": context}
timestamp = datetime.now(timezone.utc).isoformat(timespec="seconds")
index = updated_index(index, sha, metrics, timestamp)
record = json.dumps(index["entries"][-1], indent=2).encode() + b"\n"
+293
View File
@@ -0,0 +1,293 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Build the Alkane Toolkit Pages site (served from this repo's gh-pages).
build-pages.py --out site [--manual docs/manual] [--quality quality.json]
[--bench bench-site/index.html] [--sha SHA]
Pages:
/ overview and downloads
/manual/ the user manual, one page per docs/manual/NN-name.md chapter
/quality/ code-quality dashboard from the measured quality.json that main
CI publishes next to the badges (ci/gen-badges.py)
/bench/ the measured benchmark history (ci/bench_history.py render)
Every value taken from CI data is HTML-escaped; the manual is Markdown written
in this repository.
"""
import argparse
import html
import json
import re
import shutil
from pathlib import Path
import markdown
REPO = "https://gitea.bluefla.re/blueflare/alkane-toolkit"
RELEASES = REPO + "/releases"
SECTIONS = (("", "Overview"), ("manual/", "Manual"), ("quality/", "Code quality"),
("bench/", "Benchmarks"))
CSS = """
:root { --bg:#ffffff; --fg:#1f2328; --muted:#59636e; --line:#d1d9e0; --card:#f6f8fa;
--accent:#d9822b; --link:#0969da; --good:#1a7f37; --warn:#9a6700; --bad:#cf222e; }
@media (prefers-color-scheme: dark) { :root { --bg:#0d1117; --fg:#e6edf3; --muted:#9198a1;
--line:#30363d; --card:#151b23; --link:#4493f8; --good:#3fb950; --warn:#d29922; --bad:#f85149; } }
* { box-sizing: border-box; }
body { margin:0; background:var(--bg); color:var(--fg);
font:16px/1.55 system-ui,-apple-system,"Segoe UI",Roboto,Ubuntu,sans-serif; }
a { color:var(--link); text-decoration:none; } a:hover { text-decoration:underline; }
header { border-bottom:1px solid var(--line); }
header .bar, main { max-width:1040px; margin:0 auto; padding:0 16px; }
header .bar { display:flex; align-items:center; gap:24px; height:56px; flex-wrap:wrap; }
header .brand { font-weight:700; color:var(--fg); display:flex; gap:8px; align-items:center; }
header .brand i { width:20px; height:20px; border-radius:5px; background:var(--accent); display:inline-block; }
header nav { display:flex; gap:18px; flex-wrap:wrap; }
header nav a { color:var(--muted); } header nav a.on { color:var(--fg); font-weight:600; }
main { padding:28px 16px 64px; }
h1 { font-size:1.9rem; margin:.2em 0 .4em; } h2 { margin-top:1.8em; border-bottom:1px solid var(--line); padding-bottom:.25em; }
code { background:var(--card); border:1px solid var(--line); border-radius:5px; padding:.1em .35em; font-size:.92em; }
pre { background:var(--card); border:1px solid var(--line); border-radius:8px; padding:12px; overflow:auto; }
pre code { border:0; padding:0; }
table { border-collapse:collapse; width:100%; margin:1em 0; display:block; overflow-x:auto; }
th, td { border:1px solid var(--line); padding:6px 10px; text-align:left; vertical-align:top; }
th { background:var(--card); }
td.num, th.num { text-align:right; font-variant-numeric:tabular-nums; white-space:nowrap; }
.cards { display:grid; grid-template-columns:repeat(auto-fill,minmax(180px,1fr)); gap:12px; margin:1.2em 0; }
.card { background:var(--card); border:1px solid var(--line); border-radius:10px; padding:14px; }
.card b { display:block; font-size:1.6rem; } .card span { color:var(--muted); font-size:.9rem; }
.good { color:var(--good); } .warn { color:var(--warn); } .bad { color:var(--bad); }
.bar-cell { min-width:120px; } .meter { height:8px; background:var(--line); border-radius:4px; overflow:hidden; }
.meter i { display:block; height:100%; }
.layout { display:grid; grid-template-columns:220px 1fr; gap:32px; }
.layout aside ol { padding-left:1.2em; margin:0; } .layout aside li { margin:.3em 0; }
.layout aside a.on { font-weight:600; color:var(--fg); }
@media (max-width:760px) { .layout { grid-template-columns:1fr; } }
.buttons a { display:inline-block; margin:4px 8px 4px 0; padding:8px 14px; border-radius:8px;
border:1px solid var(--line); background:var(--card); color:var(--fg); }
.buttons a.primary { background:var(--accent); border-color:var(--accent); color:#fff; }
footer { color:var(--muted); font-size:.85rem; margin-top:48px; }
"""
def page(title: str, body: str, depth: int, current: str, sha: str) -> str:
up = "../" * depth
nav = "".join(
f'<a href="{up}{path}"{" class=on" if path == current else ""}>{label}</a>'
for path, label in SECTIONS)
built = f"Built from {html.escape(sha[:10])}. " if sha else ""
return f"""<!doctype html>
<html lang="en"><head><meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>{html.escape(title)} - Alkane Toolkit</title>
<link rel="stylesheet" href="{up}style.css"></head>
<body><header><div class="bar"><a class="brand" href="{up}"><i></i>Alkane Toolkit</a>
<nav>{nav}<a href="{RELEASES}">Downloads</a><a href="{REPO}">Source</a></nav></div></header>
<main>{body}
<footer>{built}Alkane Toolkit is MIT licensed.</footer></main></body></html>
"""
def write(out: Path, rel: str, text: str) -> None:
path = out / rel
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(text, encoding="utf-8")
# ---- manual -----------------------------------------------------------------
def chapters(manual: Path) -> list[tuple[str, str, str]]:
"""(slug, title, markdown) for docs/manual/NN-slug.md, in file-name order."""
out = []
for path in sorted(manual.glob("[0-9][0-9]-*.md")):
text = path.read_text(encoding="utf-8")
m = re.search(r"^# (.+)$", text, re.M)
title = m.group(1).strip() if m else path.stem
out.append((path.stem[3:], title, text))
return out
def build_manual(out: Path, manual: Path, sha: str) -> None:
items = chapters(manual)
if not items:
raise SystemExit(f"no manual chapters in {manual}")
def toc(current: str) -> str:
links = "".join(
f'<li><a href="{slug}.html"{" class=on" if slug == current else ""}>'
f"{html.escape(title)}</a></li>" for slug, title, _ in items)
return f"<aside><ol>{links}</ol></aside>"
for slug, title, text in items:
# Chapters link to each other as NN-name.md in the repo; on the site
# they are name.html.
text = re.sub(r"\]\((?:\./)?[0-9][0-9]-([a-z0-9-]+)\.md(#[^)]*)?\)", r"](\1.html\2)", text)
body_html = markdown.markdown(text, extensions=["tables", "fenced_code", "toc"])
write(out, f"manual/{slug}.html",
page(title, f'<div class="layout">{toc(slug)}<article>{body_html}</article></div>',
1, "manual/", sha))
first = items[0][0]
listing = "".join(f'<li><a href="{s}.html">{html.escape(t)}</a></li>' for s, t, _ in items)
write(out, "manual/index.html",
page("Manual", f"<h1>Manual</h1><p>Start with "
f'<a href="{first}.html">{html.escape(items[0][1])}</a>.</p><ol>{listing}</ol>',
1, "manual/", sha))
# ---- quality dashboard ---------------------------------------------------------
def pct_class(pct: float | None) -> str:
if pct is None:
return ""
return "good" if pct >= 80 else "warn" if pct >= 40 else "bad"
def meter(pct: float) -> str:
colour = {"good": "var(--good)", "warn": "var(--warn)", "bad": "var(--bad)"}[pct_class(pct)]
return f'<div class="meter"><i style="width:{max(0.0, min(pct, 100.0)):.1f}%;background:{colour}"></i></div>'
def build_quality(out: Path, quality: dict | None, sha: str) -> None:
e = html.escape
if not quality:
write(out, "quality/index.html", page(
"Code quality", "<h1>Code quality</h1><p>No measurement has been published yet; "
"the next main build will fill this page.</p>", 1, "quality/", sha))
return
grade = str(quality.get("grade", "pending"))
cov = quality.get("coverage_pct")
bench_cov = quality.get("bench_coverage_pct")
delta = quality.get("bench_delta_pct")
def card(value: str, label: str, cls: str = "") -> str:
return f'<div class="card"><b class="{cls}">{value}</b><span>{label}</span></div>'
cards = "".join([
card(e(grade), "Quality grade", {"A": "good", "B": "good", "C": "warn"}.get(grade, "bad")),
card(e(str(quality.get("tests_passed", "-"))), "Tests passing", "good"),
card(f"{cov:.1f}%" if cov is not None else "-", "Line coverage", pct_class(cov)),
card(f"{bench_cov:.1f}%" if bench_cov is not None else "-", "Benchmark coverage", pct_class(bench_cov)),
card(e(str(quality.get("clippy") or "-")), "Clippy (warnings are errors)",
"good" if quality.get("clippy") == "clean" else "bad"),
card(e(str(quality.get("rustfmt") or "-")), "rustfmt", "good" if quality.get("rustfmt") == "clean" else ""),
card(f"{quality.get('loc', 0):,}", "Lines of Rust"),
card(e(str(quality.get("dependencies", "-"))), "Crates in Cargo.lock"),
card((f"{'+' if delta > 0 else ''}{delta:.1f}%" if delta is not None else "-"),
"Benchmarks vs previous" + (" (same inputs)" if quality.get("bench_same_inputs") else ""),
"" if delta is None else "good" if delta >= 2 else "" if delta > -2 else "warn"),
])
bands = ", ".join(f"{e(str(letter))} at {floor:.0f}% or more"
for floor, letter in quality.get("grade_bands", []))
grade_rule = (f"<p>The grade is F if Clippy or rustfmt fails on main. Otherwise it is the "
f"line-coverage band: {bands}, and F below that. The coverage badge uses the "
f"same bands for its colour, so the two never disagree.</p>")
crates = quality.get("coverage_by_crate", {})
loc = quality.get("loc_by_crate", {})
rows = []
for name in sorted(set(crates) | set(loc)):
c = crates.get(name)
if c and c["lines"]:
pct = 100.0 * (c["lines"] - c["missed"]) / c["lines"]
cov_cells = (f'<td class="num {pct_class(pct)}">{pct:.1f}%</td>'
f'<td class="bar-cell">{meter(pct)}</td>'
f'<td class="num">{c["lines"] - c["missed"]:,} / {c["lines"]:,}</td>')
else:
cov_cells = '<td class="num">-</td><td></td><td class="num">-</td>'
rows.append(f"<tr><td>{e(name)}</td>{cov_cells}<td class='num'>{loc.get(name, 0):,}</td></tr>")
crate_table = ("<table><tr><th>Crate</th><th class=num>Line coverage</th><th></th>"
"<th class=num>Covered lines</th><th class=num>Lines of Rust</th></tr>"
+ "".join(rows) + "</table>")
files = sorted(quality.get("coverage_by_file", []),
key=lambda r: (r["lines"] - r["missed"]) / r["lines"] if r["lines"] else 1)
file_rows = "".join(
f"<tr><td><code>{e(r['file'])}</code></td>"
f"<td class='num {pct_class(100.0 * (r['lines'] - r['missed']) / r['lines'])}'>"
f"{100.0 * (r['lines'] - r['missed']) / r['lines']:.1f}%</td>"
f"<td class='num'>{r['missed']:,}</td><td class='num'>{r['lines']:,}</td></tr>"
for r in files if r["lines"])
file_table = ("<table><tr><th>File (least covered first)</th><th class=num>Coverage</th>"
"<th class=num>Uncovered lines</th><th class=num>Lines</th></tr>"
+ file_rows + "</table>") if file_rows else ""
measured = str(quality.get("sha", ""))[:10]
of_build = f" (this page: <code>{e(measured)}</code>)" if measured else ""
body = f"""<h1>Code quality</h1>
<p>Measured by main CI on every build{of_build}:
unit tests, line coverage (unit tests plus the headless UI self-test), Clippy with
warnings as errors, and rustfmt. Windows builds run the same tests under Wine and
on real Windows 11.</p>
<div class="cards">{cards}</div>
<h2 id="grade">How the grade is set</h2>{grade_rule}
<h2 id="coverage">Coverage by crate</h2>{crate_table}
<h2 id="files">Coverage by file</h2>{file_table}
<p>The dependency count is every package in <code>Cargo.lock</code>, direct and
transitive. Lines of Rust count every <code>.rs</code> line under <code>crates/</code>,
tests included.</p>"""
write(out, "quality/index.html", page("Code quality", body, 1, "quality/", sha))
# ---- benchmarks + overview -------------------------------------------------------
def build_bench(out: Path, bench: Path | None, sha: str) -> None:
if bench is None or not bench.is_file():
write(out, "bench/index.html", page(
"Benchmarks", "<h1>Benchmarks</h1><p>No benchmark history yet.</p>", 1, "bench/", sha))
return
rendered = bench.read_text(encoding="utf-8")
# The history renderer emits a complete document; keep its body (and its
# own styles) under the site's header.
styles = "".join(re.findall(r"<style[^>]*>.*?</style>", rendered, re.S | re.I))
m = re.search(r"<body[^>]*>(.*)</body>", rendered, re.S | re.I)
inner = m.group(1) if m else rendered
text = page("Benchmarks", inner, 1, "bench/", sha)
write(out, "bench/index.html", text.replace("</head>", styles + "</head>", 1))
def build_index(out: Path, quality: dict | None, sha: str) -> None:
grade = html.escape(str((quality or {}).get("grade", "pending")))
body = f"""<h1>Alkane Toolkit</h1>
<p>Desktop discovery and monitoring for ASIC miners on your network: find every
miner in your IP ranges, see hashrate, power, temperatures, fans and hashboard
health at a glance, and run the controls each firmware supports.</p>
<div class="buttons"><a class="primary" href="{RELEASES}">Download for Windows or Linux</a>
<a href="manual/">Read the manual</a><a href="quality/">Code quality: {grade}</a>
<a href="bench/">Benchmarks</a></div>
<h2>Platforms</h2>
<ul><li><b>Windows 10 and 11</b> (x86_64): one signed, self-contained <code>alkane-toolkit.exe</code>.</li>
<li><b>Linux</b> (x86_64, GTK 3): one binary.</li></ul>
<p>Every release is built, tested and signed by CI from the public source.</p>"""
write(out, "index.html", page("Overview", body, 0, "", sha))
def main() -> None:
ap = argparse.ArgumentParser(description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
ap.add_argument("--out", required=True)
ap.add_argument("--manual", default="docs/manual")
ap.add_argument("--quality", default=None)
ap.add_argument("--bench", default=None)
ap.add_argument("--sha", default="")
args = ap.parse_args()
out = Path(args.out)
if out.exists():
shutil.rmtree(out)
out.mkdir(parents=True)
quality = None
if args.quality and Path(args.quality).is_file():
quality = json.loads(Path(args.quality).read_text())
if not isinstance(quality, dict) or quality.get("schema") != 1:
raise SystemExit("unsupported quality.json")
(out / "style.css").write_text(CSS.strip() + "\n", encoding="utf-8")
build_index(out, quality, args.sha)
build_manual(out, Path(args.manual), args.sha)
build_quality(out, quality, args.sha)
build_bench(out, Path(args.bench) if args.bench else None, args.sha)
print(f"built {sum(1 for _ in out.rglob('*.html'))} pages in {out}")
if __name__ == "__main__":
main()
+11 -4
View File
@@ -22,24 +22,31 @@ def main() -> int:
for path in sorted((ROOT / ".gitea/workflows").glob("*.yml")):
workflow = yaml.load(path.read_text(), Loader=yaml.BaseLoader)
for name, job in workflow.get("jobs", {}).items():
if (job.get("runs-on") in {"alkane-fast", "alkane-pages"}
and "secrets." in str(job)):
print(f"{path.name}: {name} exposes a secret to the fast runner", file=sys.stderr)
return 1
if job.get("runs-on") not in {"alkane-ci", "alkane-fast", "alkane-verify"}:
continue
if job.get("container", {}).get("image") != IMAGE:
print(f"{path.name}: {name} has a different runner image", file=sys.stderr)
return 1
pages = yaml.load(
(ROOT / ".gitea/workflows/bench-pages.yml").read_text(),
(ROOT / ".gitea/workflows/pages.yml").read_text(),
Loader=yaml.BaseLoader,
)
if (pages["on"]["workflow_run"]["workflows"] != ["build-test-release"]
or pages["jobs"]["publish"].get("runs-on") != "alkane-pages"):
print("Benchmark Pages must follow main CI on the Pages runner", file=sys.stderr)
or pages["jobs"]["publish"].get("runs-on") != "alkane-verify"):
print("Pages must follow main CI on the trusted verifier", file=sys.stderr)
return 1
release = yaml.load(
(ROOT / ".gitea/workflows/release.yml").read_text(),
Loader=yaml.BaseLoader,
)
if any("ci/publish-bench-pages.py" in step.get("run", "")
if release["jobs"]["release"].get("runs-on") != "alkane-ci":
print("Main release must use the dedicated Alkane build pool", file=sys.stderr)
return 1
if any("ci/publish-pages.py" in step.get("run", "")
for step in release["jobs"]["release"]["steps"]):
print("Main release must not publish Pages from GARM", file=sys.stderr)
return 1
+8 -2
View File
@@ -1,15 +1,21 @@
#!/usr/bin/env bash
# SPDX-License-Identifier: MIT
# Avoid a runner-local cache download when the pinned image has this source.
# check-wx-image-prefix.sh [linux|windows]
set -euo pipefail
prefix="${WX_PREFIX:?WX_PREFIX is required}"
case "${1:-linux}" in
linux) prefix="${WX_PREFIX:?WX_PREFIX is required}"; library=lib/libwx_gtk3u-3.3.a ;;
windows) prefix="${WX_WINDOWS_PREFIX:?WX_WINDOWS_PREFIX is required}"
library=lib/libwx_mswu-3.3-x86_64-w64-mingw32.a ;;
*) echo "unknown wx platform: $1" >&2; exit 2 ;;
esac
expected="$(awk '$1 == "sha256:" {print $2}' thirdparty/wxwidgets/VERSION)"
[[ "$expected" =~ ^[0-9a-f]{64}$ ]]
available=false
if [ ! -L "$prefix" ] && [ ! -L "$prefix/.alkane-source-sha256" ] &&
[ -x "$prefix/bin/wx-config" ] &&
[ -s "$prefix/lib/libwx_gtk3u-3.3.a" ] &&
[ -s "$prefix/$library" ] &&
[ "$(cat "$prefix/.alkane-source-sha256" 2>/dev/null || true)" = "$expected" ]; then
available=true
fi
+13 -2
View File
@@ -9,8 +9,9 @@ import sys
ROOT = Path(__file__).resolve().parents[1]
DIRECTORIES = ("target", "dist", "coverage", "bench-site")
FILES = ("bench-current.txt",)
DIRECTORIES = ("target", "dist", "coverage", "bench-site", "site")
FILES = ("bench-current.txt", "coverage-summary.txt", "quality.json")
BADGE_FILES = ("bench-baseline.json", "bench-context.json", "quality.json")
def cleanup() -> None:
@@ -32,6 +33,16 @@ def cleanup() -> None:
if path.is_file():
path.unlink()
print(f"Removed generated file: {name}")
badge_dir = ROOT / "badges"
if badge_dir.is_symlink():
raise ValueError("unsafe generated badge directory")
for name in BADGE_FILES:
path = badge_dir / name
if path.is_symlink() or path.parent.resolve() != badge_dir.resolve():
raise ValueError(f"unsafe generated badge file: {path}")
if path.is_file():
path.unlink()
print(f"Removed generated badge file: {name}")
if __name__ == "__main__":
+7 -3
View File
@@ -36,13 +36,17 @@ crates/alkane-gui/src/bin/*)
ui=true ;;
crates/alkane-core/*|crates/alkane-discovery/*|crates/alkane-access/*|\
crates/alkane-flash/*|crates/alkane-artifacts/*|crates/alkane-cli/*|\
crates/alkane-gui/src/*|Cargo.toml|Cargo.lock|.gitea/*|ci/*|scripts/*|\
crates/alkane-gui/src/*|crates/alkane-gui/Cargo.toml|crates/alkane-gui/build.rs|\
crates/alkane-gui/windows/*|crates/alkane-gui/assets/*|\
Cargo.toml|Cargo.lock|.gitea/*|ci/*|scripts/*|\
vendor/*|thirdparty/asic-rs/*)
# Any other GUI source file (naming, scan, model, pool_prefs, restore,
# access_probe, credentials, ...) is backend logic. ui.rs/fixtures.rs/bin
# access_probe, credentials, ...) is backend logic, as is how the binary
# is built and packaged (build.rs, the Windows manifest/icon/version
# resources, embedded assets). ui.rs/fixtures.rs/bin
# match the UI arm above first, so they still bump Z, not Y.
backend=true ;;
*) : ;; # docs, HANDOFF, README, thirdparty/wxwidgets tree: no bump
*) : ;; # docs, README, thirdparty/wxwidgets tree: no bump
esac
done <<< "$changed"
+7 -1
View File
@@ -3,13 +3,19 @@
# Use the preinstalled CI image or install missing packages on older runners.
set -euo pipefail
mode="${1:?usage: ensure-build-deps.sh base|ui|all|ssh}"
mode="${1:?usage: ensure-build-deps.sh base|ui|all|ssh|windows|pages}"
case "$mode" in
base) packages=(libssl-dev pkg-config ca-certificates) ;;
ui) packages=(xvfb xauth dbus-x11 fonts-dejavu-core) ;;
ssh) packages=(openssh-client) ;;
pages) packages=(python3-markdown) ;;
all) packages=(libssl-dev pkg-config ca-certificates openssh-client
xvfb xauth dbus-x11 fonts-dejavu-core) ;;
# Windows cross build (mingw-w64, posix threads) + Wine for its tests.
windows) packages=(libssl-dev pkg-config ca-certificates
gcc-mingw-w64-x86-64-posix g++-mingw-w64-x86-64-posix
binutils-mingw-w64-x86-64 mingw-w64-x86-64-dev wine wine64 xvfb xauth
openjdk-21-jre-headless) ;;
*) echo "unknown dependency set: $mode" >&2; exit 2 ;;
esac
+21 -6
View File
@@ -1,9 +1,24 @@
#!/usr/bin/env bash
# SPDX-License-Identifier: MIT
# Use the matching image or cache prefix; rebuild after a vendored source bump.
# ensure-wx-prefix.sh [linux|windows] (default linux: wxGTK in $WX_PREFIX;
# windows: the mingw wxMSW prefix in $WX_WINDOWS_PREFIX)
set -euo pipefail
prefix="${WX_PREFIX:?WX_PREFIX is required}"
platform="${1:-linux}"
case "$platform" in
linux)
prefix="${WX_PREFIX:?WX_PREFIX is required}"
allowed=/root/.cache/wx-3.3.3-linux
library=lib/libwx_gtk3u-3.3.a
build=scripts/build-wx-linux.sh ;;
windows)
prefix="${WX_WINDOWS_PREFIX:?WX_WINDOWS_PREFIX is required}"
allowed=/root/.cache/wx-3.3.3-mingw
library=lib/libwx_mswu-3.3-x86_64-w64-mingw32.a
build=scripts/build-wx-windows.sh ;;
*) echo "unknown wx platform: $platform" >&2; exit 2 ;;
esac
if [ -L "$prefix" ] || [ -L "$prefix/.alkane-source-sha256" ]; then
echo 'refusing symlinked wxWidgets prefix or source marker' >&2
exit 1
@@ -15,13 +30,13 @@ expected="$(awk '$1 == "sha256:" {print $2}' thirdparty/wxwidgets/VERSION)"
}
marker="$prefix/.alkane-source-sha256"
if [ -e "$marker" ] && [ "$(cat "$marker")" != "$expected" ]; then
python3 - "$prefix" <<'PY'
python3 - "$prefix" "$allowed" <<'PY'
from pathlib import Path
import shutil
import sys
prefix = Path(sys.argv[1])
allowed = Path('/root/.cache/wx-3.3.3-linux')
allowed = Path(sys.argv[2])
if prefix != allowed or prefix.is_symlink():
raise SystemExit('refusing unsafe wxWidgets prefix reset')
if prefix.is_dir():
@@ -30,13 +45,13 @@ PY
fi
built=false
if [ ! -x "$prefix/bin/wx-config" ] ||
[ ! -s "$prefix/lib/libwx_gtk3u-3.3.a" ]; then
bash scripts/build-wx-linux.sh
[ ! -s "$prefix/$library" ]; then
WX_WINDOWS_PREFIX="$prefix" sh "$build"
built=true
else
echo 'wx prefix available from matching image or cache'
fi
[ -s "$prefix/lib/libwx_gtk3u-3.3.a" ]
[ -s "$prefix/$library" ]
printf '%s\n' "$expected" > "$marker"
if [ -n "${GITHUB_OUTPUT:-}" ]; then
printf 'built=%s\n' "$built" >> "$GITHUB_OUTPUT"
+41
View File
@@ -0,0 +1,41 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Download the measured quality record (badges/quality.json on ci-badges).
fetch-quality.py OUT.json
Writes nothing (and exits 0) when main CI has not published one yet, so the
Pages build shows a "not measured yet" dashboard instead of failing.
"""
import base64
import json
import os
from pathlib import Path
import sys
from urllib.error import HTTPError
from urllib.request import Request, urlopen
def main() -> None:
out = Path(sys.argv[1])
api = os.environ["GITHUB_API_URL"].rstrip("/")
repo = os.environ["GITHUB_REPOSITORY"]
url = f"{api}/repos/{repo}/contents/badges/quality.json?ref=ci-badges"
request = Request(url, headers={"Authorization": f"token {os.environ['GITEA_TOKEN']}"})
try:
with urlopen(request, timeout=20) as response:
content = base64.b64decode(json.load(response)["content"])
except HTTPError as error:
if error.code == 404:
print("No quality record published yet")
return
raise
if not isinstance(json.loads(content), dict):
sys.exit("invalid quality record")
out.write_bytes(content)
print(f"Fetched quality record ({len(content)} bytes)")
if __name__ == "__main__":
main()
+125 -14
View File
@@ -11,8 +11,10 @@ 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 json
import math
import os
from pathlib import Path
import re
import sys
@@ -38,7 +40,8 @@ def text_width(s: str) -> float:
return len(s) * CHAR_W + 2 * PAD
def badge_svg(label: str, message: str, color: str) -> str:
def badge_svg(label: str, message: str, color: str,
description: str | None = None) -> str:
color = COLORS.get(color, color)
lw = round(text_width(label), 1)
mw = round(text_width(message), 1)
@@ -46,8 +49,9 @@ def badge_svg(label: str, message: str, color: str) -> str:
lx = round(lw / 2, 1)
mx = round(lw + mw / 2, 1)
# Text is drawn twice (a dark shadow then the light glyphs) for the shields look.
return f'''<svg xmlns="http://www.w3.org/2000/svg" width="{total}" height="20" role="img" aria-label="{label}: {message}">
<title>{label}: {message}</title>
description = description or f"{label}: {message}"
return f'''<svg xmlns="http://www.w3.org/2000/svg" width="{total}" height="20" role="img" aria-label="{description}">
<title>{description}</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
@@ -131,10 +135,72 @@ def cov_color(pct: float) -> str:
return "red"
def quality_grade(clippy: str | None) -> str:
if clippy is None:
# Code-quality grade (shown on the badge and explained on the Pages quality
# dashboard). Lint failures fail the grade outright; otherwise the grade is the
# measured line-coverage band, using the same bands as the coverage badge
# colour, so the two badges can never disagree.
GRADE_BANDS = ((80.0, "A"), (60.0, "B"), (40.0, "C"), (20.0, "D"))
GRADE_COLORS = {"A": "brightgreen", "B": "yellowgreen", "C": "yellow",
"D": "orange", "F": "red", "pending": "lightgrey"}
def quality_grade(clippy: str | None, coverage: float | None = None) -> str:
if clippy is None or (clippy == "clean" and coverage is None):
return "pending"
return "A" if clippy == "clean" else "F"
if clippy != "clean":
return "F"
for floor, grade in GRADE_BANDS:
if coverage >= floor:
return grade
return "F"
def coverage_by_file(summary_path: str | None, root: str) -> list[dict]:
"""Per-file line coverage from a `cargo llvm-cov --summary-only` table.
Columns: Filename, Regions, Missed Regions, Cover, Functions, Missed
Functions, Executed, Lines, Missed Lines, Cover, ...
"""
if not summary_path:
return []
rows = []
root_abs = os.path.abspath(root).rstrip("/") + "/"
for line in Path(summary_path).read_text(errors="replace").splitlines():
cols = line.split()
if len(cols) < 10 or cols[0] in ("Filename", "TOTAL") or not cols[0].endswith(".rs"):
continue
try:
lines, missed = int(cols[7]), int(cols[8])
except ValueError:
continue
name = cols[0][len(root_abs):] if cols[0].startswith(root_abs) else cols[0]
# llvm-cov drops the prefix every file shares, so when only workspace
# crates are measured "crates/alkane-gui/src/x.rs" is printed as
# "alkane-gui/src/x.rs". Put the prefix back.
first = Path(name).parts[0] if Path(name).parts else ""
if not name.startswith("crates/") and (Path(root) / "crates" / first).is_dir():
name = f"crates/{name}"
rows.append({"file": name, "lines": lines, "missed": missed})
return rows
def crate_of(path: str) -> str:
parts = Path(path).parts
if "crates" in parts and parts.index("crates") + 1 < len(parts):
return parts[parts.index("crates") + 1]
if "wx-rs-0.2.0-patched" in parts:
return "wx-rs (bridge)"
return "other"
def loc_by_crate(root: str) -> dict[str, int]:
out: dict[str, int] = {}
crates = Path(root) / "crates"
for path in sorted(crates.glob("*/**/*.rs")):
crate = path.relative_to(crates).parts[0]
with open(path, encoding="utf-8", errors="ignore") as fh:
out[crate] = out.get(crate, 0) + sum(1 for _ in fh)
return out
def human(n: int) -> str:
@@ -165,6 +231,9 @@ def main() -> int:
# percentage string, or "NEW" when there is no baseline.
ap.add_argument("--bench-delta", default=None)
ap.add_argument("--clippy", choices=("clean", "failed"))
# The full `cargo llvm-cov --summary-only` table, for the per-crate and
# per-file breakdown in quality.json (the Pages quality dashboard).
ap.add_argument("--coverage-summary", default=None)
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):
@@ -172,10 +241,10 @@ def main() -> int:
os.makedirs(os.path.join(args.root, args.out), exist_ok=True)
def write(name, label, message, color):
def write(name, label, message, color, description=None):
path = os.path.join(args.root, args.out, name + ".svg")
with open(path, "w", encoding="utf-8") as fh:
fh.write(badge_svg(label, message, color))
fh.write(badge_svg(label, message, color, description))
print(f"wrote {path}: {label}={message}")
loc = count_loc(args.root)
@@ -185,10 +254,9 @@ 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 = quality_grade(args.clippy)
write("quality", "code quality", grade,
{"A": "brightgreen", "B": "yellowgreen", "C": "yellow",
"D": "orange", "F": "red", "pending": "lightgrey"}[grade])
grade = quality_grade(args.clippy, args.coverage)
write("quality", "code quality", grade, GRADE_COLORS[grade],
f"code quality: {grade} (Clippy, rustfmt and line coverage)")
if args.tests is not None:
write("tests", "tests", f"{args.tests} passing", "brightgreen")
if args.coverage is not None:
@@ -196,6 +264,14 @@ def main() -> int:
write("bench-coverage", "bench coverage",
f"{args.bench_coverage:.0f}%" if args.bench_coverage is not None else "pending",
cov_color(args.bench_coverage) if args.bench_coverage is not None else "lightgrey")
context_path = Path(args.root) / args.out / "bench-context.json"
same_inputs = False
if context_path.is_file():
context = json.loads(context_path.read_text())
if (not isinstance(context, dict) or context.get("schema") != 1 or
not isinstance(context.get("same_inputs"), bool)):
raise ValueError("invalid benchmark comparison context")
same_inputs = context["same_inputs"]
# Bench badge: prefer the mean per-benchmark improvement vs the previous
# release. Use the static label when no comparison is available.
delta = None
@@ -206,12 +282,47 @@ def main() -> int:
delta = None
if delta is not None:
# Positive = faster than the previous release.
msg = f"{'+' if delta > 0 else ''}{delta:.1f}% vs prev"
write("bench", "bench", msg, bench_color(delta))
msg = f"{'+' if delta > 0 else ''}{delta:.1f}%"
if same_inputs:
write("bench", "bench", msg + " same inputs", "lightgrey")
else:
write("bench", "bench", msg + " vs prev", bench_color(delta))
elif args.bench_delta == "NEW":
write("bench", "bench", "baseline set", "blue")
elif args.bench is not None:
write("bench", "bench", args.bench, "blue")
# Everything above, plus the per-crate breakdowns, for the Pages quality
# dashboard (ci/build-pages.py).
files = coverage_by_file(args.coverage_summary, args.root)
crates: dict[str, dict] = {}
for row in files:
c = crates.setdefault(crate_of(row["file"]), {"lines": 0, "missed": 0})
c["lines"] += row["lines"]
c["missed"] += row["missed"]
quality = {
"schema": 1,
"sha": os.environ.get("GITHUB_SHA", ""),
"grade": grade,
"grade_bands": [[floor, letter] for floor, letter in GRADE_BANDS],
"clippy": args.clippy,
"rustfmt": "clean" if args.clippy is not None else None,
"tests_passed": args.tests,
"coverage_pct": args.coverage,
"bench_coverage_pct": args.bench_coverage,
"bench_delta_pct": delta,
"bench_same_inputs": same_inputs,
"loc": loc,
"loc_by_crate": loc_by_crate(args.root),
"dependencies": deps,
"license": lic,
"coverage_by_crate": crates,
"coverage_by_file": files,
}
path = os.path.join(args.root, args.out, "quality.json")
with open(path, "w", encoding="utf-8") as fh:
json.dump(quality, fh, indent=1, sort_keys=True)
print(f"wrote {path}")
return 0
+59
View File
@@ -0,0 +1,59 @@
# syntax=docker/dockerfile:1
# Alkane Toolkit CI image (ci/runner-image.txt pins the pushed digest).
#
# Layered on the previously verified image, so every Linux job keeps exactly
# the toolchain it had (Rust 1.97.1, prebuilt wxGTK prefix, sccache,
# cargo-llvm-cov), and adds what the Windows jobs need:
# - mingw-w64 (posix threads) and the rustup target x86_64-pc-windows-gnu
# - a prebuilt static wxMSW 3.3.3 prefix, built from the vendored source by
# scripts/build-wx-windows.sh and stamped with the source digest the same
# way as the wxGTK prefix (ci/ensure-wx-prefix.sh rebuilds on a mismatch)
# - Wine with an initialised prefix, to run the Windows tests and self-test
# - a Java runtime and jsign (checksum-pinned), to Authenticode-sign the .exe
# through Azure Artifact Signing (ci/sign-windows.sh)
#
# Build and push from the workstation with ci/images/build-image.sh.
ARG BASE=gitea.bluefla.re/blueflare/alkane-ci@sha256:9d2a992bbcb91014af3c85d2e1ec8c5990701cecf83fd06c8d46f9ef13dbd948
FROM ${BASE}
RUN DEBIAN_FRONTEND=noninteractive apt-get update -qq \
&& DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends \
gcc-mingw-w64-x86-64-posix g++-mingw-w64-x86-64-posix \
binutils-mingw-w64-x86-64 mingw-w64-x86-64-dev \
wine wine64 xvfb xauth openjdk-21-jre-headless \
&& rm -rf /var/lib/apt/lists/*
# jsign (Maven Central net.jsign:jsign; keep in step with ci/windows-ci.sh).
ARG JSIGN_VERSION=7.6
ARG JSIGN_SHA256=6cf58aa080e7ff82656f320cff8d4a3bff30408df8766806dcba3740dd839fa5
RUN mkdir -p /opt/jsign \
&& curl -sSfL -o /opt/jsign/jsign.jar \
"https://repo1.maven.org/maven2/net/jsign/jsign/${JSIGN_VERSION}/jsign-${JSIGN_VERSION}.jar" \
&& echo "${JSIGN_SHA256} /opt/jsign/jsign.jar" | sha256sum -c - \
&& java -jar /opt/jsign/jsign.jar --help >/dev/null
RUN rustup target add x86_64-pc-windows-gnu
# The build context is the repository root, filtered by
# alkane-ci.Dockerfile.dockerignore down to the wx source and its build script.
COPY thirdparty/wxwidgets /tmp/alkane/thirdparty/wxwidgets
COPY scripts/build-wx-windows.sh /tmp/alkane/scripts/build-wx-windows.sh
RUN HOME=/root WX_WINDOWS_PREFIX=/root/.cache/wx-3.3.3-mingw \
sh /tmp/alkane/scripts/build-wx-windows.sh \
&& awk '$1 == "sha256:" {print $2}' /tmp/alkane/thirdparty/wxwidgets/VERSION \
> /root/.cache/wx-3.3.3-mingw/.alkane-source-sha256 \
&& rm -rf /tmp/alkane
# A ready Wine prefix saves ~10 s per job (scripts/wine-run.sh reuses it).
RUN WINEPREFIX=/root/.cache/alkane-wine WINEDEBUG=-all \
WINEDLLOVERRIDES='winemenubuilder.exe=d;mscoree=d;mshtml=d' \
sh -c 'wineboot --init; wineboot --shutdown; wineserver -w' >/dev/null 2>&1; \
test -f /root/.cache/alkane-wine/system.reg
RUN test -s /root/.cache/wx-3.3.3-mingw/lib/libwx_mswu-3.3-x86_64-w64-mingw32.a \
&& test "$(/root/.cache/wx-3.3.3-mingw/bin/wx-config --version)" = 3.3.3 \
&& test -s /root/.cache/wx-3.3.3-linux/lib/libwx_gtk3u-3.3.a \
&& x86_64-w64-mingw32-g++-posix --version >/dev/null \
&& wine --version \
&& test -s /opt/jsign/jsign.jar \
&& rustup target list --installed | grep -qx x86_64-pc-windows-gnu
@@ -0,0 +1,4 @@
# Only what the image build copies: the vendored wx tree and its build script.
*
!thirdparty/wxwidgets/**
!scripts/build-wx-windows.sh
+39
View File
@@ -0,0 +1,39 @@
#!/bin/sh
# Build the CI image from ci/images/alkane-ci.Dockerfile, push it to the Gitea
# registry, and pin the pushed digest in ci/runner-image.txt and every
# workflow (ci/check-runner-image.py enforces the pin).
#
# Run on the workstation, which holds the registry credential; it is passed to
# a throwaway Docker config that is deleted afterwards, never to a runner.
# ci/images/build-image.sh TAG e.g. ci/images/build-image.sh windows-2026-11-02
set -eu
TAG=${1:?usage: build-image.sh TAG}
REPO=$(CDPATH= cd -- "$(dirname -- "$0")/../.." && pwd)
REGISTRY=gitea.bluefla.re
IMAGE=$REGISTRY/blueflare/alkane-ci
TOKEN_FILE=${GITEA_TOKEN_FILE:-$HOME/.config/gitea/token}
cd "$REPO"
DOCKER_CONFIG=$(mktemp -d)
export DOCKER_CONFIG
trap 'rm -rf "$DOCKER_CONFIG"' 0
user=$(curl -sS --config - "https://$REGISTRY/api/v1/user" <<CFG | python3 -c 'import json,sys; print(json.load(sys.stdin)["login"])'
header = "Authorization: token $(cat "$TOKEN_FILE")"
CFG
)
docker login "$REGISTRY" -u "$user" --password-stdin < "$TOKEN_FILE" >/dev/null
DOCKER_BUILDKIT=1 docker build -f ci/images/alkane-ci.Dockerfile -t "$IMAGE:$TAG" .
docker push "$IMAGE:$TAG" >/dev/null
digest=$(docker inspect --format '{{range .RepoDigests}}{{println .}}{{end}}' "$IMAGE:$TAG" \
| grep "^$IMAGE@sha256:" | head -1)
[ -n "$digest" ] || { echo "no registry digest for $IMAGE:$TAG" >&2; exit 1; }
old=$(cat ci/runner-image.txt)
printf '%s\n' "$digest" > ci/runner-image.txt
grep -rl "$old" .gitea/workflows | while read -r f; do
python3 - "$f" "$old" "$digest" <<'PY'
import pathlib, sys
p, old, new = pathlib.Path(sys.argv[1]), sys.argv[2], sys.argv[3]
p.write_text(p.read_text().replace(old, new))
PY
done
python3 ci/check-runner-image.py
echo "pinned $digest"
+109
View File
@@ -0,0 +1,109 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Package the universal macOS build as an app bundle, for release.
package-macos.py VERSION BINARY OUT_DIR
BINARY is the universal (arm64 + x86_64) alkane-toolkit executable made by
scripts/build-gui-macos.sh. Writes
dist/alkane-toolkit-vVERSION-macos-universal.zip holding "Alkane Toolkit.app",
LICENSE and README.txt, and prints its path. Runs on macOS (lipo, codesign,
ditto).
The bundle is ad-hoc signed only (Apple Silicon refuses to run unsigned
code); it is not signed with a Developer ID or notarized, so Gatekeeper asks
the user to confirm the first launch. README.txt says how.
"""
import pathlib
import plistlib
import shutil
import subprocess
import sys
import tempfile
ROOT = pathlib.Path(__file__).resolve().parents[1]
APP = "Alkane Toolkit.app"
BUNDLE_ID = "re.bluefla.alkane-toolkit"
MIN_MACOS = "11.0"
def run(*args: str) -> str:
return subprocess.run(args, check=True, capture_output=True, text=True).stdout
def build_app(version: str, binary: pathlib.Path, dest: pathlib.Path) -> pathlib.Path:
archs = run("lipo", "-archs", str(binary)).split()
if sorted(archs) != ["arm64", "x86_64"]:
sys.exit(f"{binary} is not a universal arm64 + x86_64 binary: {archs}")
app = dest / APP
macos = app / "Contents" / "MacOS"
resources = app / "Contents" / "Resources"
macos.mkdir(parents=True)
resources.mkdir()
shutil.copy2(binary, macos / "alkane-toolkit")
shutil.copy2(ROOT / "crates/alkane-gui/macos/alkane-toolkit.icns", resources)
info = {
"CFBundleName": "Alkane Toolkit",
"CFBundleDisplayName": "Alkane Toolkit",
"CFBundleIdentifier": BUNDLE_ID,
"CFBundleExecutable": "alkane-toolkit",
"CFBundleIconFile": "alkane-toolkit",
"CFBundlePackageType": "APPL",
"CFBundleShortVersionString": version,
"CFBundleVersion": version,
"CFBundleInfoDictionaryVersion": "6.0",
"LSMinimumSystemVersion": MIN_MACOS,
"NSHighResolutionCapable": True,
"NSPrincipalClass": "NSApplication",
# The scanner talks to miners on the local network.
"NSLocalNetworkUsageDescription":
"Alkane Toolkit scans your local network to find and manage miners.",
"NSHumanReadableCopyright":
"Copyright (c) 2026 BlueFlare Energy Solutions Inc. (MIT License)",
}
with open(app / "Contents" / "Info.plist", "wb") as fh:
plistlib.dump(info, fh)
(app / "Contents" / "PkgInfo").write_text("APPL????")
# Ad-hoc signature over the whole bundle (the linker's per-slice
# signatures do not cover Info.plist or the resources).
run("codesign", "--force", "--sign", "-", "--timestamp=none", str(app))
run("codesign", "--verify", "--strict", str(app))
return app
def release(version: str, binary: str, out_dir: str) -> None:
name = f"alkane-toolkit-v{version}-macos-universal"
out = pathlib.Path(out_dir).resolve() / f"{name}.zip"
out.parent.mkdir(parents=True, exist_ok=True)
readme = (
f"alkane-toolkit v{version} (macOS, Apple Silicon and Intel)\n"
"\n"
f"Runs on macOS {MIN_MACOS} (Big Sur) or later. Drag \"Alkane Toolkit\"\n"
"to Applications, then open it.\n"
"\n"
"The app is not notarized by Apple, so the first launch is blocked\n"
"with a warning. To allow it once:\n"
" - macOS 15 or later: try to open it, then System Settings >\n"
" Privacy & Security > \"Open Anyway\" for Alkane Toolkit.\n"
" - macOS 11 to 14: Control-click the app, choose Open, then Open.\n"
"Or, in Terminal: xattr -dr com.apple.quarantine \"/Applications/Alkane Toolkit.app\"\n"
"\n"
"Settings are stored in ~/.config/alkane-toolkit/.\n"
"Manual: https://blueflare.gitea.bluefla.re/alkane-toolkit/manual/\n"
)
with tempfile.TemporaryDirectory(prefix="alkane-macos-") as tmp:
folder = pathlib.Path(tmp) / name
folder.mkdir()
build_app(version, pathlib.Path(binary), folder)
shutil.copy2(ROOT / "LICENSE", folder / "LICENSE")
(folder / "README.txt").write_text(readme)
out.unlink(missing_ok=True)
run("ditto", "-c", "-k", "--keepParent", str(folder), str(out))
print(out)
if __name__ == "__main__":
if len(sys.argv) != 4:
sys.exit(__doc__)
release(*sys.argv[1:])
+108
View File
@@ -0,0 +1,108 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Package the cross-built Windows toolkit for release and for native testing.
package-windows.py release VERSION EXE OUT_DIR
dist/alkane-toolkit-vVERSION-windows-x86_64.zip: one folder holding
alkane-toolkit.exe, LICENSE and a README.txt. Prints the zip path.
package-windows.py tests CARGO_JSON OUT_ZIP
A bundle of the test executables `cargo test --no-run
--message-format=json` reported (CARGO_JSON is that output), plus
tests.txt naming each one. The native Windows job runs every listed
executable on real Windows; the same binaries already ran under Wine.
"""
import json
import pathlib
import struct
import sys
import zipfile
ROOT = pathlib.Path(__file__).resolve().parents[1]
TARGET = "x86_64-pc-windows-gnu"
def release(version: str, exe: str, out_dir: str) -> None:
exe_path = pathlib.Path(exe)
if exe_path.suffix != ".exe" or not exe_path.is_file():
sys.exit(f"not a Windows executable: {exe}")
signed = _has_authenticode_signature(exe_path)
name = f"alkane-toolkit-v{version}-windows-x86_64"
out = pathlib.Path(out_dir) / f"{name}.zip"
out.parent.mkdir(parents=True, exist_ok=True)
readme = (
f"alkane-toolkit v{version} (Windows x86_64)\r\n"
"\r\n"
"Run alkane-toolkit.exe. No installer and no extra runtime are needed:\r\n"
"the executable is self-contained and runs on Windows 10 and 11.\r\n"
"\r\n"
+ (
"The executable is signed by BlueFlare Energy Solutions Inc. (Azure Artifact Signing). To check:\r\n"
"right-click alkane-toolkit.exe > Properties > Digital Signatures.\r\n"
if signed else
"This build is not code-signed, so Windows SmartScreen may warn on first\r\n"
"run: choose More info > Run anyway.\r\n"
)
+ "\r\n"
"Settings are kept in %APPDATA%\\alkane-toolkit.\r\n"
"SSH-based actions use the OpenSSH client built into Windows (ssh.exe);\r\n"
"HTTP actions use curl.exe, also built in.\r\n"
"\r\n"
"Offline demo: run from a Command Prompt with\r\n"
" set ALKANE_FAKE_SCAN=1 && alkane-toolkit.exe\r\n"
)
with zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED) as z:
z.write(exe_path, f"{name}/alkane-toolkit.exe")
z.write(ROOT / "LICENSE", f"{name}/LICENSE.txt")
z.writestr(f"{name}/README.txt", readme)
print(out)
def _has_authenticode_signature(exe: pathlib.Path) -> bool:
"""True if the PE file carries a certificate table (an Authenticode signature)."""
data = exe.read_bytes()
pe = struct.unpack_from("<I", data, 0x3C)[0]
magic = struct.unpack_from("<H", data, pe + 24)[0]
dirs = pe + 24 + (96 if magic == 0x10B else 112)
return struct.unpack_from("<II", data, dirs + 4 * 8)[1] > 0
def tests(cargo_json: str, out_zip: str) -> None:
executables = []
for line in pathlib.Path(cargo_json).read_text().splitlines():
try:
message = json.loads(line)
except json.JSONDecodeError:
continue
if (message.get("reason") == "compiler-artifact"
and message.get("profile", {}).get("test")
and message.get("executable")):
executables.append(pathlib.Path(message["executable"]))
executables = sorted(set(executables))
if not executables:
sys.exit("no test executables in the cargo output")
out = pathlib.Path(out_zip)
out.parent.mkdir(parents=True, exist_ok=True)
with zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED) as z:
names = []
for exe in executables:
if exe.suffix != ".exe" or TARGET not in exe.parts:
sys.exit(f"not a {TARGET} test executable: {exe}")
z.write(exe, exe.name)
names.append(exe.name)
z.writestr("tests.txt", "\n".join(names) + "\n")
print(f"{out} ({len(executables)} test executables)")
def main() -> None:
if len(sys.argv) == 5 and sys.argv[1] == "release":
release(*sys.argv[2:])
elif len(sys.argv) == 4 and sys.argv[1] == "tests":
tests(*sys.argv[2:])
else:
sys.exit(__doc__)
if __name__ == "__main__":
main()
+14 -2
View File
@@ -22,6 +22,15 @@ def documentation_only(paths: list[str]) -> bool:
)
def workflow_only(paths: list[str]) -> bool:
"""Limit the cheap PR check to workflow YAML, never policy code."""
return bool(paths) and all(
path.startswith(".gitea/workflows/") and
len(Path(path).parts) == 3 and Path(path).suffix == ".yml"
for path in paths
)
def headless_packages(paths: list[str]) -> list[str]:
"""Return tested reverse dependents for code outside the GUI graph."""
changed: set[str] = set()
@@ -95,12 +104,15 @@ def main() -> None:
try:
paths = changed_paths()
docs = documentation_only(paths)
packages = headless_packages(paths) if not docs else []
workflow = workflow_only(paths) if not docs else False
packages = headless_packages(paths) if not docs and not workflow else []
except (OSError, subprocess.CalledProcessError, ValueError):
paths = []
docs = False
workflow = False
packages = []
surface = "documentation" if docs else "headless" if packages else "full"
surface = ("documentation" if docs else "workflow" if workflow else
"headless" if packages else "full")
print(f"surface={surface}")
print(f"packages={' '.join(packages)}")
print(f"Changed paths: {len(paths)}", file=sys.stderr)
+9 -1
View File
@@ -2,6 +2,7 @@
# SPDX-License-Identifier: MIT
"""Publish measured toolkit badges to the private Gitea badge branch."""
import json
import os
from pathlib import Path
@@ -22,7 +23,14 @@ def main() -> None:
raise ValueError(f"invalid {name} SVG")
publish_file(api, repo, f"badges/{name}.svg", data, token,
f"Update measured {name} badge")
print(f"Published {len(NAMES)} measured badge SVGs")
# The full measurement record behind the badges, read by the Pages
# quality dashboard (ci/build-pages.py).
data = (ROOT / "badges" / "quality.json").read_bytes()
if not isinstance(json.loads(data), dict):
raise ValueError("invalid quality.json")
publish_file(api, repo, "badges/quality.json", data, token,
"Update measured quality record", max_bytes=262_144)
print(f"Published {len(NAMES)} measured badge SVGs and quality.json")
if __name__ == "__main__":
+79
View File
@@ -0,0 +1,79 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Publish the built Pages site to this repository's gh-pages branch.
publish-pages.py SITE_DIR
Served at https://blueflare.gitea.bluefla.re/alkane-toolkit/ by the Pages
server, which serves the gh-pages branch of public repositories. Each publish
is one orphan commit (force-pushed), so the branch never accumulates history.
Only main may publish, and a run for a superseded main commit skips.
"""
import json
import os
from pathlib import Path
import shutil
import subprocess
import sys
import tempfile
from urllib.request import Request, urlopen
BRANCH = "gh-pages"
MAX_BYTES = 20 * 1024 * 1024
def current_main_sha(api: str, repo: str, token: str) -> str:
request = Request(f"{api}/repos/{repo}/branches/main",
headers={"Authorization": f"token {token}"})
with urlopen(request, timeout=20) as response:
return json.load(response)["commit"]["id"]
def git(*args: str, cwd: Path, env: dict | None = None) -> None:
subprocess.run(("git", *args), cwd=cwd, env=env, check=True)
def main() -> None:
if len(sys.argv) != 2:
sys.exit(__doc__)
site = Path(sys.argv[1])
if not (site / "index.html").is_file():
sys.exit(f"{site} has no index.html")
size = sum(p.stat().st_size for p in site.rglob("*") if p.is_file())
if size > MAX_BYTES:
sys.exit(f"site is {size} bytes, over the {MAX_BYTES} byte limit")
for path in site.rglob("*"):
if path.is_file() and path.suffix not in {".html", ".css", ".svg", ".png", ".json"}:
sys.exit(f"unexpected file type on the site: {path}")
api = os.environ["GITHUB_API_URL"].rstrip("/")
repo = os.environ["GITHUB_REPOSITORY"]
sha = os.environ["GITHUB_SHA"]
token = os.environ["GITEA_TOKEN"]
if os.environ.get("GITHUB_REF") != "refs/heads/main":
sys.exit("Pages publication requires main")
if current_main_sha(api, repo, token) != sha:
print("Skipping Pages for a superseded main commit")
return
server = api.removesuffix("/api/v1")
with tempfile.TemporaryDirectory(prefix="alkane-pages-") as directory:
work = Path(directory)
shutil.copytree(site, work, dirs_exist_ok=True)
env = dict(os.environ, GIT_TERMINAL_PROMPT="0")
git("init", "-q", "-b", BRANCH, cwd=work)
git("-c", "user.name=Alkane CI", "-c", "user.email=ci@noreply.gitea.bluefla.re",
"add", "-A", cwd=work)
git("-c", "user.name=Alkane CI", "-c", "user.email=ci@noreply.gitea.bluefla.re",
"commit", "-q", "-m", f"Publish site for {sha[:10]} [skip ci]", cwd=work)
# The token is read from the environment by the credential helper at
# push time; it never appears on a command line or in the remote URL.
helper = '!f() { echo username=alkane-ci; echo "password=$GITEA_TOKEN"; }; f'
git("-c", f"credential.helper={helper}", "push", "-q", "--force",
f"{server}/{repo}.git", f"HEAD:refs/heads/{BRANCH}", cwd=work, env=env)
print(f"Published Pages for {sha[:10]} to {BRANCH}")
if __name__ == "__main__":
main()
+1 -1
View File
@@ -1 +1 @@
gitea.bluefla.re/blueflare/alkane-ci@sha256:9d2a992bbcb91014af3c85d2e1ec8c5990701cecf83fd06c8d46f9ef13dbd948
gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
+88
View File
@@ -0,0 +1,88 @@
#!/usr/bin/env bash
# SPDX-License-Identifier: MIT
# Authenticode-sign Windows executables with Azure Artifact Signing (formerly
# Trusted Signing), from Linux, with jsign. Every signature is RFC 3161
# timestamped: the signing certificates live only a few days, the timestamp is
# what keeps a signature valid after that.
#
# ci/sign-windows.sh FILE.exe [FILE.exe ...]
#
# Configuration (environment):
# AZURE_SIGNING_PROFILE certificate profile name; EMPTY = signing not set
# up yet: the files are left unsigned (exit 0)
# AZURE_SIGNING_ACCOUNT signing account (default blueflaresigning)
# AZURE_SIGNING_ENDPOINT account endpoint (default https://wus2.codesigning.azure.net)
# Credentials, one of:
# AZURE_SIGNING_TENANT_ID + AZURE_SIGNING_CLIENT_ID + AZURE_SIGNING_CLIENT_SECRET
# (the CI service principal alkane-toolkit-ci-signer, role
# "Artifact Signing Certificate Profile Signer" on the account only)
# AZURE_SIGNING_TOKEN an access token for https://codesigning.azure.net,
# e.g. from `az account get-access-token --resource https://codesigning.azure.net`
# ALKANE_JSIGN_JAR jsign jar (default /opt/jsign/jsign.jar, from the CI image)
#
# Once a profile is configured, any failure fails the job: a release is never
# shipped half-signed or silently unsigned.
set -euo pipefail
[ "$#" -gt 0 ] || { sed -n '3,25p' "$0" >&2; exit 2; }
profile="${AZURE_SIGNING_PROFILE:-}"
if [ -z "$profile" ]; then
echo "Windows code signing is not enabled (AZURE_SIGNING_PROFILE unset); leaving $* unsigned"
exit 0
fi
account="${AZURE_SIGNING_ACCOUNT:-blueflaresigning}"
endpoint="${AZURE_SIGNING_ENDPOINT:-https://wus2.codesigning.azure.net}"
jar="${ALKANE_JSIGN_JAR:-/opt/jsign/jsign.jar}"
[ -f "$jar" ] || { echo "jsign not found at $jar" >&2; exit 1; }
if [ -z "${AZURE_SIGNING_TOKEN:-}" ]; then
: "${AZURE_SIGNING_TENANT_ID:?signing credentials missing}"
: "${AZURE_SIGNING_CLIENT_ID:?signing credentials missing}"
: "${AZURE_SIGNING_CLIENT_SECRET:?signing credentials missing}"
# Client-credentials token for the signing service. The secret and token
# stay in this process's environment, never on a command line.
AZURE_SIGNING_TOKEN="$(python3 - <<'PY'
import json, os, sys, urllib.parse, urllib.request
body = urllib.parse.urlencode({
"grant_type": "client_credentials",
"client_id": os.environ["AZURE_SIGNING_CLIENT_ID"],
"client_secret": os.environ["AZURE_SIGNING_CLIENT_SECRET"],
"scope": "https://codesigning.azure.net/.default",
}).encode()
url = f"https://login.microsoftonline.com/{os.environ['AZURE_SIGNING_TENANT_ID']}/oauth2/v2.0/token"
try:
with urllib.request.urlopen(url, body, timeout=60) as r:
print(json.load(r)["access_token"])
except Exception as e:
sys.exit(f"could not get a signing token: {e}")
PY
)"
fi
export AZURE_SIGNING_TOKEN
for file in "$@"; do
java -jar "$jar" \
--storetype TRUSTEDSIGNING \
--keystore "${endpoint#https://}" \
--storepass env:AZURE_SIGNING_TOKEN \
--alias "$account/$profile" \
--alg SHA-256 \
--tsaurl http://timestamp.acs.microsoft.com --tsmode RFC3161 \
--tsretries 3 --tsretrywait 10 \
--name "Alkane Toolkit" \
--url https://gitea.bluefla.re/blueflare/alkane-toolkit \
"$file"
# jsign fails on any error; also make sure a signature actually landed in
# the PE certificate table before the file goes anywhere.
python3 - "$file" <<'PY'
import struct, sys
data = open(sys.argv[1], "rb").read()
pe = struct.unpack_from("<I", data, 0x3C)[0]
magic = struct.unpack_from("<H", data, pe + 24)[0]
dirs = pe + 24 + (96 if magic == 0x10B else 112)
offset, size = struct.unpack_from("<II", data, dirs + 4 * 8) # IMAGE_DIRECTORY_ENTRY_SECURITY
if size == 0:
sys.exit(f"{sys.argv[1]}: no Authenticode signature after signing")
print(f"{sys.argv[1]}: signed ({size} byte certificate table)")
PY
done
+42
View File
@@ -5,6 +5,7 @@
import importlib.util
import re
from pathlib import Path
import tempfile
import unittest
@@ -50,6 +51,47 @@ class BenchBadgeTests(unittest.TestCase):
self.assertEqual(gen_badges.bench_color(30.0), "brightgreen")
self.assertEqual(gen_badges.bench_color(-55.5555556), "orange")
def test_quality_grade_follows_lint_and_coverage(self):
# A lint failure fails the grade; otherwise it is the coverage band,
# with the same floors as the coverage badge colour.
self.assertEqual(gen_badges.quality_grade("failed", 95.0), "F")
self.assertEqual(gen_badges.quality_grade("clean", 85.0), "A")
self.assertEqual(gen_badges.quality_grade("clean", 65.6), "B")
self.assertEqual(gen_badges.quality_grade("clean", 48.0), "C")
self.assertEqual(gen_badges.quality_grade("clean", 25.0), "D")
self.assertEqual(gen_badges.quality_grade("clean", 5.0), "F")
self.assertEqual(gen_badges.quality_grade("clean"), "pending")
self.assertEqual(gen_badges.quality_grade(None, 90.0), "pending")
for pct in (85.0, 65.6, 48.0, 25.0):
grade = gen_badges.quality_grade("clean", pct)
self.assertEqual(gen_badges.GRADE_COLORS[grade], gen_badges.cov_color(pct))
def test_coverage_table_is_split_by_crate(self):
with tempfile.TemporaryDirectory(prefix="alkane-cov-") as directory:
summary = Path(directory) / "summary.txt"
summary.write_text(
"Filename Regions Missed Regions Cover Functions Missed Functions "
"Executed Lines Missed Lines Cover\n"
"crates/alkane-gui/src/ui.rs 10 5 50.00% 4 2 50.00% 100 60 40.00%\n"
"crates/alkane-core/src/platform.rs 4 0 100.00% 2 0 100.00% 50 5 90.00%\n"
"TOTAL 14 5 64.29% 6 2 66.67% 150 65 56.67%\n")
rows = gen_badges.coverage_by_file(str(summary), directory)
self.assertEqual([r["file"] for r in rows],
["crates/alkane-gui/src/ui.rs", "crates/alkane-core/src/platform.rs"])
self.assertEqual(rows[0]["missed"], 60)
self.assertEqual(gen_badges.crate_of(rows[1]["file"]), "alkane-core")
def test_coverage_table_restores_the_stripped_crates_prefix(self):
with tempfile.TemporaryDirectory(prefix="alkane-cov-") as directory:
(Path(directory) / "crates" / "alkane-cli").mkdir(parents=True)
summary = Path(directory) / "summary.txt"
summary.write_text(
"alkane-cli/src/main.rs 4 4 0.00% 1 1 0.00% 23 23 0.00%\n")
rows = gen_badges.coverage_by_file(str(summary), directory)
self.assertEqual(rows[0], {"file": "crates/alkane-cli/src/main.rs",
"lines": 23, "missed": 23})
self.assertEqual(gen_badges.crate_of(rows[0]["file"]), "alkane-cli")
if __name__ == "__main__":
unittest.main()
+62 -2
View File
@@ -3,11 +3,15 @@
"""Exercise benchmark history selection and safe site rendering."""
import sys
import json
from pathlib import Path
import subprocess
import tempfile
import unittest
sys.path.insert(0, str(Path(__file__).resolve().parent))
from bench_history import bench_badge, previous_measurement, render_html, updated_index
from bench_history import (bench_badge, git_distance, previous_measurement, render_html,
same_benchmark_inputs, updated_index)
class HistoryTests(unittest.TestCase):
@@ -41,6 +45,7 @@ class HistoryTests(unittest.TestCase):
self.assertEqual(updated["entries"][-1]["metrics"]["bench_ns_per_op"]["hash"], 7.5)
def test_invalid_measurement_and_sha_rejected(self):
self.assertIsNone(git_distance("--bad", "a" * 40))
with self.assertRaises(ValueError):
updated_index({}, "bad", {"bench_ns_per_op": {"hash": 1}}, "now")
with self.assertRaises(ValueError):
@@ -56,14 +61,69 @@ class HistoryTests(unittest.TestCase):
{"hash": 10.0})
self.assertEqual(previous_measurement(index, "b" * 40, distance, other), {})
def test_routing_change_is_marked_same_inputs_but_code_or_build_change_is_not(self):
with tempfile.TemporaryDirectory(prefix="alkane-bench-inputs-") as directory:
root = Path(directory)
workflow = root / ".gitea/workflows/release.yml"
workflow.parent.mkdir(parents=True)
code = root / "crates/alkane-gui/src/main.rs"
code.parent.mkdir(parents=True)
code.write_text("fn main() {}\n")
workflow.write_text(
"jobs:\n release:\n runs-on: alkane-verify\n"
" container:\n image: pinned-image\n"
" env:\n RUSTFLAGS: stable\n steps:\n"
" - name: Build release\n run: cargo build --release\n"
" - name: Microbenchmarks\n run: cargo test --release bench_\n")
def git(*args):
return subprocess.check_output(("git", "-C", str(root), *args),
text=True, stderr=subprocess.DEVNULL).strip()
git("init", "-q")
git("config", "user.name", "CI Test")
git("config", "user.email", "ci@example.invalid")
git("add", ".")
git("commit", "-qm", "base")
base = git("rev-parse", "HEAD")
workflow.write_text(workflow.read_text().replace("alkane-verify", "alkane-ci"))
git("commit", "-qam", "route")
route = git("rev-parse", "HEAD")
self.assertTrue(same_benchmark_inputs(base, route, root))
code.write_text("fn main() { println!(\"changed\"); }\n")
git("commit", "-qam", "code")
changed_code = git("rev-parse", "HEAD")
self.assertFalse(same_benchmark_inputs(route, changed_code, root))
workflow.write_text(workflow.read_text().replace("RUSTFLAGS: stable", "RUSTFLAGS: tuned"))
git("commit", "-qam", "flags")
flags = git("rev-parse", "HEAD")
self.assertFalse(same_benchmark_inputs(changed_code, flags, root))
def test_badge_keeps_raw_delta_and_marks_identical_inputs(self):
with tempfile.TemporaryDirectory(prefix="alkane-bench-badge-context-") as directory:
root = Path(directory)
badges = root / "badges"
badges.mkdir()
(badges / "bench-context.json").write_text(
json.dumps({"schema": 1, "same_inputs": True, "baseline_sha": "a" * 40}))
command = (sys.executable, str(Path(__file__).with_name("gen-badges.py")),
"--root", str(root), "--bench-delta=-36.4")
subprocess.run(command, check=True, capture_output=True)
self.assertIn("-36.4% same inputs", (badges / "bench.svg").read_text())
(badges / "bench-context.json").unlink()
subprocess.run(command, check=True, capture_output=True)
self.assertIn("-36.4% vs prev", (badges / "bench.svg").read_text())
def test_site_escapes_history_content(self):
entry = {"sha": "a" * 40, "timestamp": "<script>alert(1)</script>",
"metrics": {"bench_ns_per_op": {"hash": 10.0},
"bench_host": {"cpu_model": "<script>cpu</script>"}}}
"bench_host": {"cpu_model": "<script>cpu</script>"},
"bench_context": {"schema": 1, "same_inputs": True}}}
page = render_html({"entries": [entry]})
self.assertIn("&lt;script&gt;", page)
self.assertNotIn("<script>", page)
self.assertIn("10.000", page)
self.assertIn("same inputs", page)
if __name__ == "__main__":
+6
View File
@@ -53,6 +53,12 @@ R="$(new_repo)"; mkdir -p "$R/ci"; printf '2' > "$R/ci/version-x.txt"
printf 'x' > "$R/README.md"; commit "$R" init
run_case first_release_prebumped_x "$R" version=2.0.0 bump=initial release=true
# 3b. Windows packaging (build script / resources) is release-relevant: bumps Y
R="$(new_repo)"; mkdir -p "$R/ci" "$R/crates/alkane-gui/windows"; printf '0' > "$R/ci/version-x.txt"
printf 'x' > "$R/README.md"; commit "$R" init; git -C "$R" tag v1.2.3
printf '<assembly/>' > "$R/crates/alkane-gui/windows/alkane-toolkit.exe.manifest"; commit "$R" winres
run_case windows_resources_bump "$R" version=1.3.0 bump=backend release=true
# 3. Backend path change bumps Y
R="$(new_repo)"; mkdir -p "$R/ci" "$R/crates/alkane-gui/src"; printf '0' > "$R/ci/version-x.txt"
printf 'x' > "$R/README.md"; commit "$R" init; git -C "$R" tag v1.2.3
+116 -5
View File
@@ -4,13 +4,16 @@
import os
from pathlib import Path
import shutil
import subprocess
import tempfile
import importlib.util
import yaml
SCRIPT = Path(__file__).with_name("pr-surface.py")
ROOT = SCRIPT.parents[1]
spec = importlib.util.spec_from_file_location("pr_surface", SCRIPT)
assert spec and spec.loader
pr_surface = importlib.util.module_from_spec(spec)
@@ -24,18 +27,126 @@ def git(directory: Path, *args: str) -> str:
).strip()
def check_workflow_contract() -> None:
"""Keep the short workflow check from silently dropping release gates."""
required = [
("release.yml", "main", "release", (
"Check runner image pins", "Check first-party Rust formatting",
"Clippy (our crate, warnings are errors)",
"Build release", "Unit tests", "Microbenchmarks",
"Headless UI self-test", "Coverage", "Microbenchmark coverage",
"Generate measured badges", "Publish measured badges",
"Record private benchmark history", "Create Gitea release + upload artifact",
"Clean generated Toolkit build",
)),
("release.yml", "main", "windows", (
"Clippy (Windows target, warnings are errors)", "Build release (Windows)",
"Unit tests (Windows build, under Wine)",
"Headless UI self-test (Windows build, under Wine)",
"Sign Windows executable (Azure Artifact Signing)",
"Package Windows artifact", "Clean generated Toolkit build",
)),
("next.yml", "next", "candidate", (
"Check runner image pins", "Build release candidate",
"Create private prerelease", "Clean generated Toolkit build",
)),
("next.yml", "next", "windows", (
"Build Windows candidate", "Sign Windows candidate (Azure Artifact Signing)",
"Package Windows candidate",
"Clean generated Toolkit build",
)),
("verify.yml", "main", "verify", (
"Check runner image pins", "Detect changed surface",
"Check CI change surface", "Check first-party Rust formatting",
"Check workflow-only change",
"Clippy (our crate, warnings are errors)", "Build", "Unit tests",
"Microbenchmarks", "Headless UI self-test", "Clean generated Toolkit build",
)),
("verify.yml", "main", "verify-windows", (
"Clippy (Windows target, warnings are errors)", "Build (Windows)",
"Unit tests (Windows build, under Wine)",
"Headless UI self-test (Windows build, under Wine)",
"Clean generated Toolkit build",
)),
]
for filename, branch, job_name, gates in required:
path = ROOT / ".gitea/workflows" / filename
workflow = yaml.load(path.read_text(), Loader=yaml.BaseLoader)
event = "pull_request" if filename == "verify.yml" else "push"
assert workflow["on"][event]["branches"] == [branch], path
job = workflow["jobs"][job_name]
assert job["runs-on"] in {"alkane-ci", "alkane-verify"}, path
steps = job["steps"]
names = [step.get("name") for step in steps]
positions = [names.index(gate) for gate in gates]
assert positions == sorted(positions), path
assert steps[positions[-1]].get("if") == "always()", path
for gate, position in zip(gates[:-1], positions[:-1]):
condition = steps[position].get("if")
if gate in {"Create Gitea release + upload artifact",
"Create private prerelease", "Package Windows artifact",
"Build Windows candidate", "Package Windows candidate",
"Sign Windows candidate (Azure Artifact Signing)"}:
assert condition is not None and "release == 'true'" in condition, path
elif filename == "verify.yml" and gate in {
"Build", "Unit tests", "Microbenchmarks",
"Clippy (our crate, warnings are errors)",
"Headless UI self-test"}:
assert condition == "steps.surface.outputs.surface == 'full'", path
elif filename == "verify.yml" and gate == "Check CI change surface":
assert condition == "steps.surface.outputs.surface != 'documentation'", path
elif filename == "verify.yml" and gate == "Check first-party Rust formatting":
assert condition == ("steps.surface.outputs.surface == 'headless' || "
"steps.surface.outputs.surface == 'full'"), path
elif filename == "verify.yml" and gate == "Check workflow-only change":
assert condition == "steps.surface.outputs.surface == 'workflow'", path
else:
assert condition is None, path
def main() -> None:
check_workflow_contract()
with tempfile.TemporaryDirectory(prefix="alkane-toolkit-workflow-policy-") as directory:
global ROOT
saved_root = ROOT
ROOT = Path(directory)
(ROOT / ".gitea/workflows").mkdir(parents=True)
for filename in ("release.yml", "next.yml", "verify.yml"):
shutil.copyfile(saved_root / ".gitea/workflows" / filename,
ROOT / ".gitea/workflows" / filename)
release = ROOT / ".gitea/workflows/release.yml"
original = release.read_text()
release.write_text(original.replace("- name: Coverage", "- name: Skipped coverage", 1))
try:
check_workflow_contract()
except ValueError:
pass
else:
raise AssertionError("removing the coverage gate passed workflow policy")
ROOT = saved_root
assert pr_surface.documentation_only(["README.md", "docs/setup.md"])
assert pr_surface.workflow_only([".gitea/workflows/release.yml"])
for paths in ([], ["ci/pr-surface.py"], ["ci/coverage.sh"],
["ci/check-runner-image.py"],
[".gitea/workflows/release.yml", "ci/check-runner-image.py"],
[".gitea/workflows/release.yml", "crates/alkane-gui/src/main.rs"],
[".gitea/workflows/../release.yml"]):
assert not pr_surface.workflow_only(paths), paths
for paths in ([], ["docs/generated.json"], ["src/main.rs"],
["README.md", "ci/pr-surface.py"]):
assert not pr_surface.documentation_only(paths), paths
assert pr_surface.headless_packages(["crates/alkane-cli/src/main.rs"]) == ["alkane-cli"]
assert pr_surface.headless_packages(["crates/alkane-artifacts/src/lib.rs"]) == [
"alkane-artifacts", "alkane-cli", "alkane-flash",
]
# alkane-gui depends on alkane-flash and alkane-artifacts (right-click
# install/uninstall and the release picker), so a change in either reaches
# the GUI graph and needs the full build: not a headless-only change.
assert pr_surface.headless_packages(["crates/alkane-artifacts/src/lib.rs"]) == []
assert pr_surface.headless_packages(["crates/alkane-flash/src/lib.rs"]) == []
assert pr_surface.headless_packages([
"crates/alkane-access/src/lib.rs", "crates/alkane-flash/tests/update.rs",
]) == ["alkane-access", "alkane-flash"]
]) == []
assert pr_surface.headless_packages([
"crates/alkane-access/src/lib.rs", "crates/alkane-cli/src/main.rs",
]) == ["alkane-access", "alkane-cli"]
for paths in ([], ["crates/alkane-core/src/lib.rs"],
["crates/alkane-discovery/src/lib.rs"],
["crates/alkane-gui/src/main.rs"],
@@ -105,7 +216,7 @@ def main() -> None:
pr_surface.ROOT = saved_root
os.environ.clear()
os.environ.update(saved_env)
print("Toolkit PR change surface: documentation, headless, and fallback PASS")
print("Toolkit PR change surface: documentation, workflow, headless, and fallback PASS")
if __name__ == "__main__":
+85
View File
@@ -0,0 +1,85 @@
#!/usr/bin/env bash
# SPDX-License-Identifier: MIT
# Every Windows CI step in one place, so verify (PRs), the main release and the
# next-branch candidates build and test the .exe the same way:
#
# windows-ci.sh toolchain mingw-w64 + Wine + the rustup target
# windows-ci.sh clippy clippy for x86_64-pc-windows-gnu, -D warnings
# windows-ci.sh build release alkane-toolkit.exe
# windows-ci.sh test all unit tests, run under Wine
# windows-ci.sh selftest headless UI self-test under Wine + Xvfb
# windows-ci.sh sign Authenticode-sign alkane-toolkit.exe through
# Azure Artifact Signing (ci/sign-windows.sh;
# a no-op until AZURE_SIGNING_PROFILE is set)
# windows-ci.sh package VERSION dist/alkane-toolkit-vVERSION-windows-x86_64.zip
# windows-ci.sh test-bundle dist/alkane-toolkit-windows-tests.zip (for
# the native Windows job)
#
# The wxMSW prefix comes from the CI image or ci/ensure-wx-prefix.sh windows.
set -euo pipefail
cd "$(git rev-parse --show-toplevel)"
export WX_WINDOWS_PREFIX="${WX_WINDOWS_PREFIX:-/root/.cache/wx-3.3.3-mingw}"
export ALKANE_WINEPREFIX="${ALKANE_WINEPREFIX:-/root/.cache/alkane-wine}"
# shellcheck source=../scripts/windows-cross-env.sh
. scripts/windows-cross-env.sh
target="$ALKANE_WIN_TARGET"
out_dir="${CARGO_TARGET_DIR:-target}"
exe="$out_dir/$target/release/alkane-toolkit.exe"
# The GUI crate's tests link wx and some create windows; Wine wants a display.
headless() { xvfb-run -a -s '-screen 0 1280x850x24' "$@"; }
case "${1:-}" in
toolchain)
bash ci/ensure-build-deps.sh windows
rustup target list --installed | grep -qx "$target" || rustup target add "$target"
# jsign ships in the CI image; fetch the same pinned jar on older images.
jsign_version=7.6
jsign_sha256=6cf58aa080e7ff82656f320cff8d4a3bff30408df8766806dcba3740dd839fa5
if [ ! -s /opt/jsign/jsign.jar ]; then
mkdir -p /opt/jsign
curl -sSfL -o /opt/jsign/jsign.jar \
"https://repo1.maven.org/maven2/net/jsign/jsign/$jsign_version/jsign-$jsign_version.jar"
echo "$jsign_sha256 /opt/jsign/jsign.jar" | sha256sum -c -
fi
;;
clippy)
rustup component add clippy >/dev/null 2>&1 || true
cargo clippy -p alkane-gui --no-deps --release --bins --target "$target" --offline -- -D warnings
cargo clippy --workspace --exclude alkane-gui --exclude wx-rs --all-targets \
--target "$target" --offline -- -D warnings
;;
build)
cargo build --release -p alkane-gui --target "$target" --offline
# One self-contained .exe: any toolchain DLL import would fail on a clean
# Windows machine, so refuse to ship one.
if x86_64-w64-mingw32-objdump -p "$exe" | grep -iE 'DLL Name: (libstdc|libgcc|libwinpthread)'; then
echo "alkane-toolkit.exe imports a mingw runtime DLL" >&2
exit 1
fi
;;
test)
headless cargo test --workspace --exclude wx-rs --target "$target" --offline 2>&1 \
| tee tests-windows.txt
;;
selftest)
bash scripts/ui-selftest-windows.sh "$exe"
;;
sign)
bash ci/sign-windows.sh "$exe"
;;
package)
python3 ci/package-windows.py release "${2:?usage: windows-ci.sh package VERSION}" "$exe" dist
;;
test-bundle)
mkdir -p dist
cargo test --workspace --exclude wx-rs --target "$target" --offline --no-run \
--message-format=json > "$out_dir/windows-tests.json"
python3 ci/package-windows.py tests "$out_dir/windows-tests.json" \
dist/alkane-toolkit-windows-tests.zip
;;
*)
sed -n '3,19p' "$0" >&2
exit 2
;;
esac
+16 -1
View File
@@ -1,8 +1,23 @@
#!/usr/bin/env bash
# SPDX-License-Identifier: MIT
# Key the native wxWidgets prefix to its tracked source and build toolchain.
# Key a wxWidgets prefix to its tracked source and build toolchain.
# wx-cache-key.sh [linux|windows]
set -euo pipefail
platform="${1:-linux}"
if [ "$platform" = windows ]; then
material="$({
git rev-parse HEAD:thirdparty/wxwidgets/wxWidgets-3.3.3
git rev-parse HEAD:scripts/build-wx-windows.sh
x86_64-w64-mingw32-g++-posix -dumpmachine
x86_64-w64-mingw32-g++-posix -dumpfullversion
} )"
digest="$(printf '%s\n' "$material" | sha256sum | cut -c1-24)"
key="wx-3.3.3-mingw-$digest"
if [ -n "${GITHUB_OUTPUT:-}" ]; then printf 'key=%s\n' "$key" >> "$GITHUB_OUTPUT"; else printf '%s\n' "$key"; fi
exit 0
fi
material="$({
git rev-parse HEAD:thirdparty/wxwidgets/wxWidgets-3.3.3
git rev-parse HEAD:scripts/build-wx-linux.sh
+1 -1
View File
@@ -81,7 +81,7 @@ impl SshTarget {
}
fn command(&self, probe: Probe) -> Command {
let mut command = Command::new("ssh");
let mut command = alkane_core::platform::quiet_command("ssh");
command
.arg("-F")
.arg("none")
+2
View File
@@ -6,5 +6,7 @@ license.workspace = true
[dependencies]
alkane-core = { path = "../alkane-core" }
serde.workspace = true
serde_json.workspace = true
sha2.workspace = true
thiserror.workspace = true
File diff suppressed because it is too large Load Diff
+404
View File
@@ -0,0 +1,404 @@
// SPDX-License-Identifier: MIT
//! Fetch the latest alkane-os `.afw` release from a Gitea repository.
//!
//! GitHub is retired for this project; releases live on the self-hosted Gitea.
//! This resolves `releases/latest`, picks the `.afw` asset for a board, and
//! downloads it so the normal verify -> plan -> preflight -> install flow runs on
//! it exactly as it would on a local file. TLS is required, so this shells out to
//! `curl` (as the GUI already does) rather than the plaintext TCP path used for
//! liveness checks.
//!
//! A private repo needs a token; it is read from the environment at run time
//! (`ALKANE_RELEASE_TOKEN`, else `GITEA_TOKEN`) and passed to curl through a
//! 0600 config file, never on the command line.
//!
//! As a convenience for the GUI, a read-only token can be baked into the binary
//! at build time by compiling with `ALKANE_EMBEDDED_TOKEN=<token>` set (see
//! `EMBEDDED_TOKEN`). The source tree carries no secret - the value lives only in
//! a binary built with that variable set - and the environment variables above
//! always take precedence, so a user can override it. When no such token is baked
//! in and none is in the environment, the token is simply absent (fine for public
//! repos; a private repo then returns 401/404).
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
use serde_json::Value;
use thiserror::Error;
/// A read-only Gitea token baked in at build time when the crate is compiled
/// with `ALKANE_EMBEDDED_TOKEN` set. `None` in an ordinary build (no secret in
/// the source tree). The environment variables win over this, so it is only a
/// fallback for a distributed binary (the GUI) that ships without asking the user
/// to configure a token. Scope it read-only on the server side; anyone with the
/// binary can extract it.
const EMBEDDED_TOKEN: Option<&str> = option_env!("ALKANE_EMBEDDED_TOKEN");
#[derive(Debug, Error)]
pub enum FetchError {
#[error("curl failed: {0}")]
Curl(String),
#[error("release metadata did not parse: {0}")]
Parse(String),
#[error("no .afw asset for board {0} in the latest release")]
NoAsset(String),
#[error("io: {0}")]
Io(String),
}
/// Where releases come from. Defaults to the alkane-os repo on the self-hosted
/// Gitea; the base URL and token are read from the environment.
pub struct ReleaseSource {
pub base_url: String,
pub owner: String,
pub repo: String,
pub token: Option<String>,
}
impl ReleaseSource {
/// The alkane-os release source, honoring `ALKANE_RELEASE_BASE` and a token
/// from `ALKANE_RELEASE_TOKEN` or `GITEA_TOKEN`.
pub fn alkane_os() -> Self {
let base_url = std::env::var("ALKANE_RELEASE_BASE")
.ok()
.filter(|s| !s.is_empty())
.unwrap_or_else(|| "https://gitea.bluefla.re".to_string());
let token = std::env::var("ALKANE_RELEASE_TOKEN")
.ok()
.or_else(|| std::env::var("GITEA_TOKEN").ok())
.filter(|t| !t.is_empty())
.or_else(|| EMBEDDED_TOKEN.map(str::to_string).filter(|t| !t.is_empty()));
Self {
base_url,
owner: "blueflare".to_string(),
repo: "alkane-os".to_string(),
token,
}
}
/// The releases list (newest first). Unlike `releases/latest`, this includes
/// pre-releases, so an early/bench channel is still found by `--latest`.
fn api_list(&self) -> String {
format!(
"{}/api/v1/repos/{}/{}/releases?limit=50",
self.base_url.trim_end_matches('/'),
self.owner,
self.repo
)
}
}
/// Find the first `.afw` asset for `board` across a newest-first list of
/// releases. Returns (name, url).
fn pick_asset(releases: &Value, board: &str) -> Option<(String, String)> {
let needle = format!("-{board}-");
for release in releases.as_array()? {
let Some(assets) = release.get("assets").and_then(Value::as_array) else {
continue;
};
for asset in assets {
let name = asset.get("name").and_then(Value::as_str).unwrap_or("");
if name.ends_with(".afw") && name.contains(&needle) {
if let Some(url) = asset.get("browser_download_url").and_then(Value::as_str) {
return Some((name.to_string(), url.to_string()));
}
}
}
}
None
}
/// A temp curl `--config` file carrying the auth header, removed on drop so the
/// token never lands in a process argument or a lingering file.
struct TokenConfig {
path: Option<PathBuf>,
}
impl TokenConfig {
fn new(token: &Option<String>) -> Result<Self, FetchError> {
let Some(token) = token else {
return Ok(Self { path: None });
};
let path = std::env::temp_dir().join(format!("alkane-fetch-{}.cfg", std::process::id()));
write_private(
&path,
&format!("header = \"Authorization: token {token}\"\n"),
)?;
Ok(Self { path: Some(path) })
}
fn apply(&self, cmd: &mut Command) {
if let Some(path) = &self.path {
cmd.arg("--config").arg(path);
}
}
}
impl Drop for TokenConfig {
fn drop(&mut self) {
if let Some(path) = &self.path {
let _ = fs::remove_file(path);
}
}
}
#[cfg(unix)]
fn write_private(path: &Path, contents: &str) -> Result<(), FetchError> {
use std::io::Write;
use std::os::unix::fs::OpenOptionsExt;
let mut file = fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.mode(0o600)
.open(path)
.map_err(|e| FetchError::Io(e.to_string()))?;
file.write_all(contents.as_bytes())
.map_err(|e| FetchError::Io(e.to_string()))
}
#[cfg(not(unix))]
fn write_private(path: &Path, contents: &str) -> Result<(), FetchError> {
fs::write(path, contents).map_err(|e| FetchError::Io(e.to_string()))
}
fn curl_bytes(src: &ReleaseSource, url: &str) -> Result<Vec<u8>, FetchError> {
let config = TokenConfig::new(&src.token)?;
let mut cmd = Command::new("curl");
cmd.arg("-fsSL").arg("--max-time").arg("120");
config.apply(&mut cmd);
cmd.arg(url);
let out = cmd.output().map_err(|e| FetchError::Curl(e.to_string()))?;
if !out.status.success() {
return Err(FetchError::Curl(format!(
"{} ({})",
String::from_utf8_lossy(&out.stderr).trim(),
out.status
)));
}
Ok(out.stdout)
}
fn curl_download(src: &ReleaseSource, url: &str, dest: &Path) -> Result<(), FetchError> {
let config = TokenConfig::new(&src.token)?;
let mut cmd = Command::new("curl");
cmd.arg("-fsSL")
.arg("--max-time")
.arg("600")
.arg("-o")
.arg(dest);
config.apply(&mut cmd);
cmd.arg(url);
let out = cmd.output().map_err(|e| FetchError::Curl(e.to_string()))?;
if !out.status.success() {
return Err(FetchError::Curl(format!(
"{} ({})",
String::from_utf8_lossy(&out.stderr).trim(),
out.status
)));
}
Ok(())
}
/// Resolve the latest release's `.afw` asset for `board`: returns (name, url).
/// Scans the newest-first releases list (so a pre-release counts as latest).
pub fn latest_afw_asset(src: &ReleaseSource, board: &str) -> Result<(String, String), FetchError> {
let body = curl_bytes(src, &src.api_list())?;
let releases: Value =
serde_json::from_slice(&body).map_err(|e| FetchError::Parse(e.to_string()))?;
pick_asset(&releases, board).ok_or_else(|| FetchError::NoAsset(board.to_string()))
}
/// Download the latest `.afw` for `board` into `dest_dir`; returns its path.
pub fn fetch_latest_afw(
src: &ReleaseSource,
board: &str,
dest_dir: &Path,
) -> Result<PathBuf, FetchError> {
let (name, url) = latest_afw_asset(src, board)?;
fs::create_dir_all(dest_dir).map_err(|e| FetchError::Io(e.to_string()))?;
let dest = dest_dir.join(&name);
curl_download(src, &url, &dest)?;
Ok(dest)
}
/// One `.afw` asset in a release.
#[derive(Debug, Clone)]
pub struct AfwAsset {
pub name: String,
pub url: String,
}
/// A release as listed for the GUI's release picker: its tag/name, whether it is
/// a pre-release or draft, when it was published, and the `.afw` assets it holds.
#[derive(Debug, Clone)]
pub struct ReleaseInfo {
pub tag: String,
pub name: String,
pub prerelease: bool,
pub draft: bool,
pub published_at: String,
pub afw_assets: Vec<AfwAsset>,
}
impl ReleaseInfo {
/// The `.afw` asset for `board` in this release, if any (matched by the
/// `-<board>-` segment of the filename, as `pick_asset` does).
pub fn asset_for_board(&self, board: &str) -> Option<&AfwAsset> {
let needle = format!("-{board}-");
self.afw_assets.iter().find(|a| a.name.contains(&needle))
}
}
/// Parse a Gitea releases array (newest first) into `ReleaseInfo`s, keeping only
/// the `.afw` assets of each. Drafts are included so the caller can decide.
fn parse_releases(releases: &Value) -> Vec<ReleaseInfo> {
let mut out = Vec::new();
let Some(arr) = releases.as_array() else {
return out;
};
for release in arr {
let tag = release
.get("tag_name")
.and_then(Value::as_str)
.unwrap_or("")
.to_string();
let name = release
.get("name")
.and_then(Value::as_str)
.unwrap_or("")
.to_string();
let prerelease = release
.get("prerelease")
.and_then(Value::as_bool)
.unwrap_or(false);
let draft = release
.get("draft")
.and_then(Value::as_bool)
.unwrap_or(false);
let published_at = release
.get("published_at")
.or_else(|| release.get("created_at"))
.and_then(Value::as_str)
.unwrap_or("")
.to_string();
let mut afw_assets = Vec::new();
if let Some(assets) = release.get("assets").and_then(Value::as_array) {
for asset in assets {
let aname = asset.get("name").and_then(Value::as_str).unwrap_or("");
if aname.ends_with(".afw") {
if let Some(url) = asset.get("browser_download_url").and_then(Value::as_str) {
afw_assets.push(AfwAsset {
name: aname.to_string(),
url: url.to_string(),
});
}
}
}
}
out.push(ReleaseInfo {
tag,
name,
prerelease,
draft,
published_at,
afw_assets,
});
}
out
}
/// List the releases (newest first) of the source repo, each with its `.afw`
/// assets. Used by the GUI to scan alkane-os releases and pick one to install.
pub fn list_releases(src: &ReleaseSource) -> Result<Vec<ReleaseInfo>, FetchError> {
let body = curl_bytes(src, &src.api_list())?;
let releases: Value =
serde_json::from_slice(&body).map_err(|e| FetchError::Parse(e.to_string()))?;
Ok(parse_releases(&releases))
}
/// Download a specific release asset (by its `browser_download_url`) into
/// `dest_dir`, saving it under `name`; returns the written path.
pub fn fetch_afw_url(
src: &ReleaseSource,
name: &str,
url: &str,
dest_dir: &Path,
) -> Result<PathBuf, FetchError> {
fs::create_dir_all(dest_dir).map_err(|e| FetchError::Io(e.to_string()))?;
let dest = dest_dir.join(name);
curl_download(src, url, &dest)?;
Ok(dest)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn source_defaults_to_alkane_os_on_gitea() {
std::env::remove_var("ALKANE_RELEASE_BASE");
let src = ReleaseSource::alkane_os();
assert_eq!(src.owner, "blueflare");
assert_eq!(src.repo, "alkane-os");
assert!(src
.api_list()
.contains("/api/v1/repos/blueflare/alkane-os/releases"));
assert!(src.api_list().starts_with("https://gitea.bluefla.re"));
}
#[test]
fn pick_asset_takes_the_newest_matching_afw() {
// Newest-first list of releases; the board's .afw in the first release wins.
let releases = serde_json::json!([
{"tag_name": "v0.1.0-bench1", "assets": [
{"name": "SHA256SUMS", "browser_download_url": "u0"},
{"name": "alkane-os-0.1.0-am335x-arm.afw", "browser_download_url": "u1"},
{"name": "alkane-os-0.1.0-zynq-7010-armv7.afw", "browser_download_url": "u2"},
]},
{"tag_name": "v0.0.9", "assets": [
{"name": "alkane-os-0.0.9-zynq-7010-armv7.afw", "browser_download_url": "old"},
]},
]);
assert_eq!(
pick_asset(&releases, "zynq-7010"),
Some(("alkane-os-0.1.0-zynq-7010-armv7.afw".into(), "u2".into()))
);
assert_eq!(pick_asset(&releases, "cv1835"), None);
}
#[test]
fn list_parses_releases_and_filters_afw_assets() {
let releases = serde_json::json!([
{"tag_name": "v0.2.0-bench1", "name": "bench", "prerelease": true, "draft": false,
"published_at": "2026-11-11T10:00:00Z", "assets": [
{"name": "SHA256SUMS", "browser_download_url": "s"},
{"name": "alkane-os-0.2.0-zynq-7010-armv7.afw", "browser_download_url": "z"},
]},
{"tag_name": "v0.1.0", "name": "", "prerelease": false, "draft": false,
"published_at": "2026-10-01T00:00:00Z", "assets": [
{"name": "alkane-os-0.1.0-am335x-arm.afw", "browser_download_url": "a"},
]},
]);
let parsed = parse_releases(&releases);
assert_eq!(parsed.len(), 2);
// Newest first; only .afw assets kept; SHA256SUMS dropped.
assert_eq!(parsed[0].tag, "v0.2.0-bench1");
assert!(parsed[0].prerelease);
assert_eq!(parsed[0].afw_assets.len(), 1);
// The board filter matches the -<board>- segment.
assert_eq!(
parsed[0]
.asset_for_board("zynq-7010")
.map(|a| a.url.as_str()),
Some("z")
);
assert!(parsed[0].asset_for_board("am335x").is_none());
assert_eq!(
parsed[1].asset_for_board("am335x").map(|a| a.name.as_str()),
Some("alkane-os-0.1.0-am335x-arm.afw")
);
assert!(parsed[1].asset_for_board("zynq-7010").is_none());
}
}
+3
View File
@@ -1,6 +1,9 @@
// SPDX-License-Identifier: MIT
//! Verify local firmware artifacts before an install path consumes them.
pub mod afw;
pub mod fetch;
use sha2::{Digest, Sha256};
use std::collections::HashSet;
use std::fs::File;
+2
View File
@@ -7,3 +7,5 @@ license.workspace = true
[dependencies]
alkane-core = { path = "../alkane-core" }
alkane-artifacts = { path = "../alkane-artifacts" }
alkane-flash = { path = "../alkane-flash" }
serde_json.workspace = true
File diff suppressed because it is too large Load Diff
+2
View File
@@ -1 +1,3 @@
// alkane-core
pub mod platform;
+148
View File
@@ -0,0 +1,148 @@
//! The few places the toolkit's behaviour depends on the operating system,
//! kept together so the rest of the code stays platform-neutral.
//!
//! - where per-user settings live ([`config_dir`]),
//! - how a secret file is written so only its owner can read it
//! ([`write_private`]),
//! - the null device for tools that insist on an output path ([`NULL_DEVICE`]),
//! - how helper programs (`ssh`, `curl`) are started from the GUI without a
//! console window popping up on Windows ([`quiet_command`]).
use std::path::{Path, PathBuf};
use std::process::Command;
/// Directory name of the toolkit's settings under the per-user config root.
pub const APP_DIR: &str = "alkane-toolkit";
/// Environment variable whose value is the per-user config root on this
/// platform: `HOME` (settings in `$HOME/.config/alkane-toolkit`) on Unix,
/// `APPDATA` (settings in `%APPDATA%\alkane-toolkit`) on Windows. Tests point it
/// at a scratch directory.
#[cfg(not(windows))]
pub const CONFIG_ROOT_VAR: &str = "HOME";
#[cfg(windows)]
pub const CONFIG_ROOT_VAR: &str = "APPDATA";
/// The per-user settings directory (not created here).
///
/// Unix keeps the long-standing `$HOME/.config/alkane-toolkit`. Windows uses
/// the roaming application-data folder, `%APPDATA%\alkane-toolkit`, which is
/// where Windows applications keep per-user settings and which the user
/// profile's ACL already restricts to its owner. A missing variable falls back
/// to the working directory, as before.
pub fn config_dir() -> PathBuf {
let root = std::env::var_os(CONFIG_ROOT_VAR).unwrap_or_else(|| ".".into());
if cfg!(windows) {
PathBuf::from(root).join(APP_DIR)
} else {
PathBuf::from(root).join(".config").join(APP_DIR)
}
}
/// `config_dir()/file`.
pub fn config_path(file: &str) -> PathBuf {
config_dir().join(file)
}
/// The null device, for tools that want an output path (`curl -o`,
/// `ssh -o UserKnownHostsFile=`).
#[cfg(not(windows))]
pub const NULL_DEVICE: &str = "/dev/null";
#[cfg(windows)]
pub const NULL_DEVICE: &str = "NUL";
/// Write `data` to `path` so only the owner can read it.
///
/// On Unix the file is created 0600 (so a secret is never momentarily
/// world-readable between write and chmod), and a pre-existing file is
/// re-tightened while it is still empty, before the plaintext is written. On
/// Windows the settings directory inherits the user profile's owner-only ACL,
/// so a plain write already has the equivalent protection.
pub fn write_private(path: &Path, data: &[u8]) -> std::io::Result<()> {
#[cfg(unix)]
{
use std::io::Write;
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
let mut f = std::fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.mode(0o600)
.open(path)?;
f.set_permissions(std::fs::Permissions::from_mode(0o600))?;
f.write_all(data)
}
#[cfg(not(unix))]
{
std::fs::write(path, data)
}
}
/// A [`Command`] for a helper program run in the background of the GUI.
///
/// On Windows a console program (`ssh.exe`, `curl.exe`) started from a GUI
/// process gets a new console window by default, so every probe would flash a
/// black window; `CREATE_NO_WINDOW` suppresses that while keeping its piped
/// stdin/stdout/stderr. Elsewhere this is `Command::new`.
pub fn quiet_command(program: &str) -> Command {
#[allow(unused_mut)]
let mut command = Command::new(program);
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
command.creation_flags(CREATE_NO_WINDOW);
}
command
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn config_dir_is_under_the_platform_root() {
let dir = config_dir();
assert!(dir.ends_with(APP_DIR), "{dir:?}");
if cfg!(windows) {
assert!(!dir.to_string_lossy().contains(".config"), "{dir:?}");
} else {
assert!(dir.parent().unwrap().ends_with(".config"), "{dir:?}");
}
assert_eq!(config_path("x.txt"), dir.join("x.txt"));
}
#[test]
fn write_private_round_trips_and_restricts() {
let dir = std::env::temp_dir().join(format!("alkane-private-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("secret.txt");
write_private(&path, b"one").unwrap();
write_private(&path, b"two").unwrap();
assert_eq!(std::fs::read(&path).unwrap(), b"two");
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let mode = std::fs::metadata(&path).unwrap().permissions().mode() & 0o777;
assert_eq!(mode, 0o600);
}
std::fs::remove_dir_all(&dir).unwrap();
}
#[test]
fn quiet_command_runs_with_piped_output() {
// `cmd /C echo` and `sh -c echo` are the platform's own shells.
let mut command = if cfg!(windows) {
let mut c = quiet_command("cmd");
c.args(["/C", "echo alkane"]);
c
} else {
let mut c = quiet_command("sh");
c.args(["-c", "echo alkane"]);
c
};
let out = command.output().unwrap();
assert!(out.status.success());
assert!(String::from_utf8_lossy(&out.stdout).contains("alkane"));
}
}
+1
View File
@@ -7,6 +7,7 @@ license.workspace = true
[dependencies]
alkane-core = { path = "../alkane-core" }
alkane-artifacts = { path = "../alkane-artifacts" }
serde_json.workspace = true
sha2.workspace = true
thiserror.workspace = true
tempfile = "3"
+880
View File
@@ -0,0 +1,880 @@
// SPDX-License-Identifier: MIT
//! Amlogic A113D / AXG (Antminer S21 Pro-class) board module: tier-2 network
//! UPDATE of a board already running alkane. Our OS is staged as FILES in the
//! nvdata UBI volume: alkane/{vmlinux.bin, devicetree.dtb, uramdisk.image.gz}.
//! (The legacy vendor path name "anthillos" from AnthillOS is no longer used;
//! our own bootcmd loads from alkane/.)
//!
//! The running alkane image exposes ONLY the nvdata region as an MTD (the board
//! DT declares a single `nvdata` fixed-partition; the FIP bootloader and the
//! stock boot/recovery/misc/config regions are deliberately undeclared, so they
//! are never registered as MTD devices and cannot be written from Linux). This
//! module attaches UBI to that one nvdata MTD, mounts the UBIFS volume, and
//! overwrites the three files under alkane/. It performs no raw mtd0-5 write and
//! never changes the bootloader: the brick-sensitive regions are physically
//! unreachable.
//!
//! The first from-stock install (past the signed bootloader) is handled
//! elsewhere and is NOT this module. This is the repeatable alkane-to-alkane
//! update.
use crate::md5::md5_hex;
use crate::preflight::{classify, parse_digest};
use crate::transport::{Remote, RemoteError};
use alkane_artifacts::afw::{AfwImage, BootloaderPolicy, VerifiedAfw};
use std::fs;
use std::io::Write;
use std::path::PathBuf;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use thiserror::Error;
pub const BOARD: &str = "a113d";
pub const ARCH: &str = "arm64";
/// The UBI volume subdirectory our boot chain reads our OS files from. This is
/// alkane's own name; the board's `ourbootcmd` loads from here.
pub const ALKANE_DIR: &str = "alkane";
/// nvdata UBI usable size; the three files together must fit (0xB900000).
pub const NVDATA_USABLE: u64 = 0xB900000;
/// The only MTD partition our DT exposes. mtd0-5 (FIP + stock boot) are not
/// declared in the DT at all, so they are not MTD devices on a running image.
pub const NVDATA_LABEL: &str = "nvdata";
/// Authoritative file targets: (image, on-board basename, ceiling, format).
/// Written rootfs -> dtb -> kernel so a mid-write interruption never leaves a
/// new rootfs beside an old kernel (the kernel file lands last).
const TARGETS: [(&str, &str, u64, &str); 3] = [
("rootfs", "uramdisk.image.gz", 0x6000000, "uimage"),
("dtb", "devicetree.dtb", 0x100000, "fdt"),
("kernel", "vmlinux.bin", 0x4000000, "arm64-image"),
];
#[derive(Debug, Error)]
pub enum A113dPlanError {
#[error("bundle is for {0}, not a113d")]
WrongBoard(String),
#[error("bundle arch is {0}, a113d needs arm64")]
WrongArch(String),
#[error("a113d requires bootloader_policy preserve (the FIP is never written)")]
BootloaderPolicy,
#[error("a113d bundle carries a bootloader/spl/fip/tpl member: {0}")]
BootloaderMember(String),
#[error("manifest is not an OS payload")]
PayloadType,
#[error("manifest marker is empty")]
Marker,
#[error("a113d must install exactly kernel, dtb and rootfs")]
InstallCount,
#[error("a113d is missing the {0} image")]
MissingImage(String),
#[error("a113d {image} format is {actual}, expected {expected}")]
ImageFormat {
image: String,
actual: String,
expected: &'static str,
},
#[error("a113d {image} is {size} bytes, over the 0x{ceiling:x}-byte ceiling")]
ImageTooLarge {
image: String,
size: u64,
ceiling: u64,
},
#[error("a113d images total {total} bytes, over the nvdata UBI (0x{usable:x})")]
OverNvdata { total: u64, usable: u64 },
#[error("a113d {image} is not an arm64 Image")]
NotArm64 { image: String },
#[error("a113d {image} is not an FDT")]
NotFdt { image: String },
#[error("a113d {image} is not a legacy uImage")]
NotUimage { image: String },
#[error("a113d refuses: preserved partition {0} (mtd0-5) carries an image")]
PreservedCarriesImage(String),
#[error("a113d refuses an unsafe destination for {image}: {dest}")]
UnsafeDest { image: String, dest: String },
}
#[derive(Clone, Debug)]
pub struct A113dTarget {
pub image_name: String,
/// On-board basename inside the alkane directory (never a device path).
pub dest: String,
pub size: u64,
pub data: Vec<u8>,
pub expected_md5: String,
}
#[derive(Clone, Debug)]
pub struct A113dPlan {
pub targets: Vec<A113dTarget>,
pub marker: String,
pub kernel_version: String,
pub sdk_revision: String,
pub os_revision: String,
pub afw_sha256: String,
pub min_free_bytes: u64,
}
fn is_bootloaderish(image: &AfwImage) -> bool {
let lowered = format!("{} {} {}", image.name, image.file, image.role).to_lowercase();
image.role == "bootloader"
|| lowered.contains("spl")
|| lowered.contains("u-boot")
|| lowered.contains("uboot")
|| lowered.contains("fip")
|| lowered.contains("tpl")
}
/// A destination is safe only as a bare basename (no separators, no traversal,
/// not a device path). This keeps every write inside the alkane/ directory.
fn is_safe_dest(dest: &str) -> bool {
!dest.is_empty()
&& !dest.contains('/')
&& !dest.contains("..")
&& !dest.starts_with("/dev/")
&& dest == dest.trim()
}
impl A113dPlan {
pub fn from_afw(afw: &VerifiedAfw) -> Result<Self, A113dPlanError> {
let manifest = &afw.manifest;
if manifest.board != BOARD {
return Err(A113dPlanError::WrongBoard(manifest.board.clone()));
}
if manifest.arch != ARCH {
return Err(A113dPlanError::WrongArch(manifest.arch.clone()));
}
if manifest.payload_type != "os" {
return Err(A113dPlanError::PayloadType);
}
if manifest.bootloader_policy != BootloaderPolicy::Preserve {
return Err(A113dPlanError::BootloaderPolicy);
}
if manifest.marker.is_empty() {
return Err(A113dPlanError::Marker);
}
// FIP / bootloader members are never allowed - we reuse the board's.
for image in &manifest.images {
if is_bootloaderish(image) {
return Err(A113dPlanError::BootloaderMember(image.file.clone()));
}
}
// Defense in depth: only nvdata (mtd6) may carry an image; mtd0-5 preserved.
for partition in &manifest.partitions {
if partition.name != "nvdata" && partition.image.is_some() {
return Err(A113dPlanError::PreservedCarriesImage(
partition.name.clone(),
));
}
}
let installs: Vec<&AfwImage> = manifest.images.iter().filter(|i| i.install).collect();
if installs.len() != TARGETS.len() {
return Err(A113dPlanError::InstallCount);
}
let mut targets = Vec::with_capacity(TARGETS.len());
let mut total = 0u64;
for (image_name, dest, ceiling, expected_format) in TARGETS {
let image = manifest
.images
.iter()
.find(|i| i.name == image_name && i.install)
.ok_or_else(|| A113dPlanError::MissingImage(image_name.to_owned()))?;
if image.format != expected_format {
return Err(A113dPlanError::ImageFormat {
image: image_name.to_owned(),
actual: image.format.clone(),
expected: expected_format,
});
}
if image.size > ceiling {
return Err(A113dPlanError::ImageTooLarge {
image: image_name.to_owned(),
size: image.size,
ceiling,
});
}
if !is_safe_dest(dest) {
return Err(A113dPlanError::UnsafeDest {
image: image_name.to_owned(),
dest: dest.to_owned(),
});
}
let data = afw
.image(image_name)
.map(|(_, data)| data)
.ok_or_else(|| A113dPlanError::MissingImage(image_name.to_owned()))?;
// Each arm validates a different magic; keeping them as explicit
// arms (not match guards) reads more clearly than collapsing.
#[allow(clippy::collapsible_match)]
match expected_format {
"arm64-image" => {
if !(data.len() >= 0x3C && data[0x38..0x3C] == *b"ARMd") {
return Err(A113dPlanError::NotArm64 {
image: image_name.to_owned(),
});
}
}
"fdt" => {
if !(data.len() >= 4 && data[0..4] == [0xd0, 0x0d, 0xfe, 0xed]) {
return Err(A113dPlanError::NotFdt {
image: image_name.to_owned(),
});
}
}
"uimage" => {
if !(data.len() >= 4 && data[0..4] == [0x27, 0x05, 0x19, 0x56]) {
return Err(A113dPlanError::NotUimage {
image: image_name.to_owned(),
});
}
}
_ => {}
}
total += image.size;
targets.push(A113dTarget {
image_name: image_name.to_owned(),
dest: dest.to_owned(),
size: image.size,
expected_md5: md5_hex(data),
data: data.to_vec(),
});
}
if total > NVDATA_USABLE {
return Err(A113dPlanError::OverNvdata {
total,
usable: NVDATA_USABLE,
});
}
Ok(Self {
targets,
marker: manifest.marker.clone(),
kernel_version: manifest.kernel_version.clone(),
sdk_revision: manifest.sdk_revision.clone(),
os_revision: manifest.os_revision.clone(),
afw_sha256: afw.archive_sha256.clone(),
min_free_bytes: manifest
.preflight
.get("min_free_bytes")
.and_then(|v| v.as_u64())
.unwrap_or(16 * 1024 * 1024),
})
}
pub fn render(&self) -> String {
let mut out = format!("board {BOARD} arch {ARCH}\n");
out.push_str(
"tier 2 update: attach UBI to the nvdata MTD, mount it, and overwrite the OS files \
under alkane/; the FIP + stock boot/recovery/misc/config are not MTD devices at all, \
so no raw NAND write is possible\n",
);
out.push_str("image format kernel=arm64-image, dtb=fdt, rootfs=uimage\n");
for target in &self.targets {
out.push_str(&format!(
"write {} -> {ALKANE_DIR}/{} size {} B md5 {}\n",
target.image_name, target.dest, target.size, target.expected_md5
));
}
out.push_str(&format!(
"marker {} kernel {} sdk {} os {}",
self.marker,
self.kernel_version,
short(&self.sdk_revision),
short(&self.os_revision),
));
out
}
}
fn short(rev: &str) -> &str {
rev.get(..12).unwrap_or(rev)
}
#[derive(Debug, Error)]
pub enum A113dError {
#[error("preflight failed:\n{0}")]
Preflight(String),
#[error("--confirm FLASH is required to write")]
Confirm,
#[error("the running image exposes no '{0}' MTD; it needs a NAND-enabled a113d kernel")]
NoNvdataMtd(String),
#[error("could not attach UBI to the nvdata MTD / find its volume")]
UbiAttach,
#[error("could not mount the nvdata UBIFS volume")]
Mount,
#[error("refusing an unsafe destination: {0}")]
UnsafeDest(String),
#[error("{0} staged md5 differs from the verified bundle")]
StageMismatch(String),
#[error("{0} read-back md5 mismatch; do not reboot")]
Readback(String),
#[error(transparent)]
Remote(#[from] RemoteError),
#[error(transparent)]
Io(#[from] std::io::Error),
}
#[derive(Clone, Debug)]
pub struct A113dCheck {
pub name: String,
pub ok: bool,
pub detail: String,
}
#[derive(Clone, Debug)]
pub struct A113dPreflight {
pub host: String,
pub checks: Vec<A113dCheck>,
/// The nvdata MTD index (e.g. 0 for /dev/mtd0), when the running image
/// exposes it. Used for `ubiattach -m <index>`.
pub nvdata_mtd: Option<u32>,
}
impl A113dPreflight {
pub fn ok(&self) -> bool {
self.checks.iter().all(|c| c.ok)
}
pub fn render(&self) -> String {
let mut out = format!("preflight {}\n", self.host);
for c in &self.checks {
out.push_str(&format!(
"check {} {}: {}\n",
c.name,
if c.ok { "ok" } else { "FAIL" },
c.detail
));
}
out.push_str(&format!(
"result {}",
if self.ok() {
"PASS"
} else {
"FAIL (do not write)"
}
));
out
}
}
/// Parse /proc/mtd for a partition labelled "nvdata" and return its mtd index.
/// e.g. `mtd0: 0b900000 00020000 "nvdata"` -> Some(0).
fn parse_nvdata_mtd(proc_mtd: &str) -> Option<u32> {
for line in proc_mtd.lines() {
let line = line.trim();
if !line.starts_with("mtd") {
continue;
}
let (dev, rest) = line.split_once(':')?;
if rest.contains(&format!("\"{NVDATA_LABEL}\"")) {
return dev.trim_start_matches("mtd").parse::<u32>().ok();
}
}
None
}
pub fn preflight(
plan: &A113dPlan,
remote: &mut dyn Remote,
host: &str,
) -> Result<A113dPreflight, A113dError> {
let mut checks = Vec::new();
let fingerprint = remote.user_command(
"uname -r; echo __MODEL__; cat /proc/device-tree/model 2>/dev/null; echo; \
echo __RELEASE__; cat /etc/os-release 2>/dev/null; cat /etc/alkane-release 2>/dev/null \
|| true",
Duration::from_secs(20),
)?;
let text = String::from_utf8_lossy(&fingerprint).into_owned();
let mut it = text.split("__MODEL__");
let kernel = it.next().unwrap_or("").trim().to_owned();
let rest = it.next().unwrap_or("");
let mut it2 = rest.split("__RELEASE__");
let _model = it2.next().unwrap_or("");
let release = it2.next().unwrap_or("");
let source = classify(&kernel, release, &text);
checks.push(A113dCheck {
name: "source-os".to_owned(),
ok: source == "alkane",
detail: format!("{source} (update path requires alkane)"),
});
let uid = String::from_utf8_lossy(&remote.root_command("id -u", Duration::from_secs(20))?)
.trim()
.to_owned();
checks.push(A113dCheck {
name: "root".to_owned(),
ok: uid == "0",
detail: format!("uid {uid}"),
});
let tools = remote.user_command(
"for c in ubiattach ubidetach mount umount cp md5sum sync; do \
command -v $c >/dev/null 2>&1 && echo $c || echo missing:$c; done",
Duration::from_secs(15),
)?;
let missing: Vec<String> = String::from_utf8_lossy(&tools)
.lines()
.filter_map(|l| l.strip_prefix("missing:").map(str::to_owned))
.collect();
checks.push(A113dCheck {
name: "commands".to_owned(),
ok: missing.is_empty(),
detail: if missing.is_empty() {
"ubi/file tools present".to_owned()
} else {
format!("missing {}", missing.join(", "))
},
});
// The nvdata MTD must be exposed (NAND-enabled a113d kernel). If absent, the
// running image cannot self-update - it needs the DT with the nvdata
// fixed-partition. mtd0-5 are intentionally never exposed, so nvdata is the
// ONLY mtd this board should ever present.
let proc_mtd = String::from_utf8_lossy(
&remote.user_command("cat /proc/mtd 2>/dev/null", Duration::from_secs(20))?,
)
.into_owned();
let nvdata_mtd = parse_nvdata_mtd(&proc_mtd);
checks.push(A113dCheck {
name: "nvdata-mtd".to_owned(),
ok: nvdata_mtd.is_some(),
detail: match nvdata_mtd {
Some(n) => format!("nvdata is /dev/mtd{n} (the only exposed MTD)"),
None => format!("no 'nvdata' MTD exposed: {}", proc_mtd.replace('\n', " ")),
},
});
// Every destination is a bare basename - the structural brick guard.
let dests_safe = plan.targets.iter().all(|t| is_safe_dest(&t.dest));
checks.push(A113dCheck {
name: "file-only".to_owned(),
ok: dests_safe,
detail: format!("all writes are files under {ALKANE_DIR}/ on the nvdata UBI"),
});
Ok(A113dPreflight {
host: host.to_owned(),
checks,
nvdata_mtd,
})
}
#[derive(Clone, Debug)]
pub struct A113dInstallOptions {
pub dry_run: bool,
pub confirm: Option<String>,
pub no_reboot: bool,
pub backup_dir: PathBuf,
}
#[derive(Clone, Debug)]
pub struct A113dBackup {
pub image_name: String,
pub dest: String,
pub path: Option<PathBuf>,
pub md5: Option<String>,
pub size: u64,
}
#[derive(Clone, Debug)]
pub struct A113dReceipt {
pub volume: String,
pub backups: Vec<A113dBackup>,
pub rebooted: bool,
}
pub enum A113dOutcome {
DryRun(Box<A113dPreflight>),
Installed(A113dReceipt),
}
const MNT: &str = "/tmp/.alkane-nvdata";
/// Attach UBI to the nvdata MTD and mount its single user volume read-write.
/// Returns (ubi device number, volume name). The volume name is DISCOVERED, never
/// assumed (vendor histories leave different names: umc_os_rootfs, nvdada_log,
/// overlay, ...).
fn attach_and_mount(remote: &mut dyn Remote, nvdata_mtd: u32) -> Result<String, A113dError> {
// Attach (idempotent: if ubi0 already exists, reuse it).
let _ = remote.root_command(
&format!(
"if [ ! -d /sys/class/ubi/ubi0 ]; then ubiattach -m {nvdata_mtd} -d 0 >/dev/null 2>&1; fi"
),
Duration::from_secs(60),
)?;
// Discover the first user volume name under ubi0.
let name = String::from_utf8_lossy(&remote.root_command(
"for n in /sys/class/ubi/ubi0_*/name; do [ -f \"$n\" ] && cat \"$n\" && break; done",
Duration::from_secs(20),
)?)
.trim()
.to_owned();
if name.is_empty() {
return Err(A113dError::UbiAttach);
}
// Mount it read-write.
remote.root_command(
&format!("mkdir -p {MNT} && mount -t ubifs ubi0:{name} {MNT}"),
Duration::from_secs(60),
)?;
// Confirm the mount actually took.
let mounted = remote.user_command(
&format!("mount | grep -c ' {MNT} '"),
Duration::from_secs(20),
)?;
if String::from_utf8_lossy(&mounted).trim() == "0" {
return Err(A113dError::Mount);
}
Ok(name)
}
fn unmount(remote: &mut dyn Remote) {
let _ = remote.root_command(
&format!(
"sync; umount {MNT} 2>/dev/null; ubidetach -d 0 2>/dev/null; rmdir {MNT} 2>/dev/null"
),
Duration::from_secs(60),
);
}
pub fn install(
plan: &A113dPlan,
remote: &mut dyn Remote,
options: &A113dInstallOptions,
host: &str,
) -> Result<A113dOutcome, A113dError> {
let report = preflight(plan, remote, host)?;
if !report.ok() {
return Err(A113dError::Preflight(report.render()));
}
if options.dry_run {
return Ok(A113dOutcome::DryRun(Box::new(report)));
}
if options.confirm.as_deref() != Some("FLASH") {
return Err(A113dError::Confirm);
}
let nvdata_mtd = report
.nvdata_mtd
.ok_or_else(|| A113dError::NoNvdataMtd(NVDATA_LABEL.to_owned()))?;
fs::create_dir_all(&options.backup_dir)?;
let epoch = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_secs();
let volume = attach_and_mount(remote, nvdata_mtd)?;
let alkane_dir = format!("{MNT}/{ALKANE_DIR}");
let _ = remote.root_command(&format!("mkdir -p {alkane_dir}"), Duration::from_secs(20))?;
let mut backups = Vec::new();
let result = (|| -> Result<(), A113dError> {
for target in &plan.targets {
// Structural guard at the point of writing: a bare basename only.
if !is_safe_dest(&target.dest) {
return Err(A113dError::UnsafeDest(target.dest.clone()));
}
let name = &target.image_name;
let dest_path = format!("{alkane_dir}/{}", target.dest);
// Back up the existing file, if present.
let have = remote.user_command(
&format!("test -f {dest_path} && echo __YES__"),
Duration::from_secs(15),
)?;
if String::from_utf8_lossy(&have).contains("__YES__") {
let local = options
.backup_dir
.join(format!("{}-{epoch}.bak", target.dest));
remote.pull(&dest_path, &local, Duration::from_secs(300))?;
let data = fs::read(&local)?;
backups.push(A113dBackup {
image_name: name.clone(),
dest: target.dest.clone(),
md5: Some(md5_hex(&data)),
size: data.len() as u64,
path: Some(local),
});
} else {
backups.push(A113dBackup {
image_name: name.clone(),
dest: target.dest.clone(),
md5: None,
size: 0,
path: None,
});
}
// Stage the verified payload and prove its remote md5 before copying.
let mut staged = tempfile::NamedTempFile::new()?;
staged.write_all(&target.data)?;
staged.flush()?;
let remote_stage = format!("/tmp/.alkane-a113d-{name}.img");
remote.push(staged.path(), &remote_stage, Duration::from_secs(300))?;
let staged_md5 = parse_digest(
&remote.root_command(&format!("md5sum {remote_stage}"), Duration::from_secs(60))?,
32,
)
.unwrap_or_default();
if staged_md5 != target.expected_md5 {
let _ =
remote.root_command(&format!("rm -f {remote_stage}"), Duration::from_secs(15));
return Err(A113dError::StageMismatch(name.clone()));
}
// Copy into the UBIFS volume (file write only), then sync.
remote.root_command(
&format!("cp -f {remote_stage} {dest_path} && sync"),
Duration::from_secs(300),
)?;
// Read back the copied file and compare md5.
let readback = parse_digest(
&remote.root_command(&format!("md5sum {dest_path}"), Duration::from_secs(60))?,
32,
)
.unwrap_or_default();
let _ = remote.root_command(&format!("rm -f {remote_stage}"), Duration::from_secs(15));
if readback != target.expected_md5 {
return Err(A113dError::Readback(name.clone()));
}
}
Ok(())
})();
// Always unmount/detach, success or failure, before returning or rebooting.
unmount(remote);
result?;
let rebooted = if options.no_reboot {
false
} else {
remote.reboot()?;
true
};
Ok(A113dOutcome::Installed(A113dReceipt {
volume,
backups,
rebooted,
}))
}
pub fn owns_board(board: &str) -> bool {
board == BOARD
}
/// True when no plan target would ever name a preserved raw partition. Used by
/// tests to assert the structural guard holds for the fixed TARGETS table.
pub fn no_raw_device_targets(plan: &A113dPlan) -> bool {
plan.targets.iter().all(|t| is_safe_dest(&t.dest))
}
#[cfg(test)]
mod tests {
use super::*;
use alkane_artifacts::afw::{AfwManifest, AfwMember};
use serde_json::json;
use sha2::{Digest, Sha256};
const REV: &str = "0123456789abcdef0123456789abcdef01234567";
fn arm64_image(payload: &[u8]) -> Vec<u8> {
let mut b = vec![0u8; 64];
b[0x38..0x3C].copy_from_slice(b"ARMd");
b.extend_from_slice(payload);
b
}
fn dtb() -> Vec<u8> {
let mut b = vec![0u8; 2048];
b[0..4].copy_from_slice(&[0xd0, 0x0d, 0xfe, 0xed]);
b
}
fn uramdisk() -> Vec<u8> {
let mut b = vec![0u8; 64];
b[0..4].copy_from_slice(&[0x27, 0x05, 0x19, 0x56]);
b
}
fn afw_with(
kernel: Vec<u8>,
dtb: Vec<u8>,
rootfs: Vec<u8>,
partitions: serde_json::Value,
) -> VerifiedAfw {
let image = |name: &str, file: &str, role: &str, fmt: &str, data: &[u8]| {
let sha: String = Sha256::digest(data)
.iter()
.map(|b| format!("{b:02x}"))
.collect();
json!({"name": name, "file": file, "role": role, "format": fmt,
"size": data.len(), "sha256": sha, "partition": "nvdata", "install": true})
};
let value = json!({
"schema": 2, "format": "afw", "board": "a113d", "arch": "arm64",
"version": "0.1.0", "build_date": "2026-11-06T00:00:00Z",
"sdk_revision": REV, "os_revision": REV, "payload_type": "os",
"bootloader_policy": "preserve",
"signature": {"type": "unsigned", "member": null, "public_key_hex": null},
"partitions": partitions,
"images": [
image("kernel", "payload/vmlinux.bin", "kernel", "arm64-image", &kernel),
image("dtb", "payload/devicetree.dtb", "dtb", "fdt", &dtb),
image("rootfs", "payload/uramdisk.image.gz", "rootfs", "uimage", &rootfs),
],
"boot_switch": {}, "preflight": {"min_free_bytes": 16777216},
"recovery": {}, "marker": "Alkane", "kernel_version": "6.18.48"
});
let manifest: AfwManifest = serde_json::from_value(value).unwrap();
VerifiedAfw {
manifest,
members: vec![
AfwMember {
name: "payload/vmlinux.bin".to_owned(),
data: kernel,
},
AfwMember {
name: "payload/devicetree.dtb".to_owned(),
data: dtb,
},
AfwMember {
name: "payload/uramdisk.image.gz".to_owned(),
data: rootfs,
},
],
manifest_sha256: "0".repeat(64),
archive_sha256: "0".repeat(64),
}
}
fn preserved_partitions() -> serde_json::Value {
json!([
{"name":"bootloader","device":"/dev/mtd0","offset":0,"size":2097152,
"secure":true,"boot_critical":true,"write_order":0,"image":null},
{"name":"nvdata","device":"/dev/mtd6","offset":74448896,"size":193986560,
"secure":false,"boot_critical":true,"write_order":1,"image":"kernel"}
])
}
fn good() -> VerifiedAfw {
afw_with(arm64_image(b"k"), dtb(), uramdisk(), preserved_partitions())
}
#[test]
fn accepts_a_good_plan_as_file_copies() {
let plan = A113dPlan::from_afw(&good()).unwrap();
assert_eq!(plan.targets.len(), 3);
// write order rootfs, dtb, kernel (kernel file lands last)
assert_eq!(plan.targets[0].image_name, "rootfs");
assert_eq!(plan.targets[2].image_name, "kernel");
assert!(no_raw_device_targets(&plan));
for t in &plan.targets {
assert!(
!t.dest.contains('/'),
"{} has a path, not a basename",
t.image_name
);
}
assert!(plan.render().contains("alkane/"));
assert!(plan.render().contains("no raw NAND write is possible"));
}
#[test]
fn refuses_a_non_arm64_kernel() {
let r = A113dPlan::from_afw(&afw_with(
vec![0u8; 64],
dtb(),
uramdisk(),
preserved_partitions(),
));
assert!(matches!(r, Err(A113dPlanError::NotArm64 { .. })));
}
#[test]
fn refuses_an_oversize_kernel() {
let big = arm64_image(&vec![0u8; 0x4000000]);
let r = A113dPlan::from_afw(&afw_with(big, dtb(), uramdisk(), preserved_partitions()));
assert!(matches!(r, Err(A113dPlanError::ImageTooLarge { .. })));
}
#[test]
fn refuses_a_fip_member() {
let mut v = good();
v.manifest.images[0].role = "bootloader".to_owned();
assert!(matches!(
A113dPlan::from_afw(&v),
Err(A113dPlanError::BootloaderMember(_))
));
let mut v = good();
v.manifest.images[1].file = "payload/fip.bin".to_owned();
assert!(matches!(
A113dPlan::from_afw(&v),
Err(A113dPlanError::BootloaderMember(_))
));
}
#[test]
fn refuses_a_preserved_partition_carrying_an_image() {
let partitions = json!([
{"name":"bootloader","device":"/dev/mtd0","offset":0,"size":2097152,
"secure":true,"boot_critical":true,"write_order":0,"image":"kernel"},
{"name":"nvdata","device":"/dev/mtd6","offset":74448896,"size":193986560,
"secure":false,"boot_critical":true,"write_order":1,"image":"kernel"}
]);
let v = afw_with(arm64_image(b"k"), dtb(), uramdisk(), partitions);
assert!(matches!(
A113dPlan::from_afw(&v),
Err(A113dPlanError::PreservedCarriesImage(_))
));
}
#[test]
fn wrong_board_and_arch_are_refused() {
let mut v = good();
v.manifest.board = "zynq-7010".to_owned();
assert!(matches!(
A113dPlan::from_afw(&v),
Err(A113dPlanError::WrongBoard(_))
));
let mut v = good();
v.manifest.arch = "armv7".to_owned();
assert!(matches!(
A113dPlan::from_afw(&v),
Err(A113dPlanError::WrongArch(_))
));
}
#[test]
fn every_target_is_a_basename_never_a_device() {
for (image, dest, _ceiling, _fmt) in TARGETS {
assert!(
is_safe_dest(dest),
"{image} dest {dest} is not a safe basename"
);
}
}
#[test]
fn unsafe_dest_is_rejected_by_guard() {
assert!(!is_safe_dest("/dev/mtd0"));
assert!(!is_safe_dest("../escape"));
assert!(!is_safe_dest("sub/dir/file"));
assert!(is_safe_dest("vmlinux.bin"));
}
#[test]
fn parses_the_nvdata_mtd_index() {
let proc_mtd = "dev: size erasesize name\n\
mtd0: 0b900000 00020000 \"nvdata\"\n";
assert_eq!(parse_nvdata_mtd(proc_mtd), Some(0));
// No nvdata line -> None (the no-NAND running image).
assert_eq!(parse_nvdata_mtd("dev: size erasesize name\n"), None);
// Different index is honored.
assert_eq!(
parse_nvdata_mtd("mtd3: 0b900000 00020000 \"nvdata\"\n"),
Some(3)
);
}
}
File diff suppressed because it is too large Load Diff
+406
View File
@@ -0,0 +1,406 @@
// SPDX-License-Identifier: MIT
//! CV1835 board module: the only write is the 16 MiB p1 FIT.
//!
//! The vendor boot0, BL2, BL31 and U-Boot chain is preserved. The board plan is
//! read from the verified `.afw` manifest, not guessed at runtime.
use crate::md5::md5_hex;
use alkane_artifacts::afw::{
AfwImage, AfwManifest, AfwPartition, BootloaderPolicy, VerifiedAfw, CV1835_P1_SIZE,
};
use thiserror::Error;
pub const BOARD: &str = "cv1835";
pub const ARCH: &str = "arm64";
pub const P1_DEVICE: &str = "/dev/mmcblk0p1";
pub const MARKER: &str = "CVBOOT";
pub const UPDATE_DAEMON_PORT: u16 = 12887;
pub const GOLDEN_LBA_BYTES: u64 = 0x300000 * 512;
#[derive(Debug, Error)]
pub enum CvPlanError {
#[error("bundle is for {0}, not cv1835")]
WrongBoard(String),
#[error("bundle arch is {0}, cv1835 needs arm64")]
WrongArch(String),
#[error("cv1835 requires bootloader_policy preserve")]
BootloaderPolicy,
#[error("cv1835 bundle carries a bootloader member")]
BootloaderMember,
#[error("cv1835 bundle must install exactly p1")]
MissingP1,
#[error("cv1835 p1 is {0} bytes, not the 16 MiB padded FIT")]
P1Size(u64),
#[error("cv1835 p1 partition is not /dev/mmcblk0p1")]
P1Device,
#[error("cv1835 p1 partition must be 16 MiB, non-secure and written once")]
P1Geometry,
#[error("cv1835 p1 is not a bootable FIT: {0}")]
Fit(String),
#[error("manifest marker is empty")]
Marker,
#[error("manifest kernel_version is empty")]
KernelVersion,
#[error("manifest is not an OS payload")]
PayloadType,
#[error("manifest preflight is missing {0}")]
Preflight(String),
}
#[derive(Clone, Debug)]
pub struct Cv1835Plan {
pub image: AfwImage,
pub data: Vec<u8>,
pub partition: AfwPartition,
pub expected_md5: String,
pub expected_sha256: String,
pub marker: String,
pub kernel_version: String,
pub sdk_revision: String,
pub os_revision: String,
pub source_os: Vec<String>,
pub required_commands: Vec<String>,
pub min_free_bytes: u64,
pub golden_lba_bytes: u64,
}
impl Cv1835Plan {
pub fn from_afw(afw: &VerifiedAfw) -> Result<Self, CvPlanError> {
let manifest = &afw.manifest;
if manifest.board != BOARD {
return Err(CvPlanError::WrongBoard(manifest.board.clone()));
}
if manifest.arch != ARCH {
return Err(CvPlanError::WrongArch(manifest.arch.clone()));
}
if manifest.payload_type != "os" {
return Err(CvPlanError::PayloadType);
}
if manifest.bootloader_policy != BootloaderPolicy::Preserve {
return Err(CvPlanError::BootloaderPolicy);
}
if manifest
.images
.iter()
.any(|image| image.role == "bootloader")
{
return Err(CvPlanError::BootloaderMember);
}
if manifest.marker.is_empty() {
return Err(CvPlanError::Marker);
}
if manifest.kernel_version.is_empty() {
return Err(CvPlanError::KernelVersion);
}
let install: Vec<&AfwImage> = manifest
.images
.iter()
.filter(|image| image.install)
.collect();
if install.len() != 1 || install[0].name != "p1" {
return Err(CvPlanError::MissingP1);
}
let image = install[0].clone();
if image.format != "fit" {
return Err(CvPlanError::Fit("format is not fit".to_owned()));
}
if image.size != CV1835_P1_SIZE {
return Err(CvPlanError::P1Size(image.size));
}
let (_, data) = afw.install_image().ok_or(CvPlanError::MissingP1)?;
if !data.starts_with(b"\xd0\x0d\xfe\xed") {
return Err(CvPlanError::Fit("missing FDT/FIT magic".to_owned()));
}
if !contains(data, b"config@cv1835_miner_emmc") {
return Err(CvPlanError::Fit(
"missing config@cv1835_miner_emmc".to_owned(),
));
}
if contains(data, b"signature@") {
return Err(CvPlanError::Fit("carries signature@ nodes".to_owned()));
}
let partition = manifest
.partitions
.iter()
.find(|part| part.name == "p1")
.ok_or(CvPlanError::P1Device)?
.clone();
if partition.device != P1_DEVICE {
return Err(CvPlanError::P1Device);
}
if partition.size != CV1835_P1_SIZE
|| partition.secure
|| !partition.boot_critical
|| partition.write_order != 1
{
return Err(CvPlanError::P1Geometry);
}
if manifest
.partitions
.iter()
.any(|part| part.write_order > 0 && part.name != "p1")
{
return Err(CvPlanError::MissingP1);
}
let source_os = json_strings(&manifest.preflight, "source_os");
let required_commands = json_strings(&manifest.preflight, "required_commands");
let min_free_bytes = manifest
.preflight
.get("min_free_bytes")
.and_then(|value| value.as_u64())
.unwrap_or(32 * 1024 * 1024);
let golden_lba_bytes = manifest
.recovery
.get("golden_lba_bytes")
.and_then(|value| value.as_u64())
.unwrap_or(GOLDEN_LBA_BYTES);
Ok(Self {
expected_md5: md5_hex(data),
expected_sha256: image.sha256.clone(),
image,
data: data.to_vec(),
partition,
marker: manifest.marker.clone(),
kernel_version: manifest.kernel_version.clone(),
sdk_revision: manifest.sdk_revision.clone(),
os_revision: manifest.os_revision.clone(),
source_os,
required_commands,
min_free_bytes,
golden_lba_bytes,
})
}
pub fn render(&self) -> String {
format!(
"board cv1835 arch arm64\n\
partition {} {} {} B secure=false boot_critical=true write_order={}\n\
image {} {} {} B sha256 {}\n\
image md5 {}\n\
bootloader preserve (vendor boot0/BL2/BL31/U-Boot kept)\n\
boot switch partition-overwrite (p1 is the switch)\n\
marker {} kernel {} sdk {} os {}",
self.partition.name,
self.partition.device,
self.partition.size,
self.partition.write_order,
self.image.name,
self.image.file,
self.image.size,
self.image.sha256,
self.expected_md5,
self.marker,
self.kernel_version,
short_revision(&self.sdk_revision),
short_revision(&self.os_revision),
)
}
}
fn short_revision(revision: &str) -> &str {
revision.get(..12).unwrap_or(revision)
}
fn contains(haystack: &[u8], needle: &[u8]) -> bool {
haystack
.windows(needle.len())
.any(|window| window == needle)
}
fn json_strings(value: &serde_json::Value, key: &str) -> Vec<String> {
value
.get(key)
.and_then(|item| item.as_array())
.map(|items| {
items
.iter()
.filter_map(|item| item.as_str().map(str::to_owned))
.collect()
})
.unwrap_or_default()
}
pub fn manifest_from_json(value: serde_json::Value) -> Result<AfwManifest, serde_json::Error> {
serde_json::from_value(value)
}
#[cfg(test)]
mod tests {
use super::*;
use alkane_artifacts::afw::AfwMember;
use serde_json::json;
use sha2::{Digest, Sha256};
const P1: usize = CV1835_P1_SIZE as usize;
const REV: &str = "0000000000000000000000000000000000000000";
fn sha_hex(data: &[u8]) -> String {
Sha256::digest(data)
.iter()
.map(|byte| format!("{byte:02x}"))
.collect()
}
fn p1_image() -> Vec<u8> {
let mut fit = vec![0_u8; P1];
fit[..4].copy_from_slice(b"\xd0\x0d\xfe\xed");
let marker = b"config@cv1835_miner_emmc";
fit[0x100..0x100 + marker.len()].copy_from_slice(marker);
fit
}
fn manifest_value(p1: &[u8]) -> serde_json::Value {
json!({
"schema": 2,
"format": "afw",
"board": "cv1835",
"arch": "arm64",
"version": "0.1.0",
"build_date": "2026-11-04T00:00:00Z",
"sdk_revision": REV,
"os_revision": REV,
"payload_type": "os",
"bootloader_policy": "preserve",
"signature": {"type": "unsigned", "member": null, "public_key_hex": null},
"partitions": [
{"name": "p1", "device": "/dev/mmcblk0p1", "offset": 0,
"size": CV1835_P1_SIZE, "secure": false, "boot_critical": true,
"write_order": 1, "image": "p1"},
{"name": "boot0", "device": "/dev/mmcblk0boot0", "offset": 0,
"size": 4194304, "secure": true, "boot_critical": true,
"write_order": 0, "image": null}
],
"images": [
{"name": "p1", "file": "payload/p1.fit", "role": "boot",
"format": "fit", "size": p1.len(),
"sha256": sha_hex(p1),
"partition": "p1", "install": true}
],
"boot_switch": {"method": "partition-overwrite"},
"preflight": {"required_commands": ["dd", "md5sum", "sync"],
"source_os": ["stock-bitmain", "vnish", "braiins", "ouros", "alkane"],
"min_free_bytes": 33554432},
"recovery": {"network": "afw restore", "golden_lba_bytes": GOLDEN_LBA_BYTES},
"marker": "CVBOOT",
"kernel_version": "6.18.48"
})
}
fn afw(p1: &[u8]) -> VerifiedAfw {
let manifest = manifest_from_json(manifest_value(p1)).unwrap();
VerifiedAfw {
manifest,
members: vec![AfwMember {
name: "payload/p1.fit".to_owned(),
data: p1.to_vec(),
}],
manifest_sha256: "0".repeat(64),
archive_sha256: "0".repeat(64),
}
}
#[test]
fn accepts_the_cv_plan() {
let data = p1_image();
let plan = Cv1835Plan::from_afw(&afw(&data)).unwrap();
assert_eq!(plan.partition.device, "/dev/mmcblk0p1");
assert_eq!(plan.image.size, CV1835_P1_SIZE);
assert_eq!(plan.marker, "CVBOOT");
assert!(plan
.render()
.contains("partition p1 /dev/mmcblk0p1 16777216"));
}
#[test]
fn refuses_a_bundle_for_another_board() {
let data = p1_image();
let mut verified = afw(&data);
verified.manifest.board = "zynq-7010".to_owned();
assert!(matches!(
Cv1835Plan::from_afw(&verified),
Err(CvPlanError::WrongBoard(_))
));
}
#[test]
fn refuses_include_bootloader_policy() {
let data = p1_image();
let mut verified = afw(&data);
verified.manifest.bootloader_policy = BootloaderPolicy::Include;
assert!(matches!(
Cv1835Plan::from_afw(&verified),
Err(CvPlanError::BootloaderPolicy)
));
}
#[test]
fn refuses_a_bootloader_member() {
let data = p1_image();
let mut verified = afw(&data);
verified.manifest.images.push(AfwImage {
name: "u-boot".to_owned(),
file: "payload/u-boot.img".to_owned(),
role: "bootloader".to_owned(),
format: "uimage".to_owned(),
size: 4,
sha256: "0".repeat(64),
partition: None,
install: false,
});
assert!(matches!(
Cv1835Plan::from_afw(&verified),
Err(CvPlanError::BootloaderMember)
));
}
#[test]
fn refuses_a_short_p1() {
let data = vec![0_u8; 1024];
let verified = afw(&data);
assert!(matches!(
Cv1835Plan::from_afw(&verified),
Err(CvPlanError::P1Size(1024))
));
}
#[test]
fn refuses_a_secure_p1() {
let data = p1_image();
let mut verified = afw(&data);
verified.manifest.partitions[0].secure = true;
assert!(matches!(
Cv1835Plan::from_afw(&verified),
Err(CvPlanError::P1Geometry)
));
}
#[test]
fn refuses_a_wrong_device() {
let data = p1_image();
let mut verified = afw(&data);
verified.manifest.partitions[0].device = "/dev/mmcblk0p3".to_owned();
assert!(matches!(
Cv1835Plan::from_afw(&verified),
Err(CvPlanError::P1Device)
));
}
#[test]
fn refuses_a_fit_without_the_board_config() {
let mut data = p1_image();
for byte in data.iter_mut() {
if *byte == b'c' {
*byte = b'x';
}
}
let verified = afw(&data);
assert!(matches!(
Cv1835Plan::from_afw(&verified),
Err(CvPlanError::Fit(_))
));
}
}
+8
View File
@@ -0,0 +1,8 @@
// SPDX-License-Identifier: MIT
//! Board modules. Each module validates the verified manifest for its family
//! and exposes the exact write plan the installer follows.
pub mod a113d;
pub mod am335x;
pub mod cv1835;
pub mod zynq;
+410
View File
@@ -0,0 +1,410 @@
// SPDX-License-Identifier: MIT
//! Zynq-7010 board module: the manifest gate and write plan for putting our
//! OS onto a Zynq control board (Antminer S17/S19 class).
//!
//! This module decides WHAT may be written and WHERE, in absolute NAND terms.
//! It does not write. The write itself (for a board already on alkane, and for
//! the first install from stock) is done by the compiled-in method behind
//! `crate::stock` (`update_in_place` / `install_from_stock`), because on a board
//! running alkane the boot regions are deliberately not exposed to Linux and
//! have to be re-registered first; that mechanism lives with the method.
//!
//! Layout (absolute NAND offsets, 128 KiB erase blocks): BOOT.bin (FSBL + FPGA
//! bitstream + stock U-Boot + env) occupies 0x0..0x1a00000 and is never
//! written. The stock U-Boot reads the dtb at 0x1a00000, the kernel at
//! 0x2000000 and the ramdisk at 0x2800000, and boots the kernel and ramdisk as
//! legacy uImages, so both are written with a 64-byte uImage header.
//!
//! History: an earlier version of this module wrote raw images at
//! device-relative offsets on /dev/mtd0 and /dev/mtd1. That matched an early
//! alkane image that exposed the whole NAND, not the current one (which exposes
//! only the small `stock-cfg` and `alkane-cfg` partitions), and its raw kernel
//! and ramdisk were not bootable by the stock U-Boot. It was removed.
use crate::md5::md5_hex;
use alkane_artifacts::afw::{AfwImage, BootloaderPolicy, VerifiedAfw};
use thiserror::Error;
pub const BOARD: &str = "zynq-7010";
pub const ARCH: &str = "armv7";
/// Absolute NAND 0x0..0x1a00000 is BOOT.bin (FSBL + FPGA bitstream + stock
/// U-Boot) + the U-Boot env, and is NEVER erased or written.
pub const BOOTBIN_PRESERVE: u64 = 0x1A00000;
/// Size of the legacy uImage header the stock U-Boot needs on the kernel and
/// the ramdisk.
const UIMAGE_HEADER: u64 = 64;
/// Write targets in write order (rootfs, dtb, kernel, so an interrupted write
/// never leaves a new rootfs under an old kernel): (image, absolute NAND
/// offset, slot size, expected manifest format, uImage-wrapped).
const TARGETS: [(&str, u64, u64, &str, bool); 3] = [
("rootfs", 0x2800000, 0x2000000, "cpio-gzip", true),
("dtb", 0x1A00000, 0x20000, "fdt", false),
("kernel", 0x2000000, 0x800000, "zimage", true),
];
#[derive(Debug, Error)]
pub enum ZynqPlanError {
#[error("bundle is for {0}, not zynq-7010")]
WrongBoard(String),
#[error("bundle arch is {0}, zynq-7010 needs armv7")]
WrongArch(String),
#[error("zynq-7010 requires bootloader_policy preserve")]
BootloaderPolicy,
#[error("zynq-7010 bundle carries a bootloader/spl/BOOT.bin member: {0}")]
BootloaderMember(String),
#[error("manifest is not an OS payload")]
PayloadType,
#[error("manifest marker is empty")]
Marker,
#[error("zynq-7010 must install exactly kernel, dtb and rootfs")]
InstallCount,
#[error("zynq-7010 is missing the {0} image")]
MissingImage(String),
#[error("zynq-7010 {image} format is {actual}, expected {expected}")]
ImageFormat {
image: String,
actual: String,
expected: &'static str,
},
#[error("zynq-7010 {image} is {size} bytes, over the {ceiling}-byte ceiling for its 0x{slot:x} slot")]
ImageTooLarge {
image: String,
size: u64,
ceiling: u64,
slot: u64,
},
#[error("zynq-7010 {image} is not an ARM zImage")]
NotZImage { image: String },
#[error("zynq-7010 refuses to place {image} at 0x{offset:x}: below BOOT.bin (0x{bootbin:x})")]
WouldClobberBootbin {
image: String,
offset: u64,
bootbin: u64,
},
}
#[derive(Clone, Debug)]
pub struct ZynqTarget {
pub image_name: String,
/// Absolute NAND offset of the slot.
pub absolute: u64,
pub slot: u64,
/// Size of the image as shipped in the `.afw` (before any uImage header).
pub size: u64,
pub uimage_wrapped: bool,
pub data: Vec<u8>,
pub expected_md5: String,
}
#[derive(Clone, Debug)]
pub struct ZynqPlan {
pub targets: Vec<ZynqTarget>,
pub marker: String,
pub kernel_version: String,
pub sdk_revision: String,
pub os_revision: String,
pub afw_sha256: String,
}
fn is_bootloaderish(image: &AfwImage) -> bool {
let lowered = format!("{} {} {}", image.name, image.file, image.role).to_lowercase();
image.role == "bootloader"
|| lowered.contains("spl")
|| lowered.contains("u-boot")
|| lowered.contains("uboot")
|| lowered.contains("boot.bin")
}
impl ZynqPlan {
pub fn from_afw(afw: &VerifiedAfw) -> Result<Self, ZynqPlanError> {
let manifest = &afw.manifest;
if manifest.board != BOARD {
return Err(ZynqPlanError::WrongBoard(manifest.board.clone()));
}
if manifest.arch != ARCH {
return Err(ZynqPlanError::WrongArch(manifest.arch.clone()));
}
if manifest.payload_type != "os" {
return Err(ZynqPlanError::PayloadType);
}
if manifest.bootloader_policy != BootloaderPolicy::Preserve {
return Err(ZynqPlanError::BootloaderPolicy);
}
if manifest.marker.is_empty() {
return Err(ZynqPlanError::Marker);
}
// BOOT.bin / bootloader members are never allowed - we reuse the board's.
for image in &manifest.images {
if is_bootloaderish(image) {
return Err(ZynqPlanError::BootloaderMember(image.file.clone()));
}
}
let installs: Vec<&AfwImage> = manifest.images.iter().filter(|i| i.install).collect();
if installs.len() != TARGETS.len() {
return Err(ZynqPlanError::InstallCount);
}
let mut targets = Vec::with_capacity(TARGETS.len());
for (image_name, absolute, slot, expected_format, wrapped) in TARGETS {
let image = manifest
.images
.iter()
.find(|i| i.name == image_name && i.install)
.ok_or_else(|| ZynqPlanError::MissingImage(image_name.to_owned()))?;
if image.format != expected_format {
return Err(ZynqPlanError::ImageFormat {
image: image_name.to_owned(),
actual: image.format.clone(),
expected: expected_format,
});
}
let ceiling = if wrapped { slot - UIMAGE_HEADER } else { slot };
if image.size > ceiling {
return Err(ZynqPlanError::ImageTooLarge {
image: image_name.to_owned(),
size: image.size,
ceiling,
slot,
});
}
// The hard brick guard: nothing is ever placed inside BOOT.bin.
if absolute < BOOTBIN_PRESERVE {
return Err(ZynqPlanError::WouldClobberBootbin {
image: image_name.to_owned(),
offset: absolute,
bootbin: BOOTBIN_PRESERVE,
});
}
let data = afw
.image(image_name)
.map(|(_, data)| data)
.ok_or_else(|| ZynqPlanError::MissingImage(image_name.to_owned()))?;
if expected_format == "zimage"
&& !(data.len() >= 0x28 && data[0x24..0x28] == [0x18, 0x28, 0x6f, 0x01])
{
return Err(ZynqPlanError::NotZImage {
image: image_name.to_owned(),
});
}
targets.push(ZynqTarget {
image_name: image_name.to_owned(),
absolute,
slot,
size: image.size,
uimage_wrapped: wrapped,
expected_md5: md5_hex(data),
data: data.to_vec(),
});
}
Ok(Self {
targets,
marker: manifest.marker.clone(),
kernel_version: manifest.kernel_version.clone(),
sdk_revision: manifest.sdk_revision.clone(),
os_revision: manifest.os_revision.clone(),
afw_sha256: afw.archive_sha256.clone(),
})
}
pub fn render(&self) -> String {
let mut out = format!("board {BOARD} arch {ARCH}\n");
out.push_str(&format!(
"boot slots (absolute NAND); BOOT.bin 0x0..0x{BOOTBIN_PRESERVE:x} preserved, never written\n"
));
out.push_str(
"kernel and rootfs are written as legacy uImages (what the stock U-Boot boots); dtb raw\n",
);
for target in &self.targets {
out.push_str(&format!(
"write {:<6} abs 0x{:x} slot 0x{:x} size {} B{} md5 {}\n",
target.image_name,
target.absolute,
target.slot,
target.size,
if target.uimage_wrapped {
" +64 B header"
} else {
""
},
target.expected_md5
));
}
out.push_str(&format!(
"marker {} kernel {} sdk {} os {}",
self.marker,
self.kernel_version,
short(&self.sdk_revision),
short(&self.os_revision),
));
out
}
}
fn short(rev: &str) -> &str {
rev.get(..12).unwrap_or(rev)
}
pub fn owns_board(board: &str) -> bool {
board == BOARD
}
#[cfg(test)]
mod tests {
use super::*;
use alkane_artifacts::afw::{AfwManifest, AfwMember};
use serde_json::json;
use sha2::{Digest, Sha256};
const REV: &str = "0123456789abcdef0123456789abcdef01234567";
fn zimage(payload: &[u8]) -> Vec<u8> {
let mut b = vec![0u8; 64];
b[0x24..0x28].copy_from_slice(&[0x18, 0x28, 0x6f, 0x01]);
b.extend_from_slice(payload);
b
}
fn afw(kernel: Vec<u8>, dtb: Vec<u8>, rootfs: Vec<u8>) -> VerifiedAfw {
let image = |name: &str, file: &str, role: &str, fmt: &str, data: &[u8]| {
let sha: String = Sha256::digest(data)
.iter()
.map(|b| format!("{b:02x}"))
.collect();
json!({"name": name, "file": file, "role": role, "format": fmt,
"size": data.len(), "sha256": sha, "partition": "x", "install": true})
};
let value = json!({
"schema": 2, "format": "afw", "board": "zynq-7010", "arch": "armv7",
"version": "0.1.0", "build_date": "2026-11-06T00:00:00Z",
"sdk_revision": REV, "os_revision": REV, "payload_type": "os",
"bootloader_policy": "preserve",
"signature": {"type": "unsigned", "member": null, "public_key_hex": null},
"partitions": [],
"images": [
image("kernel", "payload/zImage", "kernel", "zimage", &kernel),
image("dtb", "payload/zynq-alkane.dtb", "dtb", "fdt", &dtb),
image("rootfs", "payload/rootfs.cpio.gz", "rootfs", "cpio-gzip", &rootfs),
],
"boot_switch": {}, "preflight": {"min_free_bytes": 16777216},
"recovery": {}, "marker": "Alkane", "kernel_version": "6.18.48"
});
let manifest: AfwManifest = serde_json::from_value(value).unwrap();
VerifiedAfw {
manifest,
members: vec![
AfwMember {
name: "payload/zImage".to_owned(),
data: kernel,
},
AfwMember {
name: "payload/zynq-alkane.dtb".to_owned(),
data: dtb,
},
AfwMember {
name: "payload/rootfs.cpio.gz".to_owned(),
data: rootfs,
},
],
manifest_sha256: "0".repeat(64),
archive_sha256: "0".repeat(64),
}
}
fn dtb() -> Vec<u8> {
let mut b = vec![0u8; 1024];
b[0..4].copy_from_slice(&[0xd0, 0x0d, 0xfe, 0xed]);
b
}
#[test]
fn accepts_a_good_plan_and_places_above_bootbin() {
let plan = ZynqPlan::from_afw(&afw(zimage(b"k"), dtb(), b"\x1f\x8brf".to_vec())).unwrap();
assert_eq!(plan.targets.len(), 3);
// write order rootfs, dtb, kernel
assert_eq!(plan.targets[0].image_name, "rootfs");
assert_eq!(plan.targets[2].image_name, "kernel");
for t in &plan.targets {
assert!(
t.absolute >= BOOTBIN_PRESERVE,
"{} below BOOT.bin",
t.image_name
);
}
let render = plan.render();
assert!(render.contains("BOOT.bin"));
assert!(render.contains("uImage"));
}
#[test]
fn slots_match_the_stock_uboot_layout() {
let plan = ZynqPlan::from_afw(&afw(zimage(b"k"), dtb(), b"\x1f\x8brf".to_vec())).unwrap();
let at = |name: &str| plan.targets.iter().find(|t| t.image_name == name).unwrap();
assert_eq!((at("dtb").absolute, at("dtb").slot), (0x1A00000, 0x20000));
assert_eq!(
(at("kernel").absolute, at("kernel").slot),
(0x2000000, 0x800000)
);
assert_eq!(
(at("rootfs").absolute, at("rootfs").slot),
(0x2800000, 0x2000000)
);
assert!(at("kernel").uimage_wrapped && at("rootfs").uimage_wrapped);
assert!(!at("dtb").uimage_wrapped);
}
#[test]
fn refuses_a_non_zimage_kernel() {
let result = ZynqPlan::from_afw(&afw(vec![0u8; 64], dtb(), b"\x1f\x8brf".to_vec()));
assert!(matches!(result, Err(ZynqPlanError::NotZImage { .. })));
}
#[test]
fn refuses_a_kernel_that_would_not_fit_with_its_uimage_header() {
// Exactly the slot size is too big once the 64-byte header is added.
let big = zimage(&vec![0u8; 0x800000 - 64]);
assert_eq!(big.len(), 0x800000);
let result = ZynqPlan::from_afw(&afw(big, dtb(), b"\x1f\x8brf".to_vec()));
assert!(matches!(result, Err(ZynqPlanError::ImageTooLarge { .. })));
let fits = zimage(&vec![0u8; 0x800000 - 128]);
assert!(ZynqPlan::from_afw(&afw(fits, dtb(), b"\x1f\x8brf".to_vec())).is_ok());
}
#[test]
fn refuses_a_bootloader_member() {
let mut verified = afw(zimage(b"k"), dtb(), b"\x1f\x8brf".to_vec());
verified.manifest.images[0].role = "bootloader".to_owned();
assert!(matches!(
ZynqPlan::from_afw(&verified),
Err(ZynqPlanError::BootloaderMember(_))
));
}
#[test]
fn wrong_board_and_arch_are_refused() {
let mut v = afw(zimage(b"k"), dtb(), b"\x1f\x8brf".to_vec());
v.manifest.board = "am335x".to_owned();
assert!(matches!(
ZynqPlan::from_afw(&v),
Err(ZynqPlanError::WrongBoard(_))
));
let mut v = afw(zimage(b"k"), dtb(), b"\x1f\x8brf".to_vec());
v.manifest.arch = "arm".to_owned();
assert!(matches!(
ZynqPlan::from_afw(&v),
Err(ZynqPlanError::WrongArch(_))
));
}
#[test]
fn every_target_is_above_bootbin() {
for (image, absolute, _slot, _fmt, _wrapped) in TARGETS {
assert!(
absolute >= BOOTBIN_PRESERVE,
"{image} target below BOOT.bin"
);
}
}
}
+920
View File
@@ -0,0 +1,920 @@
// SPDX-License-Identifier: MIT
//! CV1835 install, restore and live verification over the network.
//!
//! Order of operations for an install: verify the bundle, preflight the board,
//! hold the current p1 over SSH, stage the new p1, write it once, read the whole
//! partition back, and only then reboot. Any doubt before the first write stops
//! the sequence. A read-back mismatch stops before reboot and prints the exact
//! restore command.
use crate::boards::cv1835::{Cv1835Plan, CvPlanError};
use crate::md5::md5_hex;
use crate::preflight::{preflight, PreflightError, PreflightOptions, PreflightReport};
use crate::transport::{Remote, RemoteError, SshOptions, SshTransport};
use alkane_artifacts::afw::{AfwError, VerifiedAfw};
use sha2::{Digest, Sha256};
use std::fs;
use std::io::{Read, Write};
use std::net::{TcpStream, ToSocketAddrs};
use std::path::{Path, PathBuf};
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
use thiserror::Error;
const REMOTE_BACKUP: &str = "/tmp/.alkane-p1-backup.img";
const REMOTE_STAGE: &str = "/tmp/.alkane-p1-stage.img";
#[derive(Debug, Error)]
pub enum InstallError {
#[error("preflight failed; do not write\n{0}")]
Preflight(String),
#[error("install and restore need --confirm FLASH")]
Confirm,
#[error("verified .afw: {0}")]
Afw(#[from] AfwError),
#[error("cv1835 plan: {0}")]
Plan(#[from] CvPlanError),
#[error("preflight: {0}")]
PreflightError(#[from] PreflightError),
#[error("remote: {0}")]
Remote(#[from] RemoteError),
#[error("I/O: {0}")]
Io(#[from] std::io::Error),
#[error("backup {0} is not the 16 MiB p1 size")]
BackupSize(PathBuf),
#[error("backup md5 does not match the live p1; refusing to continue")]
BackupMismatch,
#[error("staged image md5 does not match the verified bundle; nothing written")]
StageMismatch,
#[error("p1 read-back md5 mismatch; do not reboot. Restore with: {0}")]
Readback(String),
#[error("restore read-back md5 mismatch; the board may still hold the new image")]
RestoreReadback,
}
#[derive(Clone, Debug)]
pub struct InstallOptions {
pub dry_run: bool,
pub confirm: Option<String>,
pub no_reboot: bool,
pub backup_dir: PathBuf,
pub held_backup: Option<PathBuf>,
pub allow_unknown_source: bool,
pub check_golden: bool,
}
impl Default for InstallOptions {
fn default() -> Self {
Self {
dry_run: false,
confirm: None,
no_reboot: false,
backup_dir: default_backup_dir(),
held_backup: None,
allow_unknown_source: false,
check_golden: false,
}
}
}
#[derive(Clone, Debug)]
pub struct InstallReceipt {
pub backup_path: PathBuf,
pub backup_md5: String,
pub backup_sha256: String,
pub image_md5: String,
pub rebooted: bool,
}
#[derive(Clone, Debug)]
pub enum InstallOutcome {
DryRun(Box<PreflightReport>),
Installed(InstallReceipt),
}
pub fn install(
_afw: &VerifiedAfw,
plan: &Cv1835Plan,
remote: &mut dyn Remote,
options: &InstallOptions,
host: &str,
) -> Result<InstallOutcome, InstallError> {
let report = preflight(
plan,
remote,
&PreflightOptions {
host,
held_backup: options.held_backup.as_deref(),
check_golden: options.check_golden,
allow_unknown_source: options.allow_unknown_source,
},
)?;
if !report.ok() {
return Err(InstallError::Preflight(report.render()));
}
if options.dry_run {
return Ok(InstallOutcome::DryRun(Box::new(report)));
}
if options.confirm.as_deref() != Some("FLASH") {
return Err(InstallError::Confirm);
}
fs::create_dir_all(&options.backup_dir)?;
let epoch = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_secs();
let backup_path = options.backup_dir.join(format!("p1-{epoch}.img"));
let device = &plan.partition.device;
// Hold the current p1 as root, then pull it over the unprivileged SSH
// session. The daemon channel is blind, so this two-step path is required.
let remote_backup = REMOTE_BACKUP;
remote.root_command(
&format!("dd if={device} of={remote_backup} bs=1M 2>&1; chmod 644 {remote_backup}"),
Duration::from_secs(180),
)?;
remote.pull(remote_backup, &backup_path, Duration::from_secs(240))?;
let _ = remote.root_command(&format!("rm -f {remote_backup}"), Duration::from_secs(15));
let backup_data = fs::read(&backup_path)?;
if backup_data.len() as u64 != plan.partition.size {
return Err(InstallError::BackupSize(backup_path));
}
let backup_md5 = md5_hex(&backup_data);
if report.live_md5 != "unreadable" && backup_md5 != report.live_md5 {
return Err(InstallError::BackupMismatch);
}
let backup_sha256: String = Sha256::digest(&backup_data)
.iter()
.map(|byte| format!("{byte:02x}"))
.collect();
write_sidecars(
&backup_path,
&backup_md5,
&backup_sha256,
&plan.partition,
&plan.expected_sha256,
epoch,
)?;
stage_and_write(plan, remote, &backup_path)?;
let rebooted = if options.no_reboot {
false
} else {
remote.reboot()?;
true
};
Ok(InstallOutcome::Installed(InstallReceipt {
backup_path,
backup_md5,
backup_sha256,
image_md5: plan.expected_md5.clone(),
rebooted,
}))
}
fn stage_and_write(
plan: &Cv1835Plan,
remote: &mut dyn Remote,
backup_path: &Path,
) -> Result<(), InstallError> {
let mut staged =
tempfile::NamedTempFile::new_in(backup_path.parent().unwrap_or_else(|| Path::new(".")))?;
staged.write_all(&plan.data)?;
staged.flush()?;
remote.push(staged.path(), REMOTE_STAGE, Duration::from_secs(240))?;
let staged_md5 =
remote.root_command(&format!("md5sum {REMOTE_STAGE}"), Duration::from_secs(60))?;
let staged_md5 = String::from_utf8_lossy(&staged_md5)
.split_whitespace()
.next()
.unwrap_or("")
.to_ascii_lowercase();
if staged_md5 != plan.expected_md5 {
let _ = remote.root_command(&format!("rm -f {REMOTE_STAGE}"), Duration::from_secs(15));
return Err(InstallError::StageMismatch);
}
remote.root_command(
&format!(
"dd if={REMOTE_STAGE} of={} bs=1M conv=fsync 2>&1; sync",
plan.partition.device
),
Duration::from_secs(240),
)?;
let readback = remote.root_command(
&format!("md5sum {}", plan.partition.device),
Duration::from_secs(90),
)?;
let readback = String::from_utf8_lossy(&readback)
.split_whitespace()
.next()
.unwrap_or("")
.to_ascii_lowercase();
let _ = remote.root_command(&format!("rm -f {REMOTE_STAGE}"), Duration::from_secs(15));
if readback != plan.expected_md5 {
return Err(InstallError::Readback(restore_command(
&plan.partition.device,
backup_path,
)));
}
Ok(())
}
#[derive(Clone, Debug)]
pub struct RestoreOptions {
pub confirm: Option<String>,
pub no_reboot: bool,
}
#[derive(Clone, Debug)]
pub struct RestoreReceipt {
pub backup_path: PathBuf,
pub image_md5: String,
pub rebooted: bool,
}
pub fn restore(
backup: &Path,
remote: &mut dyn Remote,
options: &RestoreOptions,
) -> Result<RestoreReceipt, InstallError> {
if options.confirm.as_deref() != Some("FLASH") {
return Err(InstallError::Confirm);
}
let data = fs::read(backup)?;
if data.len() != 16 * 1024 * 1024 {
return Err(InstallError::BackupSize(backup.to_path_buf()));
}
let md5 = md5_hex(&data);
let sha256: String = Sha256::digest(&data)
.iter()
.map(|byte| format!("{byte:02x}"))
.collect();
if let Some(sidecar) = read_sidecar(backup) {
if sidecar != sha256 {
return Err(InstallError::BackupMismatch);
}
}
let root_uid = String::from_utf8_lossy(&remote.root_command("id -u", Duration::from_secs(20))?)
.trim()
.to_owned();
if root_uid != "0" {
return Err(InstallError::Preflight(format!(
"root channel returned uid {root_uid}"
)));
}
let size = remote.user_command(
"cat /sys/class/block/mmcblk0p1/size 2>/dev/null || true",
Duration::from_secs(15),
)?;
let sectors: u64 = String::from_utf8_lossy(&size).trim().parse().unwrap_or(0);
if sectors.saturating_mul(512) != 16 * 1024 * 1024 {
return Err(InstallError::Preflight(
"the board does not expose a 16 MiB /dev/mmcblk0p1".to_owned(),
));
}
let staged = tempfile::NamedTempFile::new()?;
fs::write(staged.path(), &data)?;
remote.push(staged.path(), REMOTE_STAGE, Duration::from_secs(240))?;
let staged_md5 =
remote.root_command(&format!("md5sum {REMOTE_STAGE}"), Duration::from_secs(60))?;
let staged_md5 = String::from_utf8_lossy(&staged_md5)
.split_whitespace()
.next()
.unwrap_or("")
.to_ascii_lowercase();
if staged_md5 != md5 {
let _ = remote.root_command(&format!("rm -f {REMOTE_STAGE}"), Duration::from_secs(15));
return Err(InstallError::StageMismatch);
}
remote.root_command(
&format!("dd if={REMOTE_STAGE} of=/dev/mmcblk0p1 bs=1M conv=fsync 2>&1; sync"),
Duration::from_secs(240),
)?;
let readback = remote.root_command("md5sum /dev/mmcblk0p1", Duration::from_secs(90))?;
let readback = String::from_utf8_lossy(&readback)
.split_whitespace()
.next()
.unwrap_or("")
.to_ascii_lowercase();
let _ = remote.root_command(&format!("rm -f {REMOTE_STAGE}"), Duration::from_secs(15));
if readback != md5 {
return Err(InstallError::RestoreReadback);
}
let rebooted = if options.no_reboot {
false
} else {
remote.reboot()?;
true
};
Ok(RestoreReceipt {
backup_path: backup.to_path_buf(),
image_md5: md5,
rebooted,
})
}
fn restore_command(device: &str, backup: &Path) -> String {
format!(
"alkane-cli afw restore --host <ip> --held-backup {} --confirm FLASH (the held copy of {device} is at {})",
backup.display(),
backup.display()
)
}
fn default_backup_dir() -> PathBuf {
alkane_core::platform::config_path("backups")
}
fn write_sidecars(
path: &Path,
md5: &str,
sha256: &str,
partition: &alkane_artifacts::afw::AfwPartition,
image_sha256: &str,
epoch: u64,
) -> Result<(), InstallError> {
let file_name = path
.file_name()
.map(|name| name.to_string_lossy().into_owned())
.unwrap_or_else(|| "p1.img".to_owned());
fs::write(
path.with_extension("img.sha256"),
format!("{sha256} {file_name}\n"),
)?;
let metadata = serde_json::json!({
"board": "cv1835",
"partition": partition.name,
"device": partition.device,
"size": partition.size,
"md5": md5,
"sha256": sha256,
"afw_sha256": image_sha256,
"created_unix": epoch,
});
fs::write(
path.with_extension("img.json"),
serde_json::to_vec_pretty(&metadata).unwrap_or_default(),
)?;
Ok(())
}
fn read_sidecar(path: &Path) -> Option<String> {
let text = fs::read_to_string(path.with_extension("img.sha256")).ok()?;
text.split_whitespace().next().map(str::to_owned)
}
#[derive(Clone, Debug)]
pub struct LiveReport {
pub attempts: u32,
pub http: String,
pub http_ok: bool,
pub ssh: String,
pub ssh_ok: bool,
pub api: String,
pub api_ok: bool,
}
impl LiveReport {
pub fn ok(&self) -> bool {
self.http_ok && self.ssh_ok && self.api_ok
}
pub fn render(&self) -> String {
format!(
"verify-live attempts {}\n http {}: {}\n ssh {}: {}\n api {}: {}\nresult {}",
self.attempts,
if self.http_ok { "ok" } else { "FAIL" },
self.http,
if self.ssh_ok { "ok" } else { "FAIL" },
self.ssh,
if self.api_ok { "ok" } else { "FAIL" },
self.api,
if self.ok() { "PASS" } else { "FAIL" }
)
}
}
pub fn verify_live(
host: &str,
marker: &str,
kernel_version: &str,
timeout: Duration,
ssh_options: &SshOptions,
) -> LiveReport {
let deadline = Instant::now() + timeout;
let mut attempts = 0;
loop {
attempts += 1;
let (http, http_ok) = match http_get(host, "/", Duration::from_secs(5)) {
Ok(body) => {
let ok = body.contains(marker);
(
if ok {
format!("marker {marker} present")
} else {
format!("marker {marker} absent ({} bytes)", body.len())
},
ok,
)
}
Err(error) => (error, false),
};
let (ssh, ssh_ok) = match SshTransport::connect(ssh_options.clone(), false) {
Ok(mut session) => match session.user_command("uname -r", Duration::from_secs(15)) {
Ok(output) => {
let kernel = String::from_utf8_lossy(&output).trim().to_owned();
let ok = !kernel.is_empty()
&& (kernel_version.is_empty() || kernel.contains(kernel_version));
(
format!(
"kernel {kernel}{}",
if ok {
""
} else {
" (expected the installed kernel)"
}
),
ok,
)
}
Err(error) => (format!("{error}"), false),
},
Err(error) => (format!("{error}"), false),
};
let (api, api_ok) = match api_version(host, Duration::from_secs(5)) {
Ok(body) => {
let ok = body.contains("\"STATUS\"")
|| body.contains("\"VERSION\"")
|| body.to_lowercase().contains("version");
(format!("{} bytes", body.len()), ok)
}
Err(error) => (error, false),
};
if http_ok && ssh_ok && api_ok {
return LiveReport {
attempts,
http,
http_ok,
ssh,
ssh_ok,
api,
api_ok,
};
}
if Instant::now() >= deadline {
return LiveReport {
attempts,
http,
http_ok,
ssh,
ssh_ok,
api,
api_ok,
};
}
std::thread::sleep(Duration::from_secs(5));
}
}
pub(crate) fn http_get(host: &str, path: &str, timeout: Duration) -> Result<String, String> {
let address = (host, 80_u16)
.to_socket_addrs()
.map_err(|error| format!("resolve: {error}"))?
.next()
.ok_or_else(|| "no address".to_owned())?;
let mut stream = TcpStream::connect_timeout(&address, timeout)
.map_err(|error| format!("connect: {error}"))?;
stream
.set_read_timeout(Some(timeout))
.map_err(|error| error.to_string())?;
let request = format!("GET {path} HTTP/1.0\r\nHost: {host}\r\nConnection: close\r\n\r\n");
stream
.write_all(request.as_bytes())
.map_err(|error| error.to_string())?;
let mut data = Vec::new();
let mut buffer = [0_u8; 8192];
loop {
match stream.read(&mut buffer) {
Ok(0) => break,
Ok(read) => {
data.extend_from_slice(&buffer[..read]);
if data.len() > 512 * 1024 {
break;
}
}
Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => break,
Err(error) if error.kind() == std::io::ErrorKind::TimedOut => break,
Err(error) => return Err(error.to_string()),
}
}
let text = String::from_utf8_lossy(&data).into_owned();
let status_ok = text
.lines()
.next()
.map(|line| line.contains(" 200 ") || line.ends_with(" 200"))
.unwrap_or(false);
if status_ok {
Ok(text)
} else {
Err(text.lines().next().unwrap_or("no HTTP response").to_owned())
}
}
pub(crate) fn api_version(host: &str, timeout: Duration) -> Result<String, String> {
let address = (host, 4028_u16)
.to_socket_addrs()
.map_err(|error| format!("resolve: {error}"))?
.next()
.ok_or_else(|| "no address".to_owned())?;
let mut stream = TcpStream::connect_timeout(&address, timeout)
.map_err(|error| format!("connect: {error}"))?;
stream
.set_read_timeout(Some(timeout))
.map_err(|error| error.to_string())?;
stream
.write_all(b"{\"command\":\"version\"}\n")
.map_err(|error| error.to_string())?;
let mut data = Vec::new();
let mut buffer = [0_u8; 4096];
loop {
match stream.read(&mut buffer) {
Ok(0) => break,
Ok(read) => {
data.extend_from_slice(&buffer[..read]);
if data.len() > 64 * 1024 {
break;
}
}
Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => break,
Err(error) if error.kind() == std::io::ErrorKind::TimedOut => break,
Err(error) => return Err(error.to_string()),
}
}
let text = String::from_utf8_lossy(&data).trim().to_owned();
if text.is_empty() {
Err("no API response".to_owned())
} else {
Ok(text)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn derives_backup_sidecar_names() {
let path = Path::new("/tmp/p1-1.img");
assert_eq!(
path.with_extension("img.sha256"),
Path::new("/tmp/p1-1.img.sha256")
);
assert_eq!(
path.with_extension("img.json"),
Path::new("/tmp/p1-1.img.json")
);
}
#[test]
fn restore_command_names_the_held_copy() {
let command = restore_command("/dev/mmcblk0p1", Path::new("/tmp/p1.img"));
assert!(command.contains("afw restore"));
assert!(command.contains("/tmp/p1.img"));
}
}
#[cfg(test)]
mod network_tests {
use super::*;
use alkane_artifacts::afw::{AfwImage, AfwManifest, AfwMember, AfwPartition, BootloaderPolicy};
use serde_json::json;
use std::collections::HashMap;
const P1: usize = 16 * 1024 * 1024;
const REV: &str = "0000000000000000000000000000000000000000";
struct MockRemote {
partition: Vec<u8>,
files: HashMap<String, Vec<u8>>,
commands: Vec<String>,
rebooted: bool,
readback_corrupt: bool,
}
impl MockRemote {
fn new(partition: Vec<u8>) -> Self {
Self {
partition,
files: HashMap::new(),
commands: Vec::new(),
rebooted: false,
readback_corrupt: false,
}
}
fn md5(&self, data: &[u8]) -> String {
md5_hex(data)
}
}
impl Remote for MockRemote {
fn channel(&self) -> &str {
"mock"
}
fn root_method(&self) -> &'static str {
"direct"
}
fn user_command(
&mut self,
command: &str,
_timeout: Duration,
) -> Result<Vec<u8>, RemoteError> {
self.commands.push(command.to_owned());
let text = if command.contains("uname -r") {
"6.18.48\n__MODEL__\nAlkane CV1835\n__RELEASE__\nalkane\n".to_owned()
} else if command.contains("test -b") {
"block".to_owned()
} else if command.contains("/sys/class/block/mmcblk0p1/size") {
"32768".to_owned()
} else if command.contains("for c in dd") {
"dd\nmd5sum\nsync\n".to_owned()
} else if command.contains("df -k") {
"Filesystem 1K-blocks Used Available Use% Mounted on\n/dev/root 100000 1 90000 1% /tmp\n".to_owned()
} else if command.contains("mmcblk0boot0") {
"yes".to_owned()
} else {
String::new()
};
Ok(text.into_bytes())
}
fn root_command(
&mut self,
command: &str,
_timeout: Duration,
) -> Result<Vec<u8>, RemoteError> {
self.commands.push(command.to_owned());
if command.starts_with("id -u") || command == "id" {
return Ok(b"0\n".to_vec());
}
if let Some(rest) = command.strip_prefix("md5sum /dev/mmcblk0p1") {
let _ = rest;
let mut data = self.partition.clone();
if self.readback_corrupt && self.files.contains_key(REMOTE_STAGE) {
if let Some(last) = data.last_mut() {
*last ^= 0xff;
}
self.readback_corrupt = false;
}
return Ok(format!("{} /dev/mmcblk0p1\n", self.md5(&data)).into_bytes());
}
if let Some(rest) = command.strip_prefix("md5sum ") {
let path = rest.split_whitespace().next().unwrap_or("");
let data = self.files.get(path).cloned().unwrap_or_default();
return Ok(format!("{} {path}\n", self.md5(&data)).into_bytes());
}
if let Some(rest) = command.strip_prefix("dd if=") {
let mut parts = rest.splitn(2, " of=");
let source = parts.next().unwrap_or("");
let target = parts
.next()
.unwrap_or("")
.split_whitespace()
.next()
.unwrap_or("");
if source == "/dev/mmcblk0p1" {
self.files.insert(target.to_owned(), self.partition.clone());
} else if target == "/dev/mmcblk0p1" {
if let Some(data) = self.files.get(source).cloned() {
self.partition = data;
}
}
return Ok(Vec::new());
}
if command.starts_with("rm -f ") {
let path = command.trim_start_matches("rm -f ").trim();
self.files.remove(path);
return Ok(Vec::new());
}
Ok(Vec::new())
}
fn push(
&mut self,
local: &Path,
remote: &str,
_timeout: Duration,
) -> Result<(), RemoteError> {
self.files.insert(remote.to_owned(), fs::read(local)?);
Ok(())
}
fn pull(
&mut self,
remote: &str,
local: &Path,
_timeout: Duration,
) -> Result<(), RemoteError> {
let data = self
.files
.get(remote)
.cloned()
.ok_or_else(|| RemoteError::Daemon("missing file".to_owned()))?;
fs::write(local, data)?;
Ok(())
}
fn reboot(&mut self) -> Result<(), RemoteError> {
self.rebooted = true;
Ok(())
}
}
fn p1_image() -> Vec<u8> {
let mut fit = vec![0_u8; P1];
fit[..4].copy_from_slice(b"\xd0\x0d\xfe\xed");
let marker = b"config@cv1835_miner_emmc";
fit[0x100..0x100 + marker.len()].copy_from_slice(marker);
fit
}
fn verified(data: &[u8]) -> VerifiedAfw {
let manifest = AfwManifest {
schema: 2,
format: "afw".to_owned(),
board: "cv1835".to_owned(),
arch: "arm64".to_owned(),
version: "0.1.0".to_owned(),
build_date: "2026-11-04T00:00:00Z".to_owned(),
sdk_revision: REV.to_owned(),
os_revision: REV.to_owned(),
payload_type: "os".to_owned(),
bootloader_policy: BootloaderPolicy::Preserve,
signature: alkane_artifacts::afw::AfwSignature {
kind: "unsigned".to_owned(),
member: None,
public_key_hex: None,
},
partitions: vec![
AfwPartition {
name: "p1".to_owned(),
device: "/dev/mmcblk0p1".to_owned(),
offset: 0,
size: P1 as u64,
secure: false,
boot_critical: true,
write_order: 1,
image: Some("p1".to_owned()),
},
AfwPartition {
name: "boot0".to_owned(),
device: "/dev/mmcblk0boot0".to_owned(),
offset: 0,
size: 4 * 1024 * 1024,
secure: true,
boot_critical: true,
write_order: 0,
image: None,
},
],
images: vec![AfwImage {
name: "p1".to_owned(),
file: "payload/p1.fit".to_owned(),
role: "boot".to_owned(),
format: "fit".to_owned(),
size: P1 as u64,
sha256: Sha256::digest(data)
.iter()
.map(|byte| format!("{byte:02x}"))
.collect(),
partition: Some("p1".to_owned()),
install: true,
}],
boot_switch: json!({"method": "partition-overwrite"}),
preflight: json!({"required_commands": ["dd", "md5sum", "sync"],
"source_os": ["stock-bitmain", "vnish", "braiins", "ouros", "alkane"],
"min_free_bytes": 33554432}),
recovery: json!({"network": "afw restore", "golden_lba_bytes": 0x300000u64 * 512}),
marker: "Alkane".to_owned(),
kernel_version: "6.18.48".to_owned(),
notes: None,
};
VerifiedAfw {
manifest,
members: vec![AfwMember {
name: "payload/p1.fit".to_owned(),
data: data.to_vec(),
}],
manifest_sha256: "0".repeat(64),
archive_sha256: "0".repeat(64),
}
}
#[test]
fn installs_p1_holds_a_backup_and_verifies_before_reboot() {
let original = vec![0x11_u8; P1];
let new = p1_image();
let afw = verified(&new);
let plan = Cv1835Plan::from_afw(&afw).unwrap();
let mut remote = MockRemote::new(original.clone());
let temp = tempfile::tempdir().unwrap();
let options = InstallOptions {
dry_run: false,
confirm: Some("FLASH".to_owned()),
no_reboot: true,
backup_dir: temp.path().to_path_buf(),
held_backup: None,
allow_unknown_source: true,
check_golden: false,
};
let outcome = install(&afw, &plan, &mut remote, &options, "10.255.1.1").unwrap();
let InstallOutcome::Installed(receipt) = outcome else {
panic!("expected an install");
};
assert_eq!(remote.partition, new);
assert_eq!(receipt.backup_md5, md5_hex(&original));
assert!(receipt.backup_path.is_file());
assert!(!remote.rebooted);
assert!(remote
.commands
.iter()
.any(|command| command.starts_with("dd if=/tmp/.alkane-p1-stage.img")));
}
#[test]
fn dry_run_never_writes_the_partition() {
let original = vec![0x22_u8; P1];
let new = p1_image();
let afw = verified(&new);
let plan = Cv1835Plan::from_afw(&afw).unwrap();
let mut remote = MockRemote::new(original.clone());
let temp = tempfile::tempdir().unwrap();
let options = InstallOptions {
dry_run: true,
confirm: None,
no_reboot: false,
backup_dir: temp.path().to_path_buf(),
held_backup: None,
allow_unknown_source: true,
check_golden: false,
};
let outcome = install(&afw, &plan, &mut remote, &options, "10.255.1.1").unwrap();
assert!(matches!(outcome, InstallOutcome::DryRun(_)));
assert_eq!(remote.partition, original);
assert!(!remote
.commands
.iter()
.any(|command| command.starts_with("dd if=/tmp/.alkane-p1-stage.img")));
}
#[test]
fn a_readback_mismatch_stops_before_reboot() {
let original = vec![0x33_u8; P1];
let new = p1_image();
let afw = verified(&new);
let plan = Cv1835Plan::from_afw(&afw).unwrap();
let mut remote = MockRemote::new(original);
remote.readback_corrupt = true;
let temp = tempfile::tempdir().unwrap();
let options = InstallOptions {
dry_run: false,
confirm: Some("FLASH".to_owned()),
no_reboot: false,
backup_dir: temp.path().to_path_buf(),
held_backup: None,
allow_unknown_source: true,
check_golden: false,
};
let result = install(&afw, &plan, &mut remote, &options, "10.255.1.1");
assert!(matches!(result, Err(InstallError::Readback(_))));
assert!(!remote.rebooted);
}
#[test]
fn confirm_is_required_before_any_device_write() {
let original = vec![0x44_u8; P1];
let new = p1_image();
let afw = verified(&new);
let plan = Cv1835Plan::from_afw(&afw).unwrap();
let mut remote = MockRemote::new(original.clone());
let temp = tempfile::tempdir().unwrap();
let options = InstallOptions {
dry_run: false,
confirm: None,
no_reboot: false,
backup_dir: temp.path().to_path_buf(),
held_backup: None,
allow_unknown_source: true,
check_golden: false,
};
let result = install(&afw, &plan, &mut remote, &options, "10.255.1.1");
assert!(matches!(result, Err(InstallError::Confirm)));
assert_eq!(remote.partition, original);
}
}
+32 -2
View File
@@ -1,6 +1,36 @@
// SPDX-License-Identifier: MIT
//! Guarded write sequence for a verified artifact and an SDK partition plan.
//! Board transport adapters must supply serial, recovery and readback evidence.
//! Guarded writes plus the network-only CV1835 installer.
//!
//! The original guarded-write helpers remain for boards that need an attached
//! recovery channel. CV1835 uses the network modules below: a verified `.afw`,
//! a board plan, an SSH transport with a stock-root stage, a read-only
//! preflight, a whole-partition read-back and a network restore.
// The board modules are driven by static NAND/partition map tables (tuples) and
// multi-field hardware write functions; the two style lints below are design
// choices for this crate rather than defects.
#![allow(clippy::type_complexity, clippy::too_many_arguments)]
pub mod boards;
pub mod install;
pub mod md5;
pub mod preflight;
pub mod stock;
pub mod stock_firmware;
// Network-only stock-crossing method bodies compiled into the toolkit; the
// public interface lives in `stock`. See stock_method.rs. This module is
// maintained as a self-contained unit; the style lints below are allowed here so
// its internal layout is not churned to satisfy them.
#[allow(
clippy::needless_range_loop,
clippy::type_complexity,
clippy::too_many_arguments,
clippy::manual_repeat_n,
clippy::manual_is_multiple_of,
clippy::unnecessary_map_or
)]
mod stock_method;
pub mod transport;
use alkane_artifacts::VerifiedArtifact;
use sha2::{Digest, Sha256};
+116
View File
@@ -0,0 +1,116 @@
// SPDX-License-Identifier: MIT
//! MD5 for the CV1835 whole-partition read-back.
//!
//! The stock busybox on this board ships `md5sum` but not `sha256sum`, and the
//! proven installer gates the write on a whole-partition md5. This module is a
//! small RFC 1321 implementation so the host can compare the same digest
//! without shelling out to a tool that may not exist.
const S: [u32; 64] = [
7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9,
14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 6, 10, 15,
21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21,
];
const K: [u32; 64] = [
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
];
pub fn md5(data: &[u8]) -> [u8; 16] {
let mut state = [0x67452301_u32, 0xefcdab89, 0x98badcfe, 0x10325476];
let bit_length = (data.len() as u64).wrapping_mul(8);
let mut message = data.to_vec();
message.push(0x80);
while message.len() % 64 != 56 {
message.push(0);
}
message.extend_from_slice(&bit_length.to_le_bytes());
for chunk in message.chunks_exact(64) {
let mut words = [0_u32; 16];
for (index, word) in words.iter_mut().enumerate() {
let start = index * 4;
*word = u32::from_le_bytes([
chunk[start],
chunk[start + 1],
chunk[start + 2],
chunk[start + 3],
]);
}
let [mut a, mut b, mut c, mut d] = state;
for index in 0..64 {
let (f, g) = match index {
0..=15 => ((b & c) | (!b & d), index),
16..=31 => ((d & b) | (!d & c), (5 * index + 1) % 16),
32..=47 => (b ^ c ^ d, (3 * index + 5) % 16),
_ => (c ^ (b | !d), (7 * index) % 16),
};
let rotated = a
.wrapping_add(f)
.wrapping_add(K[index])
.wrapping_add(words[g])
.rotate_left(S[index]);
a = d;
d = c;
c = b;
b = b.wrapping_add(rotated);
}
state[0] = state[0].wrapping_add(a);
state[1] = state[1].wrapping_add(b);
state[2] = state[2].wrapping_add(c);
state[3] = state[3].wrapping_add(d);
}
let mut digest = [0_u8; 16];
for (index, word) in state.iter().enumerate() {
digest[index * 4..index * 4 + 4].copy_from_slice(&word.to_le_bytes());
}
digest
}
pub fn md5_hex(data: &[u8]) -> String {
md5(data).iter().map(|byte| format!("{byte:02x}")).collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rfc1321_vectors() {
assert_eq!(md5_hex(b""), "d41d8cd98f00b204e9800998ecf8427e");
assert_eq!(md5_hex(b"a"), "0cc175b9c0f1b6a831c399e269772661");
assert_eq!(md5_hex(b"abc"), "900150983cd24fb0d6963f7d28e17f72");
assert_eq!(
md5_hex(b"message digest"),
"f96b697d7cb7938d525a2f31aaf161d0"
);
assert_eq!(
md5_hex(b"abcdefghijklmnopqrstuvwxyz"),
"c3fcd3d76192e4007dfb496cca67e13b"
);
assert_eq!(
md5_hex(b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"),
"d174ab98d277d9f5a5611c2c9f419d9f"
);
assert_eq!(
md5_hex(
b"12345678901234567890123456789012345678901234567890123456789012345678901234567890"
),
"57edf4a22be3c955ac49da2e2107b67a"
);
}
#[test]
fn handles_a_block_boundary() {
let data = vec![0x42_u8; 64];
assert_eq!(md5_hex(&data), "8e558437ffca99de04c18a63b55a4fad");
}
}
+420
View File
@@ -0,0 +1,420 @@
// SPDX-License-Identifier: MIT
//! Read-only CV1835 preflight: source-OS fingerprint, root channel, partition
//! identity, held/golden backup hashes, free space and secure-region refusal.
//!
//! Every check runs over the network. A failure is reported, never repaired.
use crate::boards::cv1835::{Cv1835Plan, CvPlanError};
use crate::md5::md5_hex;
use crate::transport::{Remote, RemoteError};
use sha2::{Digest, Sha256};
use std::fs;
use std::path::{Path, PathBuf};
use std::time::Duration;
use thiserror::Error;
const P1_NAME: &str = "mmcblk0p1";
#[derive(Debug, Error)]
pub enum PreflightError {
#[error("preflight transport: {0}")]
Remote(#[from] RemoteError),
#[error("preflight I/O: {0}")]
Io(#[from] std::io::Error),
#[error("preflight plan: {0}")]
Plan(#[from] CvPlanError),
#[error("held backup {path} is {size} bytes, not 16 MiB")]
BackupSize { path: PathBuf, size: u64 },
#[error("held backup {0} has no readable md5")]
BackupUnreadable(PathBuf),
}
#[derive(Clone, Debug)]
pub struct Check {
pub name: &'static str,
pub ok: bool,
pub detail: String,
}
#[derive(Clone, Debug)]
pub struct BackupCheck {
pub path: PathBuf,
pub md5: String,
pub sha256: String,
pub matches_live: bool,
}
#[derive(Clone, Debug)]
pub struct PreflightReport {
pub host: String,
pub source_os: String,
pub kernel: String,
pub model: String,
pub root_method: String,
pub root_uid: String,
pub partition_device: String,
pub partition_size: u64,
pub live_md5: String,
pub held_backup: Option<BackupCheck>,
pub golden_md5: Option<String>,
pub free_bytes: u64,
pub boot0_present: bool,
pub checks: Vec<Check>,
}
impl PreflightReport {
pub fn ok(&self) -> bool {
self.checks.iter().all(|check| check.ok)
}
pub fn failures(&self) -> Vec<&Check> {
self.checks.iter().filter(|check| !check.ok).collect()
}
pub fn render(&self) -> String {
let mut out = String::new();
out.push_str(&format!("preflight {}\n", self.host));
out.push_str(&format!(
"source-os {} (kernel {})\n",
self.source_os, self.kernel
));
if !self.model.is_empty() {
out.push_str(&format!("model {}\n", self.model));
}
out.push_str(&format!(
"root {} (uid {})\n",
self.root_method, self.root_uid
));
out.push_str(&format!(
"partition {} {} B\n",
self.partition_device, self.partition_size
));
out.push_str(&format!("live p1 md5 {}\n", self.live_md5));
match &self.held_backup {
Some(backup) => out.push_str(&format!(
"held backup {} md5 {} ({})\n",
backup.path.display(),
backup.md5,
if backup.matches_live {
"matches live p1"
} else {
"differs from live p1"
}
)),
None => out.push_str("held backup none (install will create one before writing)\n"),
}
if let Some(golden) = &self.golden_md5 {
out.push_str(&format!("golden raw p1 md5 {golden}\n"));
}
out.push_str(&format!(
"free tmp {} MiB\n",
self.free_bytes / (1024 * 1024)
));
out.push_str(&format!(
"boot0 {} (never written)\n",
if self.boot0_present {
"present"
} else {
"not present"
}
));
for check in &self.checks {
out.push_str(&format!(
"check {} {}: {}\n",
check.name,
if check.ok { "ok" } else { "FAIL" },
check.detail
));
}
out.push_str(if self.ok() {
"result PASS\n"
} else {
"result FAIL (do not write)\n"
});
out
}
}
pub struct PreflightOptions<'a> {
pub host: &'a str,
pub held_backup: Option<&'a Path>,
pub check_golden: bool,
pub allow_unknown_source: bool,
}
pub fn preflight(
plan: &Cv1835Plan,
remote: &mut dyn Remote,
options: &PreflightOptions<'_>,
) -> Result<PreflightReport, PreflightError> {
let mut checks = Vec::new();
let fingerprint = remote.user_command(
"uname -r; echo __MODEL__; cat /proc/device-tree/model 2>/dev/null; echo; \
echo __RELEASE__; cat /etc/os-release 2>/dev/null; \
ls /etc/bos_version /etc/fw-info /etc/alkane-release /etc/ouros-release 2>/dev/null; \
test -x /nvdata/rroot && echo rroot; \
test -x /usr/sbin/update-daemon && echo update-daemon",
Duration::from_secs(20),
)?;
let text = String::from_utf8_lossy(&fingerprint).into_owned();
let mut sections = text.split("__MODEL__");
let kernel = sections.next().unwrap_or("").trim().to_owned();
let rest = sections.next().unwrap_or("");
let mut sections = rest.split("__RELEASE__");
let model = sections.next().unwrap_or("").trim().to_owned();
let release = sections.next().unwrap_or("");
let source_os = classify(&kernel, release, &text);
let source_ok = plan.source_os.is_empty()
|| plan.source_os.iter().any(|item| item == &source_os)
|| options.allow_unknown_source;
checks.push(Check {
name: "source-os",
ok: source_ok,
detail: format!(
"{source_os} (allowed: {})",
if plan.source_os.is_empty() {
"any".to_owned()
} else {
plan.source_os.join(", ")
}
),
});
let root_uid = String::from_utf8_lossy(&remote.root_command("id -u", Duration::from_secs(20))?)
.trim()
.to_owned();
checks.push(Check {
name: "root",
ok: root_uid == "0",
detail: format!("uid {root_uid}"),
});
let partition_device = plan.partition.device.clone();
let block = String::from_utf8_lossy(&remote.user_command(
&format!("test -b {partition_device} && echo block || echo missing"),
Duration::from_secs(15),
)?)
.trim()
.to_owned();
let size_out = remote.user_command(
&format!("cat /sys/class/block/{P1_NAME}/size 2>/dev/null || true"),
Duration::from_secs(15),
)?;
let sectors: u64 = String::from_utf8_lossy(&size_out)
.trim()
.parse()
.unwrap_or(0);
let partition_size = sectors.saturating_mul(512);
checks.push(Check {
name: "partition",
ok: block == "block" && partition_size == plan.partition.size,
detail: format!(
"{partition_device} {partition_size} B (plan {} B)",
plan.partition.size
),
});
let live = remote.root_command(
&format!("md5sum {partition_device}"),
Duration::from_secs(60),
)?;
let live_md5 = parse_digest(&live, 32).unwrap_or_else(|| "unreadable".to_owned());
checks.push(Check {
name: "live-p1-md5",
ok: live_md5.len() == 32,
detail: live_md5.clone(),
});
let commands = remote.user_command(
"for c in dd md5sum sync; do command -v $c >/dev/null 2>&1 && echo $c || echo missing:$c; done",
Duration::from_secs(15),
)?;
let commands_text = String::from_utf8_lossy(&commands).into_owned();
let missing: Vec<&str> = commands_text
.lines()
.filter_map(|line| line.strip_prefix("missing:"))
.collect();
checks.push(Check {
name: "commands",
ok: missing.is_empty(),
detail: if missing.is_empty() {
"dd, md5sum, sync present".to_owned()
} else {
format!("missing {}", missing.join(", "))
},
});
let free_bytes = free_bytes(remote)?;
checks.push(Check {
name: "free-space",
ok: free_bytes >= plan.min_free_bytes,
detail: format!(
"{} MiB at /tmp (plan {} MiB)",
free_bytes / (1024 * 1024),
plan.min_free_bytes / (1024 * 1024)
),
});
let boot0 = String::from_utf8_lossy(&remote.user_command(
"test -e /dev/mmcblk0boot0 && echo yes || echo no",
Duration::from_secs(15),
)?)
.trim()
.to_owned();
let boot0_present = boot0 == "yes";
checks.push(Check {
name: "secure-regions",
ok: !plan.partition.device.contains("boot0"),
detail: format!(
"boot0 {}; the write plan targets only {}",
if boot0_present { "present" } else { "absent" },
plan.partition.device
),
});
let mut held_backup = None;
if let Some(path) = options.held_backup {
let size = fs::metadata(path)?.len();
if size != plan.partition.size {
return Err(PreflightError::BackupSize {
path: path.to_path_buf(),
size,
});
}
let data = fs::read(path)?;
let md5 = md5_hex(&data);
let sha256: String = Sha256::digest(&data)
.iter()
.map(|byte| format!("{byte:02x}"))
.collect();
let matches_live = md5 == live_md5;
checks.push(Check {
name: "held-backup",
ok: true,
detail: format!(
"{} md5 {md5} ({})",
path.display(),
if matches_live {
"matches live p1"
} else {
"differs from live p1; restore will still write it"
}
),
});
held_backup = Some(BackupCheck {
path: path.to_path_buf(),
md5,
sha256,
matches_live,
});
}
let mut golden_md5 = None;
if options.check_golden {
let out = remote.root_command(
&format!(
"dd if=/dev/mmcblk0 skip={} count=32768 bs=512 2>/dev/null | md5sum",
plan.golden_lba_bytes / 512
),
Duration::from_secs(90),
)?;
if let Some(digest) = parse_digest(&out, 32) {
golden_md5 = Some(digest);
}
}
Ok(PreflightReport {
host: options.host.to_owned(),
source_os,
kernel,
model,
root_method: remote.root_method().to_owned(),
root_uid,
partition_device,
partition_size,
live_md5,
held_backup,
golden_md5,
free_bytes,
boot0_present,
checks,
})
}
pub(crate) fn classify(kernel: &str, release: &str, all: &str) -> String {
if all.contains("/etc/bos_version") || release.contains("Braiins") {
return "braiins".to_owned();
}
if all.contains("/etc/alkane-release") || kernel.starts_with("6.18") {
return "alkane".to_owned();
}
if all.contains("/etc/ouros-release") || kernel.contains("6.6.147") {
return "ouros".to_owned();
}
if all.contains("/etc/fw-info") || release.contains("Vnish") || release.contains("AnthillOS") {
return "vnish".to_owned();
}
// Stock Bitmain control boards: Amlogic stock is kernel 4.9.38; the AM335x
// (BeagleBone-class) stock is kernel 3.8.13+ with an "Antminer" model line.
if kernel.contains("4.9.38")
|| kernel.starts_with("3.8.13")
|| all.contains("update-daemon")
|| all.contains("rroot")
|| all.to_lowercase().contains("antminer")
{
return "stock-bitmain".to_owned();
}
"unknown".to_owned()
}
pub fn parse_digest(output: &[u8], length: usize) -> Option<String> {
let text = String::from_utf8_lossy(output);
text.split_whitespace()
.map(|token| token.trim().to_ascii_lowercase())
.find(|token| token.len() == length && token.bytes().all(|byte| byte.is_ascii_hexdigit()))
}
fn free_bytes(remote: &mut dyn Remote) -> Result<u64, RemoteError> {
let out = remote.user_command("df -k /tmp 2>/dev/null || df -k /", Duration::from_secs(15))?;
let text = String::from_utf8_lossy(&out);
for line in text.lines().rev() {
let fields: Vec<&str> = line.split_whitespace().collect();
if fields.len() >= 4 {
if let Ok(kib) = fields[3].parse::<u64>() {
return Ok(kib.saturating_mul(1024));
}
}
}
Ok(0)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn classifies_the_source_os() {
assert_eq!(
classify("4.9.38-tag-", "", "update-daemon\n"),
"stock-bitmain"
);
assert_eq!(
classify("4.9.38-tag-", "/etc/fw-info\n", "/etc/fw-info\n"),
"vnish"
);
assert_eq!(classify("6.6.147", "/etc/ouros-release\n", ""), "ouros");
assert_eq!(classify("6.18.48", "", ""), "alkane");
assert_eq!(classify("4.9.38", "", "/etc/bos_version\n"), "braiins");
assert_eq!(classify("5.10.0", "", ""), "unknown");
}
#[test]
fn parses_md5_from_md5sum_output() {
let output = b"3f43804f10ce256200bfc71e7fbdd9ee /dev/mmcblk0p1\n";
assert_eq!(
parse_digest(output, 32).as_deref(),
Some("3f43804f10ce256200bfc71e7fbdd9ee")
);
assert_eq!(parse_digest(b"not a digest\n", 32), None);
}
}
+222
View File
@@ -0,0 +1,222 @@
// SPDX-License-Identifier: MIT
//! Stock <-> alkane crossing, compiled into the toolkit.
//!
//! The toolkit is self-contained: it installs alkane onto a board on stock and
//! returns a board to stock entirely on its own, with no external helper and no
//! runtime dependency on any other tool. A user's machine needs only this
//! binary.
//!
//! Getting our first image onto a board past its stock safeguards (with root),
//! and the reverse, are implemented in the sibling module `stock_method`. This
//! file is the stable public boundary around that work: the interface
//! (`StockMethod`, `StockError`) plus the toolkit-side orchestration and
//! verification around the method. The method is plain Rust and must be
//! network-only.
use alkane_artifacts::afw::VerifiedAfw;
use std::path::{Path, PathBuf};
use thiserror::Error;
#[derive(Debug, Error)]
pub enum StockError {
#[error("the stock method is not implemented in this build")]
NotImplemented,
#[error("could not reach the board: {0}")]
Network(String),
#[error("authentication failed: {0}")]
Auth(String),
#[error("the stock method failed: {0}")]
Method(String),
#[error("io: {0}")]
Io(String),
}
/// The genuine Bitmain stock kernel and rootfs to write back when restoring to
/// stock, parsed from a vendor firmware package (OTA or SD) by `stock_firmware`.
/// The matching NAND device tree is NOT taken from the package: Bitmain never
/// ships the kernel device tree in its distributable firmware (it is factory-
/// provisioned and preserved by every update), so the method supplies the
/// correct per-board dtb itself. Borrowed so the large rootfs is not copied
/// before the method needs it.
pub struct RestoreImages<'a> {
pub kernel: &'a [u8],
pub rootfs: &'a [u8],
}
/// Options for updating a board that already runs alkane, in place.
#[derive(Clone, Debug, Default)]
pub struct InPlaceOptions {
/// Read-only: report the board state, the storage map and the write plan,
/// and write nothing.
pub dry_run: bool,
/// Reboot after the images are written and read back, then wait for the
/// board to return as alkane.
pub reboot: bool,
/// Where to keep a copy of each boot slot as it was before the write. When
/// set, every slot is read and saved before any erase; a failed backup
/// aborts the update with nothing written.
pub backup_dir: Option<PathBuf>,
}
/// One boot slot as it was before an in-place update.
#[derive(Clone, Debug)]
pub struct HeldSlot {
pub name: String,
/// Absolute NAND offset of the slot.
pub absolute: u64,
pub size: u64,
pub path: PathBuf,
pub md5: String,
}
#[derive(Clone, Debug)]
pub struct InPlaceReceipt {
pub backups: Vec<HeldSlot>,
pub rebooted: bool,
}
#[derive(Clone, Debug)]
pub enum InPlaceOutcome {
/// The dry-run report; nothing was written.
DryRun(String),
Updated(InPlaceReceipt),
}
/// Result of a live check that a Zynq board is up on alkane: two channels
/// (HTTP page marker, SSH kernel/OS) must agree.
#[derive(Clone, Debug)]
pub struct LiveCheck {
pub attempts: u32,
pub http: String,
pub http_ok: bool,
pub ssh: String,
pub ssh_ok: bool,
/// The running kernel command line (informational: on a NAND boot it is
/// the board's U-Boot env bootargs).
pub cmdline: String,
}
impl LiveCheck {
pub fn ok(&self) -> bool {
self.http_ok && self.ssh_ok
}
pub fn render(&self) -> String {
format!(
"verify-live attempts {}\n http {}: {}\n ssh {}: {}\n cmdline: {}\nresult {}\n",
self.attempts,
if self.http_ok { "PASS" } else { "FAIL" },
self.http,
if self.ssh_ok { "PASS" } else { "FAIL" },
self.ssh,
if self.cmdline.is_empty() {
"(not read)"
} else {
&self.cmdline
},
if self.ok() { "PASS" } else { "FAIL" }
)
}
}
/// The stock-side methods, implemented by `stock_method`. All implementations
/// must be NETWORK-ONLY (no serial-console dependency).
pub trait StockMethod {
/// Put our first image (the `.afw`) onto a board currently on stock, past
/// stock's gates and with root, over the network only. On Ok the board is
/// installed with alkane; the caller verifies liveness.
fn install_from_stock(
&self,
host: &str,
afw_path: &Path,
afw: &VerifiedAfw,
password: Option<&str>,
) -> Result<(), StockError>;
/// Return an aftermarket (alkane) board to genuine stock, over the network
/// only, by writing the given genuine Bitmain stock images (`images`) back to
/// NAND. `password` is the board's alkane root credential. On Ok the board is
/// on stock; the caller verifies.
fn restore_to_stock(
&self,
host: &str,
images: &RestoreImages,
password: Option<&str>,
) -> Result<(), StockError>;
/// Update a board that already runs alkane to the `.afw`'s images, over the
/// network only. Refuses a board that is not running alkane (a board on
/// stock is installed with `install_from_stock`). The boot regions are not
/// exposed to Linux on alkane, so they are re-registered the same way as for
/// a restore; the images are written in the form the board's stock U-Boot
/// boots, each read back before reboot, and BOOT.bin is never written.
fn update_in_place(
&self,
host: &str,
afw: &VerifiedAfw,
password: Option<&str>,
options: &InPlaceOptions,
) -> Result<InPlaceOutcome, StockError>;
}
/// The compiled-in method implementation.
pub fn method() -> &'static dyn StockMethod {
crate::stock_method::method()
}
/// Install alkane onto a board on stock (network-only), via the compiled-in method.
pub fn install_from_stock(
host: &str,
afw_path: &Path,
afw: &VerifiedAfw,
password: Option<&str>,
) -> Result<(), StockError> {
method().install_from_stock(host, afw_path, afw, password)
}
/// Return an alkane board to stock (network-only) by writing the genuine Bitmain
/// stock `images` back to NAND, via the compiled-in method.
pub fn restore_to_stock(
host: &str,
images: &RestoreImages,
password: Option<&str>,
) -> Result<(), StockError> {
method().restore_to_stock(host, images, password)
}
/// Check, over the network, that a Zynq board is up on alkane: the web page
/// carries `marker` (case-insensitive) and SSH reports alkane with a kernel
/// containing `kernel_version` (if non-empty). Retries until `timeout`.
pub fn verify_zynq_live(
host: &str,
password: Option<&str>,
marker: &str,
kernel_version: &str,
timeout: std::time::Duration,
) -> Result<LiveCheck, StockError> {
crate::stock_method::live_check(host, password, marker, kernel_version, timeout)
}
/// Update a board already on alkane to the `.afw`'s images, in place
/// (network-only), via the compiled-in method.
pub fn update_in_place(
host: &str,
afw: &VerifiedAfw,
password: Option<&str>,
options: &InPlaceOptions,
) -> Result<InPlaceOutcome, StockError> {
method().update_in_place(host, afw, password, options)
}
#[cfg(test)]
mod tests {
use super::*;
// The interface is exercised against whatever `stock_method` provides. We
// only assert the toolkit wires a method object in; its behaviour is the
// method module's own tests.
#[test]
fn a_method_is_compiled_in() {
let _m: &dyn StockMethod = method();
}
}
+282
View File
@@ -0,0 +1,282 @@
// SPDX-License-Identifier: MIT
//! Parse a genuine Bitmain Antminer stock firmware package into the flashable
//! stock images, so the toolkit can restore a board to genuine stock using the
//! vendor's own files (no carved blobs).
//!
//! Two genuine source shapes are handled for the Zynq-7010 (Antminer S17):
//!
//! - OTA update `.tar.gz` (`Antminer-S17-user-OM-<date>-sig*.tar.gz`): a signed
//! outer tar holding `cert.pem`, `fw.tar.gz` and `runme.sh` (each with a
//! `.sig`). The inner `fw.tar.gz` holds `BOOT.bin`, `uImage` (legacy kernel),
//! `uramdisk.image.gz` (rootfs) and `md5_info` (md5 of the rootfs). The OTA
//! package does NOT carry the device tree: the factory SD provisioning writes
//! it once and OTA upgrades preserve it.
//! - SD recovery `.zip` (`SD_Antminer-S17-*.zip`): the full factory image,
//! which DOES include `devicetree.dtb` alongside `BOOT.bin`/`uImage`/
//! `uramdisk.image.gz`. This is the complete source for a from-anywhere
//! restore, because it carries the device tree the stock kernel needs.
//!
//! Extraction shells out to the system `tar`/`unzip`/`gzip` (as the release
//! fetch shells out to `curl`); nothing is written outside a private temp dir.
use std::path::Path;
use std::process::Command;
use crate::md5::md5_hex;
#[derive(Debug, thiserror::Error)]
pub enum StockFirmwareError {
#[error("io: {0}")]
Io(String),
#[error("could not read {0}")]
Read(String),
#[error("unrecognised firmware package (not a .tar.gz or .zip): {0}")]
Format(String),
#[error("extraction failed: {0}")]
Extract(String),
#[error("the firmware package is missing a stock {0} image")]
MissingImage(&'static str),
#[error("rootfs md5 mismatch: package lists {expected}, image is {actual}")]
RootfsMd5 { expected: String, actual: String },
#[error("needed system tool not found: {0}")]
MissingTool(String),
}
/// The stock images carved from a genuine Bitmain firmware package, ready to
/// write back to NAND. `boot_bin` and `dtb` are optional (an OTA package omits
/// the dtb; the bootloader is only written on an explicit full restore).
pub struct StockFirmware {
pub boot_bin: Option<Vec<u8>>,
pub dtb: Option<Vec<u8>>,
pub kernel: Vec<u8>,
pub rootfs: Vec<u8>,
pub version: Option<String>,
/// The source package kind, for logging.
pub source_kind: &'static str,
}
impl StockFirmware {
pub fn summary(&self) -> String {
let v = self.version.as_deref().unwrap_or("unknown");
format!(
"{} (version {}): kernel {} B, rootfs {} B, dtb {}, BOOT.bin {}",
self.source_kind,
v,
self.kernel.len(),
self.rootfs.len(),
self.dtb.as_ref().map_or("absent", |_| "present"),
self.boot_bin.as_ref().map_or("absent", |_| "present"),
)
}
}
fn have_tool(tool: &str) -> bool {
Command::new(tool)
.arg("--version")
.output()
.map(|o| o.status.success() || !o.stdout.is_empty() || !o.stderr.is_empty())
.unwrap_or(false)
}
fn run(cmd: &mut Command, what: &str) -> Result<(), StockFirmwareError> {
let out = cmd
.output()
.map_err(|e| StockFirmwareError::Extract(format!("{what}: {e}")))?;
if !out.status.success() {
return Err(StockFirmwareError::Extract(format!(
"{what}: {}",
String::from_utf8_lossy(&out.stderr).trim()
)));
}
Ok(())
}
/// Recursively collect files under `dir` as (relative-path-lowercased, absolute path).
fn collect_files(dir: &Path) -> Vec<(String, std::path::PathBuf)> {
fn walk(base: &Path, dir: &Path, out: &mut Vec<(String, std::path::PathBuf)>) {
let Ok(entries) = std::fs::read_dir(dir) else {
return;
};
for entry in entries.flatten() {
let path = entry.path();
if path.is_dir() {
walk(base, &path, out);
} else if let Ok(rel) = path.strip_prefix(base) {
out.push((rel.to_string_lossy().to_lowercase(), path.clone()));
}
}
}
let mut out = Vec::new();
walk(dir, dir, &mut out);
out
}
/// Pick the best file whose basename matches `name`, preferring paths that
/// contain one of `prefer` path fragments (e.g. "bin/" for the SD image, "fw"
/// for the OTA inner tree), then the shallowest path.
fn pick<'a>(
files: &'a [(String, std::path::PathBuf)],
name: &str,
prefer: &[&str],
) -> Option<&'a std::path::PathBuf> {
let name = name.to_lowercase();
let mut matches: Vec<&(String, std::path::PathBuf)> = files
.iter()
.filter(|(rel, _)| rel.rsplit('/').next() == Some(name.as_str()) || *rel == name)
.collect();
if matches.is_empty() {
return None;
}
matches.sort_by_key(|(rel, _)| {
let pref_rank = prefer
.iter()
.position(|p| rel.contains(p))
.unwrap_or(prefer.len());
let depth = rel.matches('/').count();
(pref_rank, depth)
});
matches.first().map(|(_, p)| p)
}
fn read(path: &Path) -> Result<Vec<u8>, StockFirmwareError> {
std::fs::read(path).map_err(|_| StockFirmwareError::Read(path.display().to_string()))
}
/// Parse a genuine Bitmain stock firmware package (OTA `.tar.gz` or SD `.zip`)
/// into its stock images.
pub fn parse(path: &Path) -> Result<StockFirmware, StockFirmwareError> {
let bytes = std::fs::read(path)
.map_err(|e| StockFirmwareError::Io(format!("{}: {e}", path.display())))?;
if bytes.len() < 4 {
return Err(StockFirmwareError::Format(path.display().to_string()));
}
let is_gzip = bytes[0] == 0x1f && bytes[1] == 0x8b;
let is_zip = &bytes[0..2] == b"PK";
if !is_gzip && !is_zip {
return Err(StockFirmwareError::Format(path.display().to_string()));
}
let tmp = tempfile::Builder::new()
.prefix("alkane-stockfw-")
.tempdir()
.map_err(|e| StockFirmwareError::Io(e.to_string()))?;
let root = tmp.path();
let (source_kind, prefer): (&'static str, &[&str]) = if is_zip {
if !have_tool("unzip") {
return Err(StockFirmwareError::MissingTool("unzip".into()));
}
run(
Command::new("unzip")
.arg("-qq")
.arg("-o")
.arg(path)
.arg("-d")
.arg(root),
"unzip SD recovery image",
)?;
("Bitmain SD recovery image", &["bin/"])
} else {
if !have_tool("tar") {
return Err(StockFirmwareError::MissingTool("tar".into()));
}
run(
Command::new("tar").arg("xzf").arg(path).arg("-C").arg(root),
"untar OTA package",
)?;
// The signed OTA wraps the real images in an inner fw.tar.gz; extract it.
let inner = collect_files(root)
.into_iter()
.find(|(rel, _)| rel.rsplit('/').next() == Some("fw.tar.gz"));
if let Some((_, inner_path)) = inner {
let inner_dir = root.join("fw");
std::fs::create_dir_all(&inner_dir)
.map_err(|e| StockFirmwareError::Io(e.to_string()))?;
run(
Command::new("tar")
.arg("xzf")
.arg(&inner_path)
.arg("-C")
.arg(&inner_dir),
"untar OTA inner fw.tar.gz",
)?;
}
("Bitmain OTA update package", &["fw/", "bin/"])
};
let files = collect_files(root);
let kernel_path = pick(&files, "uImage", prefer)
.ok_or(StockFirmwareError::MissingImage("uImage (kernel)"))?;
let rootfs_path = pick(&files, "uramdisk.image.gz", prefer).ok_or(
StockFirmwareError::MissingImage("uramdisk.image.gz (rootfs)"),
)?;
let kernel = read(kernel_path)?;
let rootfs = read(rootfs_path)?;
let boot_bin = pick(&files, "BOOT.bin", prefer)
.map(|p| read(p))
.transpose()?;
let dtb = pick(&files, "devicetree.dtb", &["", "bin/"])
.map(|p| read(p))
.transpose()?;
// Verify the rootfs against md5_info when the package ships one (OTA does).
if let Some(md5_path) = pick(&files, "md5_info", prefer) {
if let Ok(raw) = std::fs::read_to_string(md5_path) {
let expected = raw.split_whitespace().next().unwrap_or("").to_lowercase();
if expected.len() == 32 {
let actual = md5_hex(&rootfs);
if actual != expected {
return Err(StockFirmwareError::RootfsMd5 { expected, actual });
}
}
}
}
let version = pick(&files, "version", prefer)
.or_else(|| pick(&files, "version_number", &[""]))
.and_then(|p| std::fs::read_to_string(p).ok())
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty());
Ok(StockFirmware {
boot_bin,
dtb,
kernel,
rootfs,
version,
source_kind,
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rejects_non_archive() {
let tmp = tempfile::NamedTempFile::new().unwrap();
std::fs::write(tmp.path(), b"not an archive").unwrap();
assert!(matches!(
parse(tmp.path()),
Err(StockFirmwareError::Format(_))
));
}
// Parse a real Bitmain firmware package. Set ALKANE_TEST_STOCK_FW to its path.
// Ignored by default (needs the vendor file, not in the repo).
#[test]
#[ignore]
fn parses_real_package() {
let Ok(path) = std::env::var("ALKANE_TEST_STOCK_FW") else {
eprintln!("set ALKANE_TEST_STOCK_FW to a firmware file");
return;
};
let fw = parse(Path::new(&path)).expect("parse");
eprintln!("{}", fw.summary());
assert!(!fw.kernel.is_empty(), "kernel present");
assert!(!fw.rootfs.is_empty(), "rootfs present");
// The kernel is a legacy u-boot uImage: magic 0x27051956 big-endian.
assert_eq!(&fw.kernel[0..4], &[0x27, 0x05, 0x19, 0x56], "uImage magic");
}
}
File diff suppressed because it is too large Load Diff
+699
View File
@@ -0,0 +1,699 @@
// SPDX-License-Identifier: MIT
//! Network transport for the CV1835 installer.
//!
//! Two root channels are implemented, both over the network:
//!
//! * `direct`: the SSH login is already uid 0 (Braiins OS, ourOS/alkane with a
//! root key, or an operator-supplied root login).
//! * `update-daemon`: stock Bitmain (and Vnish, which runs on the stock
//! kernel) exposes an SSH login as `miner` (uid 1001). `/usr/sbin/update-daemon`
//! listens on 127.0.0.1:12887 and pipes its socket into `system()` as root.
//! We reach it through an SSH local forward, exactly as documented in the RE
//! notes (`cv-kvm-host` / `cvbuild/cvroot.py`,
//! `alkane-sdk-wiki/40-boot-os-and-build/cross-install-matrix.md`). The
//! channel is blind, so root output is redirected to a world-readable file
//! and read back over the unprivileged SSH session.
//! * `rroot`: an existing `/nvdata/rroot` setuid helper on CV stock/Vnish,
//! documented in `60-reverse-engineering-methods/rroot-setuid-escalation.md`.
//! It is a fallback because the helper is not durable across a p7 reformat.
//!
//! Credentials are never read here: a password is used only through
//! `sshpass -f <path>`, and that path comes from the operator (environment
//! variable materialized by the CLI, or a file named on the command line).
use std::fs;
use std::io::{Read, Write};
use std::net::{SocketAddr, TcpStream};
use std::path::{Path, PathBuf};
use std::process::{Child, Command, ExitStatus, Stdio};
use std::thread;
use std::time::{Duration, Instant};
use thiserror::Error;
const MAX_CAPTURE: usize = 64 * 1024 * 1024;
#[derive(Debug, Error)]
pub enum RemoteError {
#[error("remote I/O: {0}")]
Io(#[from] std::io::Error),
#[error("cannot start {0}")]
MissingTool(&'static str),
#[error("invalid target: {0}")]
InvalidTarget(String),
#[error("SSH transport: {0}")]
Ssh(String),
#[error("SSH command timed out after {0:?}")]
Timeout(Duration),
#[error("remote command failed ({status}): {stderr}")]
Command { status: String, stderr: String },
#[error("root access was not obtained: {0}")]
NotRoot(String),
#[error("no network root channel is available on this board")]
NoRootMethod,
#[error("update-daemon: {0}")]
Daemon(String),
#[error("remote output is over the {0}-byte cap")]
OutputTooLarge(usize),
}
impl RemoteError {
fn sanitize(text: &str) -> String {
let text = text.trim();
let mut shortened: String = text.chars().take(300).collect();
if shortened.len() < text.len() {
shortened.push_str("...");
}
shortened
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum RootMethod {
Auto,
Direct,
UpdateDaemon,
Rroot,
}
impl RootMethod {
pub fn parse(value: &str) -> Option<Self> {
match value {
"auto" => Some(Self::Auto),
"direct" => Some(Self::Direct),
"update-daemon" => Some(Self::UpdateDaemon),
"rroot" => Some(Self::Rroot),
_ => None,
}
}
}
#[derive(Clone, Debug)]
pub struct SshOptions {
pub host: String,
pub port: u16,
pub user: String,
pub identity_file: Option<PathBuf>,
pub password_file: Option<PathBuf>,
pub known_hosts: Option<PathBuf>,
pub root_method: RootMethod,
pub update_daemon_port: Option<u16>,
}
impl Default for SshOptions {
fn default() -> Self {
Self {
host: String::new(),
port: 22,
user: "miner".to_owned(),
identity_file: None,
password_file: None,
known_hosts: None,
root_method: RootMethod::Auto,
update_daemon_port: None,
}
}
}
impl SshOptions {
fn validate(&self) -> Result<(), RemoteError> {
if self.host.is_empty()
|| self.host.len() > 253
|| self.host.starts_with('-')
|| !self.host.bytes().all(|byte| {
byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'-' | b':' | b'_')
})
{
return Err(RemoteError::InvalidTarget("host".to_owned()));
}
if self.user.is_empty()
|| !self
.user
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'-' | b'.'))
{
return Err(RemoteError::InvalidTarget("user".to_owned()));
}
if self.port == 0 {
return Err(RemoteError::InvalidTarget("port".to_owned()));
}
if let Some(path) = &self.password_file {
if !path.is_file() {
return Err(RemoteError::InvalidTarget(format!(
"password file not found: {}",
path.display()
)));
}
}
Ok(())
}
}
enum Strategy {
Direct,
Rroot,
UpdateDaemon {
local_port: u16,
remote_port: u16,
tunnel: Child,
},
}
impl Drop for Strategy {
fn drop(&mut self) {
if let Self::UpdateDaemon { tunnel, .. } = self {
let _ = tunnel.kill();
let _ = tunnel.wait();
}
}
}
pub struct SshTransport {
options: SshOptions,
known_hosts: PathBuf,
strategy: Strategy,
counter: u64,
}
impl SshTransport {
/// Open a session and (when `require_root`) prove a uid-0 channel.
pub fn connect(options: SshOptions, require_root: bool) -> Result<Self, RemoteError> {
options.validate()?;
let known_hosts = options
.known_hosts
.clone()
.unwrap_or_else(|| alkane_core::platform::config_path("known_hosts"));
if let Some(parent) = known_hosts.parent() {
fs::create_dir_all(parent)?;
}
if !known_hosts.exists() {
fs::write(&known_hosts, b"")?;
}
if options.password_file.is_some() {
Command::new("sshpass")
.arg("-V")
.stdout(Stdio::null())
.stderr(Stdio::null())
.status()
.map_err(|_| RemoteError::MissingTool("sshpass"))?;
}
let mut transport = Self {
options,
known_hosts,
strategy: Strategy::Direct,
counter: 0,
};
let identity = transport.user_command("uname -r", Duration::from_secs(15))?;
let _ = identity;
if !require_root {
return Ok(transport);
}
let uid =
String::from_utf8_lossy(&transport.user_command("id -u", Duration::from_secs(15))?)
.trim()
.to_owned();
let direct = uid == "0";
let method = match transport.options.root_method {
RootMethod::Auto if direct => RootMethod::Direct,
RootMethod::Auto => {
if transport.has_update_daemon()? {
RootMethod::UpdateDaemon
} else if transport.has_rroot()? {
RootMethod::Rroot
} else {
return Err(RemoteError::NoRootMethod);
}
}
other => other,
};
match method {
RootMethod::Direct => {
if !direct {
return Err(RemoteError::NotRoot(
"the SSH login is not uid 0; use --root-method auto, update-daemon or rroot"
.to_owned(),
));
}
transport.strategy = Strategy::Direct;
}
RootMethod::Rroot => {
if !transport.has_rroot()? {
return Err(RemoteError::NotRoot(
"/nvdata/rroot is not present or not executable".to_owned(),
));
}
transport.strategy = Strategy::Rroot;
}
RootMethod::UpdateDaemon => {
if !transport.has_update_daemon()? {
return Err(RemoteError::NotRoot(
"/usr/sbin/update-daemon is not present".to_owned(),
));
}
let remote_port = transport
.options
.update_daemon_port
.unwrap_or(transport.detect_update_daemon_port()?);
let (local_port, tunnel) = transport.start_tunnel(remote_port)?;
transport.strategy = Strategy::UpdateDaemon {
local_port,
remote_port,
tunnel,
};
}
RootMethod::Auto => unreachable!(),
}
let root_output = transport.root_command("id", Duration::from_secs(20))?;
let root = String::from_utf8_lossy(&root_output);
if !root.contains("uid=0") {
return Err(RemoteError::NotRoot(
"the selected channel did not return uid=0".to_owned(),
));
}
Ok(transport)
}
pub fn channel(&self) -> String {
format!("ssh:{}@{}", self.options.user, self.options.host)
}
pub fn root_method(&self) -> &'static str {
match &self.strategy {
Strategy::Direct => "direct",
Strategy::Rroot => "rroot",
Strategy::UpdateDaemon { .. } => "update-daemon",
}
}
pub fn update_daemon_port(&self) -> Option<u16> {
match &self.strategy {
Strategy::UpdateDaemon { remote_port, .. } => Some(*remote_port),
_ => None,
}
}
fn ssh_base(&self) -> Command {
let mut command = if let Some(password) = &self.options.password_file {
let mut command = Command::new("sshpass");
command.arg("-f").arg(password).arg("ssh");
command
} else {
Command::new("ssh")
};
command
.arg("-F")
.arg("none")
.arg("-o")
.arg(if self.options.password_file.is_some() {
"BatchMode=no"
} else {
"BatchMode=yes"
})
.arg("-o")
.arg("StrictHostKeyChecking=accept-new")
.arg("-o")
.arg(format!("UserKnownHostsFile={}", self.known_hosts.display()))
.arg("-o")
.arg("GlobalKnownHostsFile=/dev/null")
.arg("-o")
.arg("ConnectTimeout=10")
.arg("-o")
.arg("ServerAliveInterval=5")
.arg("-o")
.arg("ServerAliveCountMax=3")
.arg("-o")
.arg("RequestTTY=no")
.arg("-o")
.arg("LogLevel=ERROR")
.arg("-o")
.arg("NumberOfPasswordPrompts=1")
.arg("-o")
.arg("PreferredAuthentications=publickey,password,keyboard-interactive");
if let Some(identity) = &self.options.identity_file {
command
.arg("-i")
.arg(identity)
.arg("-o")
.arg("IdentitiesOnly=yes");
}
command
}
fn ssh_command(&self, command: &str) -> Command {
let mut child = self.ssh_base();
child
.arg("-p")
.arg(self.options.port.to_string())
.arg(format!("{}@{}", self.options.user, self.options.host))
.arg(command);
child
}
fn run_user(&self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError> {
let (stdout, stderr, status) = run_bounded(self.ssh_command(command), timeout)?;
if !status.success() {
return Err(RemoteError::Command {
status: status.to_string(),
stderr: RemoteError::sanitize(&String::from_utf8_lossy(&stderr)),
});
}
Ok(stdout)
}
fn has_rroot(&self) -> Result<bool, RemoteError> {
let out = self.run_user(
"test -x /nvdata/rroot && echo yes || echo no",
Duration::from_secs(15),
)?;
Ok(String::from_utf8_lossy(&out).contains("yes"))
}
fn has_update_daemon(&self) -> Result<bool, RemoteError> {
let out = self.run_user(
"test -x /usr/sbin/update-daemon && echo yes || echo no",
Duration::from_secs(15),
)?;
Ok(String::from_utf8_lossy(&out).contains("yes"))
}
fn detect_update_daemon_port(&self) -> Result<u16, RemoteError> {
let out = self.run_user(
"cat /proc/net/tcp /proc/net/tcp6 2>/dev/null || true",
Duration::from_secs(15),
)?;
let text = String::from_utf8_lossy(&out);
for line in text.lines() {
let fields: Vec<&str> = line.split_whitespace().collect();
if fields.len() < 4 || fields[3] != "0A" {
continue;
}
let local = fields[1];
let port = local.rsplit(':').next().unwrap_or("");
let port = u16::from_str_radix(port, 16).unwrap_or(0);
if port == 12887 || port == 22026 {
return Ok(port);
}
}
// The CV1835 stock build listens on 12887. The fallback keeps the
// explicit --update-daemon-port option available for other builds.
Ok(12887)
}
fn start_tunnel(&self, remote_port: u16) -> Result<(u16, Child), RemoteError> {
let listener = std::net::TcpListener::bind(("127.0.0.1", 0))?;
let local_port = listener.local_addr()?.port();
drop(listener);
let mut command = self.ssh_base();
command
.arg("-N")
.arg("-o")
.arg("ExitOnForwardFailure=yes")
.arg("-L")
.arg(format!("127.0.0.1:{local_port}:127.0.0.1:{remote_port}"))
.arg("-p")
.arg(self.options.port.to_string())
.arg(format!("{}@{}", self.options.user, self.options.host))
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null());
let mut tunnel = command.spawn()?;
let deadline = Instant::now() + Duration::from_secs(20);
loop {
if TcpStream::connect_timeout(
&SocketAddr::from(([127, 0, 0, 1], local_port)),
Duration::from_millis(500),
)
.is_ok()
{
return Ok((local_port, tunnel));
}
if let Some(status) = tunnel.try_wait()? {
return Err(RemoteError::Daemon(format!(
"SSH forward exited before it was ready ({status})"
)));
}
if Instant::now() >= deadline {
let _ = tunnel.kill();
return Err(RemoteError::Daemon(
"SSH forward did not become ready".to_owned(),
));
}
thread::sleep(Duration::from_millis(250));
}
}
fn daemon_send(&self, command: &str) -> Result<(), RemoteError> {
let Strategy::UpdateDaemon { local_port, .. } = &self.strategy else {
return Err(RemoteError::Daemon("not using update-daemon".to_owned()));
};
let local_port = *local_port;
if command.contains('\n') || command.contains('\r') {
return Err(RemoteError::Daemon("command contains a newline".to_owned()));
}
let mut stream = TcpStream::connect_timeout(
&SocketAddr::from(([127, 0, 0, 1], local_port)),
Duration::from_secs(10),
)?;
stream.set_write_timeout(Some(Duration::from_secs(10)))?;
stream.write_all(format!(";{command};").as_bytes())?;
stream.flush()?;
let _ = stream.set_read_timeout(Some(Duration::from_millis(500)));
let mut sink = [0_u8; 256];
let _ = stream.read(&mut sink);
Ok(())
}
fn daemon_capture(&mut self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError> {
let path = format!("/tmp/.alkane-root-{}-{}", std::process::id(), self.counter);
self.counter += 1;
let wrapped = format!("{{ {command} ; }} > {path} 2>&1; chmod 644 {path}");
self.daemon_send(&wrapped)?;
let deadline = Instant::now() + timeout;
loop {
let probe = format!("test -f {path} && echo ready || true");
let out = self.run_user(&probe, Duration::from_secs(15))?;
if String::from_utf8_lossy(&out).contains("ready") {
break;
}
if Instant::now() >= deadline {
return Err(RemoteError::Daemon(format!(
"root command produced no output file within {timeout:?}"
)));
}
thread::sleep(Duration::from_millis(200));
}
let output = self.run_user(&format!("cat {path}"), Duration::from_secs(60))?;
let _ = self.run_user(&format!("rm -f {path}"), Duration::from_secs(15));
Ok(output)
}
fn daemon_reboot(&mut self) -> Result<(), RemoteError> {
self.daemon_send("sync; echo b > /proc/sysrq-trigger")
}
}
impl Remote for SshTransport {
fn channel(&self) -> &str {
"ssh"
}
fn root_method(&self) -> &'static str {
SshTransport::root_method(self)
}
fn user_command(&mut self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError> {
self.run_user(command, timeout)
}
fn root_command(&mut self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError> {
match self.root_method() {
"direct" => self.run_user(command, timeout),
"rroot" => {
let wrapped = format!("/nvdata/rroot -c {}", shell_quote(command));
self.run_user(&wrapped, timeout)
}
"update-daemon" => self.daemon_capture(command, timeout),
_ => Err(RemoteError::NoRootMethod),
}
}
fn push(&mut self, local: &Path, remote: &str, timeout: Duration) -> Result<(), RemoteError> {
let remote = safe_remote_path(remote)?;
let mut command = self.ssh_command(&format!("cat > {remote}"));
command
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped());
let mut child = command.spawn()?;
let mut stdin = child.stdin.take().expect("piped stdin");
let path = local.to_path_buf();
let writer = thread::spawn(move || -> std::io::Result<()> {
let mut source = fs::File::open(path)?;
let mut buffer = [0_u8; 64 * 1024];
loop {
let read = source.read(&mut buffer)?;
if read == 0 {
break;
}
stdin.write_all(&buffer[..read])?;
}
stdin.flush()
});
let (stdout, stderr) = read_pipes(&mut child);
let status = wait_timeout(&mut child, timeout)?;
let _ = writer.join();
let _ = stdout.join();
let stderr = stderr.join().unwrap_or_default();
if !status.success() {
return Err(RemoteError::Command {
status: status.to_string(),
stderr: RemoteError::sanitize(&String::from_utf8_lossy(&stderr)),
});
}
Ok(())
}
fn pull(&mut self, remote: &str, local: &Path, timeout: Duration) -> Result<(), RemoteError> {
let remote = safe_remote_path(remote)?;
let data = self.run_user(&format!("cat {remote}"), timeout)?;
if data.len() > MAX_CAPTURE {
return Err(RemoteError::OutputTooLarge(MAX_CAPTURE));
}
fs::write(local, data)?;
Ok(())
}
fn reboot(&mut self) -> Result<(), RemoteError> {
match self.root_method() {
"update-daemon" => self.daemon_reboot(),
_ => {
// A successful sysrq reset drops the SSH connection mid-command.
let _ = self.run_user(
"sync; echo b > /proc/sysrq-trigger",
Duration::from_secs(15),
);
Ok(())
}
}
}
}
pub trait Remote {
fn channel(&self) -> &str;
fn root_method(&self) -> &'static str {
"network"
}
fn user_command(&mut self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError>;
fn root_command(&mut self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError>;
fn push(&mut self, local: &Path, remote: &str, timeout: Duration) -> Result<(), RemoteError>;
fn pull(&mut self, remote: &str, local: &Path, timeout: Duration) -> Result<(), RemoteError>;
fn reboot(&mut self) -> Result<(), RemoteError>;
}
pub fn shell_quote(text: &str) -> String {
format!("'{}'", text.replace('\'', "'\\''"))
}
pub fn safe_remote_path(path: &str) -> Result<&str, RemoteError> {
if !path.starts_with('/')
|| path.len() > 200
|| path.contains("..")
|| !path
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'/' | b'.' | b'_' | b'-'))
{
return Err(RemoteError::InvalidTarget(format!(
"unsafe remote path: {path}"
)));
}
Ok(path)
}
fn read_pipes(child: &mut Child) -> (thread::JoinHandle<Vec<u8>>, thread::JoinHandle<Vec<u8>>) {
let mut stdout = child.stdout.take().expect("piped stdout");
let mut stderr = child.stderr.take().expect("piped stderr");
let out = thread::spawn(move || {
let mut data = Vec::new();
let _ = stdout.read_to_end(&mut data);
data
});
let err = thread::spawn(move || {
let mut data = Vec::new();
let _ = stderr.read_to_end(&mut data);
data
});
(out, err)
}
fn wait_timeout(child: &mut Child, timeout: Duration) -> Result<ExitStatus, RemoteError> {
let deadline = Instant::now() + timeout;
loop {
if let Some(status) = child.try_wait()? {
return Ok(status);
}
if Instant::now() >= deadline {
let _ = child.kill();
let _ = child.wait();
return Err(RemoteError::Timeout(timeout));
}
thread::sleep(Duration::from_millis(20));
}
}
fn run_bounded(
mut command: Command,
timeout: Duration,
) -> Result<(Vec<u8>, Vec<u8>, ExitStatus), RemoteError> {
command
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped());
let mut child = command.spawn()?;
let (stdout, stderr) = read_pipes(&mut child);
let status = wait_timeout(&mut child, timeout)?;
let stdout = stdout.join().unwrap_or_default();
let stderr = stderr.join().unwrap_or_default();
if stdout.len() > MAX_CAPTURE {
return Err(RemoteError::OutputTooLarge(MAX_CAPTURE));
}
Ok((stdout, stderr, status))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn quotes_shell_arguments_for_rroot() {
assert_eq!(shell_quote("id"), "'id'");
assert_eq!(shell_quote("echo 'x'"), "'echo '\\''x'\\'''");
}
#[test]
fn rejects_option_injection_and_unsafe_paths() {
let mut options = SshOptions {
host: "-oProxyCommand=bad".to_owned(),
user: "root".to_owned(),
..SshOptions::default()
};
assert!(options.validate().is_err());
options.host = "10.255.1.167".to_owned();
options.user = "root;id".to_owned();
assert!(options.validate().is_err());
assert!(safe_remote_path("/tmp/ok.img").is_ok());
assert!(safe_remote_path("relative").is_err());
assert!(safe_remote_path("/tmp/../etc/passwd").is_err());
assert!(safe_remote_path("/tmp/a;b").is_err());
}
#[test]
fn parses_root_methods() {
assert_eq!(RootMethod::parse("auto"), Some(RootMethod::Auto));
assert_eq!(
RootMethod::parse("update-daemon"),
Some(RootMethod::UpdateDaemon)
);
assert_eq!(RootMethod::parse("serial"), None);
}
}
+5
View File
@@ -11,6 +11,11 @@ path = "src/main.rs"
[dependencies]
alkane-core = { path = "../alkane-core" }
alkane-discovery = { path = "../alkane-discovery" }
# The self-contained stock <-> alkane engine (compiled-in method) and the .afw
# verify/fetch, so the GUI can install-from-stock and restore-to-stock and scan
# alkane-os releases through the same code paths the CLI uses.
alkane-flash = { path = "../alkane-flash" }
alkane-artifacts = { path = "../alkane-artifacts" }
# vendored + patched wx-rs (see vendor/wx-rs/patches/)
wx-rs = { path = "../../thirdparty/wx-rs/wx-rs-0.2.0-patched" }
asic-rs = "0.8.1"
+91
View File
@@ -0,0 +1,91 @@
//! Build script for the alkane-toolkit binary. On Windows targets it compiles
//! windows/alkane-toolkit.rc (application manifest, icon, version info, and
//! wxMSW's stock resources) and links the result into the GUI executable only.
//! Other targets need nothing here.
use std::env;
use std::path::PathBuf;
use std::process::Command;
fn main() {
println!("cargo:rerun-if-changed=build.rs");
if env::var("CARGO_CFG_TARGET_OS").as_deref() != Ok("windows") {
return;
}
for f in [
"alkane-toolkit.rc",
"alkane-toolkit.exe.manifest",
"alkane-toolkit.ico",
] {
println!("cargo:rerun-if-changed=windows/{f}");
}
println!("cargo:rerun-if-env-changed=WX_RS_WXCONFIG");
if let Err(e) = compile_resources() {
panic!("alkane-gui: Windows resources: {e}");
}
}
fn compile_resources() -> Result<(), String> {
// The resource compiler and wx's resource include path come from the same
// wx-config the wx-rs bridge builds against, so they always match the
// linked wxMSW (and the mingw cross windres when cross-compiling).
let wxconfig = env::var("WX_RS_WXCONFIG").unwrap_or_else(|_| "wx-config".into());
let run = |arg: &str| -> Result<String, String> {
let out = Command::new(&wxconfig)
.arg(arg)
.output()
.map_err(|e| format!("cannot run {wxconfig} {arg}: {e}"))?;
if !out.status.success() {
return Err(format!("{wxconfig} {arg} failed"));
}
String::from_utf8(out.stdout).map_err(|e| e.to_string())
};
let rescomp = run("--rescomp")?;
let mut words = rescomp.split_whitespace();
let windres = words.next().ok_or("wx-config --rescomp printed nothing")?;
let mut args: Vec<String> = words.map(str::to_owned).collect();
// rcdefs.h lives in the build-specific setup directory, which --rescomp
// omits; it is the -I entry of --cxxflags.
for flag in run("--cxxflags")?.split_whitespace() {
if let Some(dir) = flag.strip_prefix("-I") {
args.push("--include-dir".into());
args.push(dir.into());
}
}
let version = env::var("CARGO_PKG_VERSION").unwrap_or_default();
let mut parts = version
.split(['.', '-', '+'])
.map(|p| p.parse::<u16>().unwrap_or(0));
let (major, minor, patch) = (
parts.next().unwrap_or(0),
parts.next().unwrap_or(0),
parts.next().unwrap_or(0),
);
let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").map_err(|e| e.to_string())?);
let out =
PathBuf::from(env::var("OUT_DIR").map_err(|e| e.to_string())?).join("alkane-toolkit-res.o");
let status = Command::new(windres)
.args(&args)
.arg("--include-dir")
.arg(manifest_dir.join("windows"))
.arg(format!("--define=ALKANE_VER_MAJOR={major}"))
.arg(format!("--define=ALKANE_VER_MINOR={minor}"))
.arg(format!("--define=ALKANE_VER_PATCH={patch}"))
.arg(format!("--define=ALKANE_VER_STR=\\\"{version}\\\""))
.arg("--input")
.arg(manifest_dir.join("windows/alkane-toolkit.rc"))
.arg("--output-format=coff")
.arg("--output")
.arg(&out)
.status()
.map_err(|e| format!("cannot run {windres}: {e}"))?;
if !status.success() {
return Err(format!("{windres} failed ({status})"));
}
// Only the GUI binary carries the manifest/icon; miner_probe stays a plain
// console tool. A linked object (not an archive member) is never dropped by
// the linker, which is what keeps the resource section in the .exe.
println!("cargo:rustc-link-arg-bin=alkane-toolkit={}", out.display());
Ok(())
}
Binary file not shown.
+34
View File
@@ -0,0 +1,34 @@
#!/bin/sh
# Regenerate alkane-toolkit.icns (the macOS app icon) from the in-repo
# microchip glyph: the same white chip on a rounded amber tile as the Windows
# icon, at the sizes macOS asks for (16-1024 px). Needs rsvg-convert,
# ImageMagick and python3; the .icns is committed, so a build never runs this.
set -e
cd "$(dirname "$0")"
GLYPH=../assets/icons/microchip-solid-full.svg
TMP=$(mktemp -d)
trap 'rm -rf "$TMP"' 0
sed 's/currentColor/#ffffff/g; s/<svg /<svg fill="#ffffff" /' "$GLYPH" > "$TMP/glyph.svg"
for s in 16 32 64 128 256 512 1024; do
# Apple's grid: the tile fills ~80% of the canvas, centred.
t=$((s * 80 / 100)); m=$(((s - t) / 2)); r=$((t * 22 / 100))
g=$((t * 60 / 100)); o=$(((s - g) / 2))
rsvg-convert -w "$g" -h "$g" "$TMP/glyph.svg" -o "$TMP/g$s.png"
convert -size "${s}x${s}" xc:none -fill '#d9822b' \
-draw "roundrectangle $m,$m $((m + t - 1)),$((m + t - 1)) $r,$r" \
"$TMP/g$s.png" -geometry "+$o+$o" -composite "PNG32:$TMP/i$s.png"
done
python3 - "$TMP" alkane-toolkit.icns <<'PY'
import pathlib, struct, sys
tmp, out = pathlib.Path(sys.argv[1]), sys.argv[2]
# ICNS element types that hold PNG data, by pixel size.
types = [("icp4", 16), ("icp5", 32), ("icp6", 64), ("ic07", 128), ("ic08", 256),
("ic09", 512), ("ic10", 1024), ("ic11", 32), ("ic12", 64), ("ic13", 256),
("ic14", 512)]
body = b""
for kind, size in types:
data = (tmp / f"i{size}.png").read_bytes()
body += kind.encode() + struct.pack(">I", len(data) + 8) + data
pathlib.Path(out).write_bytes(b"icns" + struct.pack(">I", len(body) + 8) + body)
PY
echo "wrote $(pwd)/alkane-toolkit.icns"
+69 -23
View File
@@ -29,10 +29,10 @@ use std::net::{SocketAddr, TcpStream};
use std::process::Command;
use std::time::Duration;
use aes::cipher::{block_padding::ZeroPadding, BlockEncryptMut, KeyInit};
use aes::Aes256;
use aes::cipher::{BlockEncryptMut, KeyInit, block_padding::ZeroPadding};
use base64::Engine;
use base64::engine::general_purpose::STANDARD as BASE64;
use base64::Engine;
use sha2::{Digest, Sha256};
type Aes256EcbEnc = ecb::Encryptor<Aes256>;
@@ -42,9 +42,9 @@ type Aes256EcbEnc = ecb::Encryptor<Aes256>;
/// authenticated/unauthorized answer is `None`.
pub fn classify_http_code(code: &str) -> Option<bool> {
match code.trim() {
"200" | "204" => Some(false), // authenticated -> unlocked/writable
"401" | "403" => Some(true), // rejected -> locked/view-only
_ => None, // 000 (no connect), 404, 5xx, ... -> unknown
"200" | "204" => Some(false), // authenticated -> unlocked/writable
"401" | "403" => Some(true), // rejected -> locked/view-only
_ => None, // 000 (no connect), 404, 5xx, ... -> unknown
}
}
@@ -77,11 +77,11 @@ pub fn probe_access(ip: &str, make: &str, user: &str, pass: &str) -> Result<Opti
return Ok(probe_whatsminer_access(ip, &candidates));
}
let url = format!("http://{ip}{}", endpoint(make));
let mut cmd = Command::new("curl");
let mut cmd = alkane_core::platform::quiet_command("curl");
cmd.args([
"-s",
"-o",
"/dev/null",
alkane_core::platform::NULL_DEVICE,
"-w",
"%{http_code}",
"--digest",
@@ -95,7 +95,10 @@ pub fn probe_access(ip: &str, make: &str, user: &str, pass: &str) -> Result<Opti
]);
// The user:pass goes through a curl config on stdin, never argv, so it can't
// be read from the process list (round 18 #12).
let config = format!("user = \"{}\"\n", curl_config_quote(&format!("{user}:{pass}")));
let config = format!(
"user = \"{}\"\n",
curl_config_quote(&format!("{user}:{pass}"))
);
let out = wait_with_timeout(cmd, Duration::from_secs(12), Some(config.as_bytes()))?;
// curl prints the status code to stdout regardless of exit status (000 on a
// connection failure), so classify the code rather than the exit status.
@@ -113,7 +116,8 @@ fn wait_with_timeout(
stdin_data: Option<&[u8]>,
) -> Result<std::process::Output, String> {
use std::io::{Read, Write};
cmd.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::piped());
cmd.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped());
if stdin_data.is_some() {
cmd.stdin(std::process::Stdio::piped());
}
@@ -135,7 +139,11 @@ fn wait_with_timeout(
if let Some(mut e) = child.stderr.take() {
let _ = e.read_to_end(&mut stderr);
}
return Ok(std::process::Output { status, stdout, stderr });
return Ok(std::process::Output {
status,
stdout,
stderr,
});
}
None => {
if start.elapsed() >= timeout {
@@ -158,7 +166,8 @@ fn curl_config_quote(s: &str) -> String {
/// override (round 12 #13) wins; otherwise the two factory defaults ("admin" for
/// V1/V2, "super" for V3). All attempts are non-mutating, so trying both is safe.
fn whatsminer_password_candidates() -> Vec<String> {
if let Some((_, pass)) = crate::credentials::load_firmware_credentials().get("WhatsMiner Stock") {
if let Some((_, pass)) = crate::credentials::load_firmware_credentials().get("WhatsMiner Stock")
{
if !pass.is_empty() {
return vec![pass.clone()];
}
@@ -170,9 +179,17 @@ fn whatsminer_password_candidates() -> Vec<String> {
/// get_error_code command and format them one per line for the log viewer
/// (round 12 #12). Returns None if the miner does not answer.
pub fn whatsminer_get_error_code(ip: &str) -> Option<String> {
let resp = wm_rpc(ip, "{\"command\":\"get_error_code\"}", Duration::from_secs(6)).ok()?;
let resp = wm_rpc(
ip,
"{\"command\":\"get_error_code\"}",
Duration::from_secs(6),
)
.ok()?;
let v: serde_json::Value = serde_json::from_str(&resp).ok()?;
let codes = v.get("Msg").and_then(|m| m.get("error_code")).and_then(|c| c.as_array());
let codes = v
.get("Msg")
.and_then(|m| m.get("error_code"))
.and_then(|c| c.as_array());
let mut lines = vec![format!("WhatsMiner get_error_code ({ip}):")];
match codes {
Some(arr) if !arr.is_empty() => {
@@ -198,7 +215,9 @@ fn wm_rpc(ip: &str, payload: &str, timeout: Duration) -> Result<String, String>
let mut stream = TcpStream::connect_timeout(&addr, timeout).map_err(|e| e.to_string())?;
stream.set_read_timeout(Some(timeout)).ok();
stream.set_write_timeout(Some(timeout)).ok();
stream.write_all(payload.as_bytes()).map_err(|e| e.to_string())?;
stream
.write_all(payload.as_bytes())
.map_err(|e| e.to_string())?;
let mut buf = Vec::new();
let mut chunk = [0u8; 4096];
loop {
@@ -213,7 +232,9 @@ fn wm_rpc(ip: &str, payload: &str, timeout: Duration) -> Result<String, String>
Err(_) => break,
}
}
Ok(String::from_utf8_lossy(&buf).trim_matches('\u{0}').to_string())
Ok(String::from_utf8_lossy(&buf)
.trim_matches('\u{0}')
.to_string())
}
/// AES-256-ECB encrypt `data` under SHA256(pwd_md5), base64-encoded -- the exact
@@ -278,15 +299,20 @@ fn probe_whatsminer_access(ip: &str, passwords: &[String]) -> Option<bool> {
// 2. Derive the md5crypt password hash + write-token from the password.
let crypted = md5crypt::md5crypt(pass.as_bytes(), salt.as_bytes());
let full = String::from_utf8_lossy(&crypted);
let Some(pwd_md5) = full.split('$').nth(3) else { continue };
let sign_crypted = md5crypt::md5crypt(format!("{pwd_md5}{time}").as_bytes(), newsalt.as_bytes());
let Some(pwd_md5) = full.split('$').nth(3) else {
continue;
};
let sign_crypted =
md5crypt::md5crypt(format!("{pwd_md5}{time}").as_bytes(), newsalt.as_bytes());
let sign_full = String::from_utf8_lossy(&sign_crypted);
let host_sign = sign_full.split('$').nth(3).unwrap_or("");
// 3. Send an encrypted, read-only `summary`. If the AES key (from the
// password) is right the miner replies encrypted; if wrong it returns
// a plaintext "enc json load err".
let cmd = format!("{{\"command\":\"summary\",\"token\":\"{host_sign}\"}}");
let Some(enc) = wm_aes_ecb_enc(pwd_md5, &cmd) else { continue };
let Some(enc) = wm_aes_ecb_enc(pwd_md5, &cmd) else {
continue;
};
let payload = format!("{{\"enc\":1,\"data\":\"{enc}\"}}");
let resp = match wm_rpc(ip, &payload, timeout) {
Ok(s) => s,
@@ -302,7 +328,11 @@ fn probe_whatsminer_access(ip: &str, passwords: &[String]) -> Option<bool> {
}
// Only report "locked" when we cleanly reached the miner and every candidate
// was rejected with no transient errors; otherwise the result is indeterminate.
if reachable && !errored { Some(true) } else { None }
if reachable && !errored {
Some(true)
} else {
None
}
}
#[cfg(test)]
@@ -311,14 +341,30 @@ mod tests {
#[test]
fn classify_codes() {
assert_eq!(classify_http_code("200"), Some(false), "authenticated -> unlocked");
assert_eq!(
classify_http_code("200"),
Some(false),
"authenticated -> unlocked"
);
assert_eq!(classify_http_code("204"), Some(false));
assert_eq!(classify_http_code("401"), Some(true), "unauthorized -> locked");
assert_eq!(
classify_http_code("401"),
Some(true),
"unauthorized -> locked"
);
assert_eq!(classify_http_code("403"), Some(true));
assert_eq!(classify_http_code("000"), None, "no connection -> unknown");
assert_eq!(classify_http_code("404"), None, "endpoint absent -> unknown");
assert_eq!(
classify_http_code("404"),
None,
"endpoint absent -> unknown"
);
assert_eq!(classify_http_code("500"), None);
assert_eq!(classify_http_code(" 200 "), Some(false), "whitespace tolerated");
assert_eq!(
classify_http_code(" 200 "),
Some(false),
"whitespace tolerated"
);
assert_eq!(classify_http_code(""), None);
}
+305
View File
@@ -0,0 +1,305 @@
//! Boards running Alkane OS on the network, and which alkane-os actions apply to
//! a scanned row.
//!
//! asic-rs recognises miners by their cgminer socket (:4028) or a vendor web UI.
//! A board running Alkane OS keeps its cgminer-compatible socket on loopback and
//! serves its own console, so asic-rs reports nothing at that address and the
//! board never appeared in the fleet. This probe finds it over plain HTTP:
//! - `GET /api/identity` (alkane-os 0.1.2 and later): os, os_version, board,
//! sdk_revision, hostname, mac, kernel;
//! - otherwise the cgminer-style `GET /api/summary`, whose STATUS Description
//! is "alkane-os" (earlier images: found, but the board family is unknown).
//!
//! Both endpoints are public and read-only on the board.
use crate::model::MinerRow;
use serde_json::{json, Value};
use std::net::IpAddr;
use std::time::Duration;
/// Firmware family shown for a board running Alkane OS.
pub const FIRMWARE: &str = "Alkane";
const CONNECT_TIMEOUT: Duration = Duration::from_secs(2);
const READ_TIMEOUT: Duration = Duration::from_secs(4);
const MAX_RESPONSE: usize = 64 * 1024;
/// Probe `ip` for Alkane OS. Returns a row for the fleet table, or None when the
/// address is not an Alkane board (or does not answer on :80).
pub async fn detect(ip: IpAddr) -> Option<MinerRow> {
if let Some(doc) = get_json(ip, "/api/identity").await {
if doc.get("os").and_then(Value::as_str) == Some("alkane-os") {
return Some(row_from_identity(ip, &doc));
}
}
let summary = get_json(ip, "/api/summary").await?;
if is_alkane_summary(&summary) {
return Some(row_from_identity(ip, &json!({})));
}
None
}
/// The cgminer-style summary an Alkane board serves names "alkane-os" in its
/// STATUS Description.
fn is_alkane_summary(doc: &Value) -> bool {
doc.get("STATUS")
.and_then(Value::as_array)
.and_then(|status| status.first())
.and_then(|entry| entry.get("Description"))
.and_then(Value::as_str)
== Some("alkane-os")
}
/// Control-board labels (cpu, code) for an Alkane board family, matching the
/// labels the scan gives the same board on stock firmware.
fn board_labels(board: &str) -> (&'static str, &'static str) {
match board {
"zynq-7010" => ("XIL", "C49"),
"am335x" => ("BBB", "C77"),
"cv1835" => ("CVI", "C88"),
"a113d" => ("AML", "C76"),
_ => ("", ""),
}
}
fn row_from_identity(ip: IpAddr, doc: &Value) -> MinerRow {
let text = |key: &str| {
doc.get(key)
.and_then(Value::as_str)
.unwrap_or("")
.trim()
.to_string()
};
let board = text("board");
let (cpu, code) = board_labels(&board);
let control_board = if cpu.is_empty() {
board.clone()
} else {
format!("{cpu} ({code})")
};
MinerRow {
ip: ip.to_string(),
// The Alkane-supported control boards are all Bitmain (Antminer) boards.
brand: if cpu.is_empty() {
String::new()
} else {
"Antminer".to_string()
},
firmware: FIRMWARE.to_string(),
fw_version: text("os_version"),
api_version: "alkane-os".to_string(),
mac: text("mac"),
hostname: text("hostname"),
control_board,
cpu: cpu.to_string(),
board_code: code.to_string(),
alkane_board: Some(board),
..Default::default()
}
}
/// HTTP/1.0 GET on :80 returning the JSON body of a 200 reply.
async fn get_json(ip: IpAddr, path: &str) -> Option<Value> {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let connect = tokio::net::TcpStream::connect((ip, 80));
let mut stream = tokio::time::timeout(CONNECT_TIMEOUT, connect)
.await
.ok()?
.ok()?;
let request = format!("GET {path} HTTP/1.0\r\nHost: {ip}\r\nConnection: close\r\n\r\n");
stream.write_all(request.as_bytes()).await.ok()?;
let mut raw = Vec::new();
let _ = tokio::time::timeout(READ_TIMEOUT, async {
let mut chunk = [0u8; 4096];
loop {
match stream.read(&mut chunk).await {
Ok(0) | Err(_) => break,
Ok(n) => {
raw.extend_from_slice(&chunk[..n]);
if raw.len() > MAX_RESPONSE {
break;
}
}
}
}
})
.await;
parse_http_json(&raw)
}
fn parse_http_json(raw: &[u8]) -> Option<Value> {
let text = std::str::from_utf8(raw).ok()?;
let (head, body) = text.split_once("\r\n\r\n")?;
let status = head.lines().next()?;
if status.split_whitespace().nth(1) != Some("200") {
return None;
}
serde_json::from_str(body.trim()).ok()
}
/// Whether the row is a board running Alkane OS (found by `detect`).
pub fn is_alkane(row: &MinerRow) -> bool {
row.alkane_board.is_some()
}
/// The alkane-os board family the row's control board is, when it can be told:
/// what an Alkane board reports, or for a stock Antminer the Zynq-7010 (S17/T17
/// era, "XIL (C49)") control board.
pub fn board_family(row: &MinerRow) -> Option<String> {
if let Some(board) = &row.alkane_board {
return (!board.is_empty()).then(|| board.clone());
}
if !row.brand.to_ascii_lowercase().contains("antminer") {
return None;
}
if row.cpu == "XIL" && row.board_code == "C49" {
return Some("zynq-7010".to_string());
}
// A stock S17 whose miner software is down (no hashboards attached: it
// restart-loops) reports its model but no control board. Its model then
// decides; a control board that IS reported always wins above.
if row.cpu.is_empty() && is_zynq_7010_model(&row.model) {
return Some("zynq-7010".to_string());
}
None
}
/// Stock models built only on the Zynq-7010 (XIL C49) control board.
fn is_zynq_7010_model(model: &str) -> bool {
matches!(model.trim(), "S17" | "S17 Pro" | "T17")
}
/// Whether alkane-os can be installed on the row's board: its control board is
/// one the toolkit supports.
pub fn install_supported(row: &MinerRow) -> bool {
board_family(row).is_some_and(|board| crate::stock_ops::is_supported_board(&board))
}
#[cfg(test)]
mod tests {
use super::*;
fn ip() -> IpAddr {
"10.0.0.5".parse().unwrap()
}
#[test]
fn parses_a_200_json_reply_only() {
let ok = b"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n{\"os\":\"alkane-os\"}";
assert_eq!(parse_http_json(ok).unwrap()["os"], "alkane-os");
let denied = b"HTTP/1.1 401 Unauthorized\r\n\r\n{\"os\":\"alkane-os\"}";
assert!(parse_http_json(denied).is_none());
let html = b"HTTP/1.1 200 OK\r\n\r\n<!DOCTYPE html><title>x</title>";
assert!(parse_http_json(html).is_none());
assert!(parse_http_json(b"garbage").is_none());
}
#[test]
fn recognises_the_alkane_summary() {
let alkane = json!({"STATUS":[{"Code":0,"Description":"alkane-os","STATUS":"S"}]});
assert!(is_alkane_summary(&alkane));
let cgminer = json!({"STATUS":[{"Description":"cgminer 4.11.1","STATUS":"S"}]});
assert!(!is_alkane_summary(&cgminer));
assert!(!is_alkane_summary(&json!({})));
}
#[test]
fn identity_becomes_a_supported_alkane_row() {
let doc = json!({
"os": "alkane-os", "os_version": "0.1.2", "board": "zynq-7010",
"sdk_revision": "6a9080ac82c1", "hostname": "alkane-zynq",
"mac": "26:4e:52:8b:e2:48", "kernel": "6.18.48",
});
let row = row_from_identity(ip(), &doc);
assert_eq!(row.ip, "10.0.0.5");
assert_eq!(row.firmware, "Alkane");
assert_eq!(row.fw_version, "0.1.2");
assert_eq!(row.control_board, "XIL (C49)");
assert_eq!(row.mac, "26:4e:52:8b:e2:48");
assert!(is_alkane(&row));
assert!(install_supported(&row));
}
#[test]
fn an_old_alkane_board_is_alkane_but_its_family_is_unknown() {
// Found via /api/summary only: uninstall applies, install cannot be
// confirmed as supported.
let row = row_from_identity(ip(), &json!({}));
assert!(is_alkane(&row));
assert_eq!(board_family(&row), None);
assert!(!install_supported(&row));
}
#[test]
fn stock_antminers_are_supported_only_on_the_zynq_7010_board() {
let stock = |cpu: &str, code: &str| MinerRow {
brand: "Antminer".into(),
firmware: "Stock".into(),
cpu: cpu.into(),
board_code: code.into(),
..Default::default()
};
let s17 = stock("XIL", "C49");
assert!(install_supported(&s17));
assert!(!is_alkane(&s17));
assert!(!install_supported(&stock("XIL", "C55"))); // S19-era Zynq
assert!(!install_supported(&stock("AML", "C76")));
assert!(!install_supported(&stock("", "")));
let whatsminer = MinerRow {
brand: "WhatsMiner".into(),
cpu: "XIL".into(),
board_code: "C49".into(),
..Default::default()
};
assert!(!install_supported(&whatsminer));
}
#[test]
fn a_stock_s17_without_a_reported_control_board_is_supported_by_model() {
// As seen live: stock S17, miner software down, control board blank.
let s17 = MinerRow {
brand: "Antminer".into(),
model: "S17".into(),
firmware: "Stock".into(),
..Default::default()
};
assert!(install_supported(&s17));
let other = |model: &str| MinerRow {
brand: "Antminer".into(),
model: model.into(),
..Default::default()
};
assert!(install_supported(&other("S17 Pro")));
assert!(install_supported(&other("T17")));
assert!(!install_supported(&other("S19")));
assert!(!install_supported(&other("S17+")));
assert!(!install_supported(&other("")));
// A reported control board overrides the model.
let s17_on_aml = MinerRow {
brand: "Antminer".into(),
model: "S17".into(),
cpu: "AML".into(),
board_code: "C76".into(),
..Default::default()
};
assert!(!install_supported(&s17_on_aml));
}
/// Live check against a real board:
/// `ALKANE_TEST_IP=10.255.1.111 cargo test -p alkane-gui live_detect -- --ignored --nocapture`
#[test]
#[ignore = "needs a board on the network (ALKANE_TEST_IP)"]
fn live_detect() {
let Ok(ip) = std::env::var("ALKANE_TEST_IP") else {
return;
};
let rt = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.unwrap();
let row = rt.block_on(detect(ip.parse().unwrap()));
println!("{row:#?}");
let row = row.expect("an Alkane board at ALKANE_TEST_IP");
assert!(is_alkane(&row));
}
}
+122
View File
@@ -0,0 +1,122 @@
//! Non-interactive SSH password logins without `sshpass`.
//!
//! OpenSSH (Linux, and the `ssh.exe` built into Windows 10/11) asks the
//! program named by `SSH_ASKPASS` for a password when `SSH_ASKPASS_REQUIRE=force`
//! (OpenSSH 8.4+). The toolkit names its own executable: when ssh runs it with
//! [`ROLE_ENV`] set, `main()` calls [`serve_if_askpass`] first thing, which
//! prints the password from [`SECRET_ENV`] and exits before any GUI starts.
//!
//! This replaces `sshpass`, which Windows does not have, with one mechanism for
//! every platform. Like `sshpass -e` the password travels in the child's
//! environment, never on a command line where the process list would show it.
use std::ffi::OsStr;
use std::process::{Command, Stdio};
/// Set (to "1") in the environment of an ssh child whose askpass helper is us.
pub const ROLE_ENV: &str = "ALKANE_SSH_ASKPASS";
/// The password the askpass helper hands back to ssh.
pub const SECRET_ENV: &str = "ALKANE_SSH_SECRET";
/// If this process is ssh's askpass helper, answer the prompt and return the
/// exit code to use; otherwise `None` and the app starts normally.
pub fn serve_if_askpass() -> Option<i32> {
std::env::var_os(ROLE_ENV)?;
let prompt = std::env::args_os().nth(1).unwrap_or_default();
Some(answer(&prompt, std::env::var_os(SECRET_ENV).as_deref()))
}
/// Print the secret for a password prompt. Anything else ssh might ask through
/// askpass (a host-key "yes/no" confirmation, a passphrase for a key we never
/// configured) is refused, so a changed prompt can never be answered with the
/// password by accident.
fn answer(prompt: &OsStr, secret: Option<&OsStr>) -> i32 {
let Some(secret) = secret else { return 1 };
if !is_password_prompt(&prompt.to_string_lossy()) {
return 1;
}
use std::io::Write;
let mut out = std::io::stdout().lock();
if out
.write_all(secret.to_string_lossy().as_bytes())
.and_then(|_| out.write_all(b"\n"))
.and_then(|_| out.flush())
.is_err()
{
return 1;
}
0
}
fn is_password_prompt(prompt: &str) -> bool {
let p = prompt.to_ascii_lowercase();
p.contains("password") && !p.contains("yes/no")
}
/// Configure an `ssh` command to log in with `password` and never block on a
/// terminal prompt. ssh tries password (and keyboard-interactive) auth once;
/// a wrong password fails fast with "Permission denied" instead of hanging.
pub fn ssh_with_password(cmd: &mut Command, password: &str) -> Result<(), String> {
let exe = std::env::current_exe().map_err(|e| format!("locate askpass helper: {e}"))?;
cmd.env("SSH_ASKPASS", exe)
.env("SSH_ASKPASS_REQUIRE", "force")
.env(ROLE_ENV, "1")
.env(SECRET_ENV, password)
.stdin(Stdio::null());
Ok(())
}
/// ssh `-o` options that go with [`ssh_with_password`].
pub const PASSWORD_AUTH_OPTIONS: [&str; 4] = [
"-o",
"PreferredAuthentications=password,keyboard-interactive",
"-o",
"NumberOfPasswordPrompts=1",
];
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn only_password_prompts_are_answered() {
assert!(is_password_prompt("root@10.0.0.1's password: "));
assert!(is_password_prompt("Password:"));
assert!(!is_password_prompt(
"Are you sure you want to continue connecting (yes/no/[fingerprint])?"
));
assert!(!is_password_prompt(
"Enter passphrase for key '/x/id_ed25519':"
));
assert_eq!(
answer(OsStr::new("Password:"), None),
1,
"no secret -> refuse"
);
assert_eq!(
answer(OsStr::new("Continue (yes/no)?"), Some(OsStr::new("pw"))),
1
);
}
#[test]
fn ssh_command_gets_askpass_environment() {
let mut cmd = Command::new("ssh");
ssh_with_password(&mut cmd, "hunter2").unwrap();
let env: std::collections::HashMap<_, _> = cmd
.get_envs()
.map(|(k, v)| (k.to_owned(), v.map(|v| v.to_owned())))
.collect();
assert_eq!(
env[OsStr::new("SSH_ASKPASS_REQUIRE")].as_deref(),
Some(OsStr::new("force"))
);
assert_eq!(
env[OsStr::new(SECRET_ENV)].as_deref(),
Some(OsStr::new("hunter2"))
);
assert!(env[OsStr::new("SSH_ASKPASS")].is_some());
// The password is never an argument.
assert!(cmd.get_args().all(|a| a != "hunter2"));
}
}
+29 -12
View File
@@ -19,18 +19,19 @@
//! ALKANE_PROBE_USER / ALKANE_PROBE_PASS if set (so a test can authenticate
//! without touching the app's saved config).
use asic_rs::MinerFactory;
use asic_rs::core::traits::miner::MinerAuth;
use asic_rs::MinerFactory;
use futures_util::StreamExt;
use measurements::Power;
fn load_creds() -> Option<(String, String)> {
if let (Ok(u), Ok(pw)) = (std::env::var("ALKANE_PROBE_USER"), std::env::var("ALKANE_PROBE_PASS")) {
if let (Ok(u), Ok(pw)) = (
std::env::var("ALKANE_PROBE_USER"),
std::env::var("ALKANE_PROBE_PASS"),
) {
return Some((u, pw));
}
let home = std::env::var("HOME").ok()?;
let p = std::path::PathBuf::from(home)
.join(".config/alkane-toolkit/scan-credentials.txt");
let p = alkane_core::platform::config_path("scan-credentials.txt");
let s = std::fs::read_to_string(p).ok()?;
let mut l = s.lines();
let u = l.next()?.to_string();
@@ -92,8 +93,14 @@ async fn scan(cidrs: &[String]) {
.map(|c| c.to_string())
.unwrap_or_default();
let fw_ver = data.firmware_version.clone().unwrap_or_default();
let bs = data.best_share.map(|v| format!("{v:.0}")).unwrap_or_default();
let sbs = data.session_best_share.map(|v| format!("{v:.0}")).unwrap_or_default();
let bs = data
.best_share
.map(|v| format!("{v:.0}"))
.unwrap_or_default();
let sbs = data
.session_best_share
.map(|v| format!("{v:.0}"))
.unwrap_or_default();
println!(
"{ip}\t{}\t{}\t{}\t{}\t{}\t{watts:.0}\t{}\t{}\t{bs}\t{sbs}",
data.device_info.make,
@@ -281,7 +288,10 @@ async fn msgs(ip_s: &str) {
Ok(Some(m)) => {
let d = m.get_data().await;
let th = |h: &Option<asic_rs::core::data::hashrate::HashRate>| {
h.clone().map(|x| x.as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash).value)
h.clone().map(|x| {
x.as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash)
.value
})
};
println!(
"{ip}: {} {} hashboards={:?} expected={:?}",
@@ -389,7 +399,7 @@ async fn lifecycle(ip_s: &str, verb: &str) {
/// Read (no tz arg) or set the miner's timezone (round 16 / G10). Capability-gated.
async fn timezone(ip_s: &str, tz: Option<&str>) {
use asic_rs::core::config::timezone::{Tz, TimezoneConfig};
use asic_rs::core::config::timezone::{TimezoneConfig, Tz};
let Ok(ip) = ip_s.parse::<std::net::IpAddr>() else {
eprintln!("bad ip {ip_s}");
return;
@@ -566,7 +576,9 @@ async fn settune(ip_s: &str, kind: &str, value: f64) {
TuningTarget::HashRate(hr)
}
None => {
eprintln!("miner reports no current hashrate; cannot build a hashrate target");
eprintln!(
"miner reports no current hashrate; cannot build a hashrate target"
);
return;
}
},
@@ -593,7 +605,9 @@ async fn settune(ip_s: &str, kind: &str, value: f64) {
}
} else if kind == "power" && m.supports_set_power_limit() {
match m.set_power_limit(Power::from_watts(value)).await {
Ok(v) => println!("set_power_limit({value} W) -> Ok({v}) [tuning_config unsupported]"),
Ok(v) => println!(
"set_power_limit({value} W) -> Ok({v}) [tuning_config unsupported]"
),
Err(e) => println!("set_power_limit({value} W) -> Err: {e:#}"),
}
} else {
@@ -680,7 +694,10 @@ async fn setpreset(ip_s: &str, name: &str) {
fn main() {
let args: Vec<String> = std::env::args().collect();
let rt = match tokio::runtime::Builder::new_current_thread().enable_all().build() {
let rt = match tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
{
Ok(rt) => rt,
Err(e) => {
eprintln!("tokio runtime: {e}");
+437
View File
@@ -0,0 +1,437 @@
//! Bug reports and feature requests from the toolbar's Bug report button.
//!
//! The app posts the report to the report relay (see tools/report-relay),
//! which holds the Gitea token and files the issue in blueflare/alkane-toolkit.
//! The app itself holds no secret. A report carries its type, the user's text,
//! what the app knows about itself (version, OS, appearance, language, window
//! size) and, if the user leaves it ticked, the recent activity log with
//! credentials scrubbed. Nothing is stored locally.
use std::io::Write;
use std::process::Stdio;
use std::sync::mpsc::{channel, Receiver};
/// Where reports go. `ALKANE_REPORT_URL` overrides it (tests, staging).
pub const DEFAULT_URL: &str = "https://gitea.bluefla.re/alkane-report/v1/report";
/// Longest report text the relay accepts.
pub const MAX_TEXT_CHARS: usize = 8000;
/// Log sent with a report: at most this many of the newest lines...
const LOG_LINES: usize = 80;
/// ...cut to this many bytes on a line boundary.
const LOG_BYTES: usize = 16 * 1024;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Kind {
Bug,
Ui,
Feature,
}
impl Kind {
/// In the order the dialog's type choice lists them.
pub const ALL: [Kind; 3] = [Kind::Bug, Kind::Ui, Kind::Feature];
pub fn label(self) -> &'static str {
match self {
Kind::Bug => "Bug",
Kind::Ui => "UI change",
Kind::Feature => "Feature request",
}
}
/// The wire value, which is also the issue label.
pub fn as_str(self) -> &'static str {
match self {
Kind::Bug => "bug",
Kind::Ui => "ui",
Kind::Feature => "feature",
}
}
}
/// What the app knows about itself, sent with every report.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Context {
pub app_version: String,
pub platform: String,
pub os: String,
pub appearance: String,
pub language: String,
pub window: String,
}
impl Context {
/// The running app's context. `window` is the main window's size.
pub fn current(dark: bool, language: &str, window: (i32, i32)) -> Context {
Context {
app_version: env!("CARGO_PKG_VERSION").to_string(),
platform: format!("{}-{}", std::env::consts::OS, std::env::consts::ARCH),
os: os_version(),
appearance: if dark { "dark" } else { "light" }.to_string(),
language: language.to_string(),
window: format!("{}x{}", window.0, window.1),
}
}
}
/// A human-readable OS name and version, best effort.
fn os_version() -> String {
#[cfg(target_os = "linux")]
{
if let Ok(s) = std::fs::read_to_string("/etc/os-release") {
for line in s.lines() {
if let Some(v) = line.strip_prefix("PRETTY_NAME=") {
return v.trim_matches('"').to_string();
}
}
}
"Linux".to_string()
}
#[cfg(target_os = "macos")]
{
let out = alkane_core::platform::quiet_command("sw_vers")
.arg("-productVersion")
.output();
match out {
Ok(o) if o.status.success() => {
format!("macOS {}", String::from_utf8_lossy(&o.stdout).trim())
}
_ => "macOS".to_string(),
}
}
#[cfg(windows)]
{
let out = alkane_core::platform::quiet_command("cmd")
.args(["/C", "ver"])
.output();
match out {
Ok(o) if o.status.success() => {
let v = String::from_utf8_lossy(&o.stdout).trim().to_string();
if v.is_empty() {
"Windows".to_string()
} else {
v
}
}
_ => "Windows".to_string(),
}
}
#[cfg(not(any(target_os = "linux", target_os = "macos", windows)))]
{
std::env::consts::OS.to_string()
}
}
/// Names whose values are secrets: `name=value`, `name: value` and
/// `"name": "value"` have the value replaced.
const SECRET_NAMES: [&str; 12] = [
"password",
"passwd",
"pass",
"pwd",
"secret",
"token",
"apikey",
"api_key",
"authorization",
"cookie",
"psk",
"credential",
];
/// Remove credentials from log text before it leaves the machine: values of
/// secret-looking names, `user:password@` in URLs, and PEM private keys.
/// What is removed becomes `[redacted]`.
pub fn scrub(text: &str) -> String {
let mut out = Vec::new();
let mut in_pem = false;
for line in text.lines() {
if line.contains("-----BEGIN") && line.contains("PRIVATE KEY") {
in_pem = true;
out.push("[redacted]".to_string());
continue;
}
if in_pem {
if line.contains("-----END") {
in_pem = false;
}
continue;
}
out.push(scrub_line(line));
}
out.join("\n")
}
fn scrub_line(line: &str) -> String {
let mut s = scrub_url_userinfo(line);
let lower = s.to_ascii_lowercase();
// Walk every occurrence of every secret name; redact the value after the
// next `=` or `:` (quotes and spaces skipped) up to whitespace, a quote, a
// comma, `&` or `;`.
let mut cuts: Vec<(usize, usize)> = Vec::new();
for name in SECRET_NAMES {
let mut from = 0;
while let Some(pos) = lower[from..].find(name) {
let start = from + pos;
from = start + name.len();
let bytes = s.as_bytes();
let mut i = start + name.len();
// allow a closing quote and spaces between the name and the separator
while i < bytes.len() && (bytes[i] == b'"' || bytes[i] == b'\'' || bytes[i] == b' ') {
i += 1;
}
if i >= bytes.len() || (bytes[i] != b'=' && bytes[i] != b':') {
continue;
}
i += 1;
while i < bytes.len() && (bytes[i] == b' ' || bytes[i] == b'"' || bytes[i] == b'\'') {
i += 1;
}
let vstart = i;
if name == "authorization" || name == "cookie" {
// "Authorization: Bearer <token>", "Cookie: a=b; c=d": the whole
// rest of the line is the secret.
i = bytes.len();
}
while i < bytes.len()
&& !matches!(bytes[i], b' ' | b'"' | b'\'' | b',' | b'&' | b';' | b'\t')
{
i += 1;
}
if i > vstart {
cuts.push((vstart, i));
}
}
}
if cuts.is_empty() {
return s;
}
cuts.sort();
let mut merged: Vec<(usize, usize)> = Vec::new();
for (a, b) in cuts {
match merged.last_mut() {
Some(last) if a <= last.1 => last.1 = last.1.max(b),
_ => merged.push((a, b)),
}
}
for (a, b) in merged.into_iter().rev() {
if s.is_char_boundary(a) && s.is_char_boundary(b) {
s.replace_range(a..b, "[redacted]");
}
}
s
}
/// `scheme://user:password@host` -> `scheme://user:[redacted]@host`.
fn scrub_url_userinfo(line: &str) -> String {
let mut s = line.to_string();
let mut from = 0;
while let Some(p) = s[from..].find("://") {
let auth_start = from + p + 3;
let rest = &s[auth_start..];
let end = rest
.find(|c: char| c == '/' || c.is_whitespace())
.unwrap_or(rest.len());
let authority = &rest[..end];
if let Some(at) = authority.rfind('@') {
if let Some(colon) = authority[..at].find(':') {
let a = auth_start + colon + 1;
let b = auth_start + at;
s.replace_range(a..b, "[redacted]");
}
}
from = auth_start;
if from >= s.len() {
break;
}
}
s
}
/// The newest activity-log lines, scrubbed and cut to the size limits.
pub fn recent_log(full_log: &str) -> String {
let lines: Vec<&str> = full_log.lines().collect();
let tail = &lines[lines.len().saturating_sub(LOG_LINES)..];
let mut text = scrub(&tail.join("\n"));
if text.len() > LOG_BYTES {
let mut cut = text.len() - LOG_BYTES;
while !text.is_char_boundary(cut) {
cut += 1;
}
text = text[cut..].to_string();
if let Some(nl) = text.find('\n') {
text = text[nl + 1..].to_string();
}
}
text
}
/// The JSON body the relay takes.
pub fn payload(kind: Kind, text: &str, ctx: &Context, log: Option<&str>) -> String {
serde_json::json!({
"kind": kind.as_str(),
"text": text,
"app_version": ctx.app_version,
"platform": ctx.platform,
"os": ctx.os,
"appearance": ctx.appearance,
"language": ctx.language,
"window": ctx.window,
"log": log.unwrap_or(""),
})
.to_string()
}
/// A filed issue: its number and web link.
#[derive(Clone, Debug, PartialEq)]
pub struct Filed {
pub number: u64,
pub url: String,
}
/// Read the relay's answer: curl's body, then the HTTP status on the last line.
pub fn parse_response(curl_stdout: &str) -> Result<Filed, String> {
let trimmed = curl_stdout.trim_end();
let (body, code) = match trimmed.rfind('\n') {
Some(i) => (&trimmed[..i], trimmed[i + 1..].trim()),
None => ("", trimmed),
};
let json: Option<serde_json::Value> = serde_json::from_str(body).ok();
if code == "201" || code == "200" {
let number = json.as_ref().and_then(|j| j["number"].as_u64());
let url = json.as_ref().and_then(|j| j["url"].as_str()).unwrap_or("");
return match number {
Some(number) => Ok(Filed {
number,
url: url.to_string(),
}),
None => Err("the report service answered without an issue number; \
check the issue list before sending again"
.into()),
};
}
let reason = json
.as_ref()
.and_then(|j| j["error"].as_str())
.map(str::to_string);
Err(match (code, reason) {
(_, Some(r)) => r,
("000", None) | ("", None) => "could not reach the report service".into(),
(c, None) => format!("the report service answered HTTP {c}"),
})
}
/// Send a report on a worker thread; the receiver gets one result.
pub fn send(body: String) -> Receiver<Result<Filed, String>> {
let url = std::env::var("ALKANE_REPORT_URL").unwrap_or_else(|_| DEFAULT_URL.to_string());
let (tx, rx) = channel();
std::thread::spawn(move || {
let result = (|| {
let mut child = alkane_core::platform::quiet_command("curl")
.args([
"-sS",
"--max-time",
"40",
"-X",
"POST",
"-H",
"Content-Type: application/json",
"--data-binary",
"@-",
"-w",
"\n%{http_code}",
&url,
])
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.map_err(|e| format!("could not run curl: {e}"))?;
if let Some(mut si) = child.stdin.take() {
let _ = si.write_all(body.as_bytes());
}
let out = child
.wait_with_output()
.map_err(|e| format!("curl failed: {e}"))?;
parse_response(&String::from_utf8_lossy(&out.stdout))
})();
let _ = tx.send(result);
});
rx
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn scrub_removes_credentials_and_keeps_the_rest() {
let log = "12:00:01 set pools on 192.168.1.20: url=stratum+tcp://u:hunter2@pool:3333 password=hunter2\n\
12:00:02 login {\"user\": \"root\", \"pass\": \"s3cret\"}\n\
12:00:03 Authorization: Bearer abc.def\n\
-----BEGIN OPENSSH PRIVATE KEY-----\nAAAA\n-----END OPENSSH PRIVATE KEY-----\n\
12:00:04 scan finished: 9 miners";
let s = scrub(log);
assert!(!s.contains("hunter2"), "{s}");
assert!(!s.contains("s3cret"), "{s}");
assert!(!s.contains("abc.def"), "{s}");
assert!(!s.contains("AAAA"), "{s}");
assert!(s.contains("192.168.1.20"));
assert!(s.contains("\"user\": \"root\""));
assert!(s.contains("scan finished: 9 miners"));
assert_eq!(s.matches("[redacted]").count(), 5, "{s}");
}
#[test]
fn recent_log_keeps_the_newest_lines_within_limits() {
let log: Vec<String> = (0..500)
.map(|i| format!("line {i} {}", "x".repeat(300)))
.collect();
let tail = recent_log(&log.join("\n"));
assert!(tail.len() <= LOG_BYTES);
assert!(tail.ends_with(&log[499]));
assert!(tail.starts_with("line "), "cut on a line boundary");
assert!(!tail.contains("line 400 "), "only the newest lines");
}
#[test]
fn payload_carries_kind_text_and_context() {
let ctx = Context {
app_version: "1.2.3".into(),
platform: "macos-aarch64".into(),
os: "macOS 15.1".into(),
appearance: "dark".into(),
language: "en".into(),
window: "1280x800".into(),
};
let v: serde_json::Value =
serde_json::from_str(&payload(Kind::Ui, "Text \"quoted\"", &ctx, None)).unwrap();
assert_eq!(v["kind"], "ui");
assert_eq!(v["text"], "Text \"quoted\"");
assert_eq!(v["app_version"], "1.2.3");
assert_eq!(v["log"], "");
}
#[test]
fn response_parsing() {
assert_eq!(
parse_response("{\"number\":42,\"url\":\"https://x/42\"}\n201"),
Ok(Filed {
number: 42,
url: "https://x/42".into()
})
);
assert_eq!(
parse_response("{\"error\":\"Too many reports; try again later\"}\n429"),
Err("Too many reports; try again later".into())
);
assert_eq!(
parse_response("\n000"),
Err("could not reach the report service".into())
);
assert_eq!(
parse_response("<html>\n502"),
Err("the report service answered HTTP 502".into())
);
}
}
+115 -56
View File
@@ -6,11 +6,11 @@
//! firmware registry, so `scan`'s callers never have to think about it.
use std::collections::HashMap;
use std::io::Write;
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
use asic_rs::MinerFactory;
use alkane_core::platform::write_private;
use asic_rs::core::traits::miner::MinerAuth;
use asic_rs::MinerFactory;
use crate::scan::config_path;
@@ -40,20 +40,9 @@ fn save_creds_file(file: &str, user: &str, pass: &str) -> std::io::Result<()> {
if let Some(dir) = p.parent() {
std::fs::create_dir_all(dir)?;
}
// Open (and create) with mode 0600 up front so a freshly created file is
// never world/group-readable, even for the instant before the write. For a
// pre-existing file the create mode is ignored, so also tighten it to 0600
// while it is still empty (post-truncate, pre-write) -- the plaintext is
// never on disk under a looser mode.
let mut f = std::fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.mode(0o600)
.open(&p)?;
f.set_permissions(std::fs::Permissions::from_mode(0o600))?;
f.write_all(format!("{user}\n{pass}\n").as_bytes())?;
Ok(())
// Owner-only from creation on (0600 on Unix, re-tightened if the file
// already existed): the plaintext is never on disk under a looser mode.
write_private(&p, format!("{user}\n{pass}\n").as_bytes())
}
fn clear_creds_file(file: &str) -> std::io::Result<()> {
@@ -80,13 +69,26 @@ pub fn load_ssh_credentials() -> Option<(String, String)> {
load_creds_file(SSH_CREDENTIALS_FILE)
}
/// Save the SSH username/password (0600). Retained for a future SSH-login dialog
/// now that the SSH PIC probe that used to save it has been removed (round 14 #5).
#[allow(dead_code)]
/// Save the SSH username/password (0600), from the Credentials dialog.
pub fn save_ssh_credentials(user: &str, pass: &str) -> std::io::Result<()> {
save_creds_file(SSH_CREDENTIALS_FILE, user, pass)
}
/// Remove the saved SSH login, if any. Not an error if none was saved.
pub fn clear_ssh_credentials() -> std::io::Result<()> {
clear_creds_file(SSH_CREDENTIALS_FILE)
}
/// The SSH username to use: the saved one, or `root` (the control-board login
/// on every firmware the restore flow drives over SSH) when none was entered.
pub fn ssh_user_or_default(user: &str) -> String {
if user.trim().is_empty() {
"root".to_string()
} else {
user.trim().to_string()
}
}
/// Remove the saved web/API credentials, if any. Not an error if none were saved.
pub fn clear_credentials() -> std::io::Result<()> {
match clear_creds_file(CREDENTIALS_FILE) {
@@ -164,20 +166,14 @@ pub fn save_firmware_credentials(map: &HashMap<String, (String, String)>) -> std
if let Some(dir) = p.parent() {
std::fs::create_dir_all(dir)?;
}
let mut f = std::fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.mode(0o600)
.open(&p)?;
f.set_permissions(std::fs::Permissions::from_mode(0o600))?;
let mut names: Vec<&String> = map.keys().collect();
names.sort();
let mut body = String::new();
for name in names {
let (user, pass) = &map[name];
f.write_all(format!("{name}\t{user}\t{pass}\n").as_bytes())?;
body.push_str(&format!("{name}\t{user}\t{pass}\n"));
}
Ok(())
write_private(&p, body.as_bytes())
}
/// Remove the per-firmware overrides file, if any. Not an error if none exists.
@@ -195,8 +191,8 @@ pub fn configured_factory() -> MinerFactory {
// (round 18 #12: config actions / refresh / pools / flash previously used
// asic-rs's 10s default, so on a slow link they could fail to reach miners a
// longer-timeout scan had found). start_scan may still override it explicitly.
let mut factory =
MinerFactory::new().with_identification_timeout_secs(crate::scan::load_scan_timeout().max(1));
let mut factory = MinerFactory::new()
.with_identification_timeout_secs(crate::scan::load_scan_timeout().max(1));
let global = load_credentials();
let per_fw = load_firmware_credentials();
if global.is_none() && per_fw.is_empty() {
@@ -218,25 +214,47 @@ pub fn configured_factory() -> MinerFactory {
mod tests {
use super::*;
/// Unix: the file is mode 0600. Windows relies on the profile directory's
/// owner-only ACL (see `alkane_core::platform::write_private`), so only
/// existence is checked there.
fn assert_owner_only(path: &std::path::Path, why: &str) {
let meta = std::fs::metadata(path).unwrap();
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
assert_eq!(meta.permissions().mode() & 0o777, 0o600, "{why}");
}
#[cfg(not(unix))]
assert!(meta.is_file(), "{why}");
}
#[test]
fn credentials_round_trip_and_file_perms() {
// config_path() reads $HOME; point it at a private temp dir. HOME is
// process-global, so serialise against other HOME-mutating tests via the
// shared lock and restore HOME afterward (round 18 #12).
let _home = crate::model::HOME_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
let prev = std::env::var_os("HOME");
let _home = crate::model::HOME_TEST_LOCK
.lock()
.unwrap_or_else(|e| e.into_inner());
let root_var = alkane_core::platform::CONFIG_ROOT_VAR;
let prev = std::env::var_os(root_var);
let dir = std::env::temp_dir().join(format!("alkane-cred-test-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
std::env::set_var("HOME", &dir);
std::env::set_var(root_var, &dir);
assert_eq!(load_credentials(), None, "no file -> None");
save_credentials("admin", "hunter2").unwrap();
assert_eq!(load_credentials(), Some(("admin".to_string(), "hunter2".to_string())));
assert_eq!(
load_credentials(),
Some(("admin".to_string(), "hunter2".to_string()))
);
let meta = std::fs::metadata(config_path(CREDENTIALS_FILE)).unwrap();
assert_eq!(meta.permissions().mode() & 0o777, 0o600, "credentials file must be 0600");
assert_owner_only(
&config_path(CREDENTIALS_FILE),
"credentials file must be 0600",
);
// configured_factory() must construct in both branches without panicking:
// with saved credentials (fans auth across every firmware backend) ...
@@ -246,15 +264,20 @@ mod tests {
// 0600 by save_credentials (the create-mode is ignored for an existing
// file, so the explicit set_permissions is what protects it).
let path = config_path(CREDENTIALS_FILE);
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o644)).unwrap();
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o644)).unwrap();
}
save_credentials("admin2", "s3cr3t").unwrap();
let meta = std::fs::metadata(&path).unwrap();
assert_owner_only(
&path,
"save over a pre-existing 0644 file must re-tighten to 0600",
);
assert_eq!(
meta.permissions().mode() & 0o777,
0o600,
"save over a pre-existing 0644 file must re-tighten to 0600"
load_credentials(),
Some(("admin2".to_string(), "s3cr3t".to_string()))
);
assert_eq!(load_credentials(), Some(("admin2".to_string(), "s3cr3t".to_string())));
clear_credentials().unwrap();
// ... and with no saved credentials (plain MinerFactory::new()).
@@ -262,38 +285,74 @@ mod tests {
assert_eq!(load_credentials(), None, "cleared -> None");
clear_credentials().unwrap(); // idempotent: clearing an already-clear store is not an error
// SSH login: separate file, same 0600 rule, clear is idempotent.
assert_eq!(load_ssh_credentials(), None, "no SSH file -> None");
save_ssh_credentials("root", "ssh-pass").unwrap();
assert_owner_only(
&config_path(SSH_CREDENTIALS_FILE),
"SSH creds file must be 0600",
);
assert_eq!(
load_ssh_credentials(),
Some(("root".to_string(), "ssh-pass".to_string()))
);
assert_eq!(
load_credentials(),
None,
"SSH save leaves the web login alone"
);
clear_ssh_credentials().unwrap();
assert_eq!(load_ssh_credentials(), None, "cleared -> None");
clear_ssh_credentials().unwrap();
assert_eq!(ssh_user_or_default(""), "root");
assert_eq!(ssh_user_or_default(" admin "), "admin");
// Per-firmware overrides (round 12 #13). Kept in this same test because
// HOME is process-global: a second #[test] mutating it would race under
// cargo's default parallel runner.
assert!(load_firmware_credentials().is_empty(), "no file -> empty map");
assert!(
load_firmware_credentials().is_empty(),
"no file -> empty map"
);
let mut fw = HashMap::new();
fw.insert("WhatsMiner Stock".to_string(), ("super".to_string(), "sup3r".to_string()));
fw.insert(
"WhatsMiner Stock".to_string(),
("super".to_string(), "sup3r".to_string()),
);
fw.insert("VNish".to_string(), ("".to_string(), "hunter2".to_string()));
save_firmware_credentials(&fw).unwrap();
// 0600, and it round-trips (an empty username survives the tab format).
let fwpath = config_path(FIRMWARE_CREDENTIALS_FILE);
assert_eq!(
std::fs::metadata(&fwpath).unwrap().permissions().mode() & 0o777,
0o600,
"per-firmware creds file must be 0600"
);
assert_owner_only(&fwpath, "per-firmware creds file must be 0600");
let back = load_firmware_credentials();
assert_eq!(back.get("WhatsMiner Stock"), Some(&("super".into(), "sup3r".into())));
assert_eq!(
back.get("WhatsMiner Stock"),
Some(&("super".into(), "sup3r".into()))
);
assert_eq!(back.get("VNish"), Some(&("".into(), "hunter2".into())));
assert_eq!(back.len(), 2);
// Shipped-default lookup: known firmware resolves, unknown blanks.
assert_eq!(firmware_default_for("AntMiner Stock"), ("root".into(), "root".into()));
assert_eq!(firmware_default_for("nonexistent"), (String::new(), String::new()));
assert_eq!(
firmware_default_for("AntMiner Stock"),
("root".into(), "root".into())
);
assert_eq!(
firmware_default_for("nonexistent"),
(String::new(), String::new())
);
// Overrides + no global still builds a factory.
let _ = configured_factory();
// Saving an empty map clears the file (no stale overrides linger).
save_firmware_credentials(&HashMap::new()).unwrap();
assert!(load_firmware_credentials().is_empty(), "empty save -> cleared");
assert!(
load_firmware_credentials().is_empty(),
"empty save -> cleared"
);
clear_firmware_credentials().unwrap(); // idempotent
match prev {
Some(v) => std::env::set_var("HOME", v),
None => std::env::remove_var("HOME"),
Some(v) => std::env::set_var(root_var, v),
None => std::env::remove_var(root_var),
}
let _ = std::fs::remove_dir_all(&dir);
}
+77 -20
View File
@@ -100,28 +100,62 @@ fn scalar_columns() -> Vec<Col> {
("slow", |r| r.slow.to_string()),
("paused", |r| r.paused.to_string()),
("pic", |r| opt_bool(r.pic_present, "PIC", "noPIC")),
("write_locked", |r| opt_bool(r.write_locked, "locked", "unlocked")),
("light_flashing", |r| opt_bool(r.light_flashing, "on", "off")),
("write_locked", |r| {
opt_bool(r.write_locked, "locked", "unlocked")
}),
("light_flashing", |r| {
opt_bool(r.light_flashing, "on", "off")
}),
("hashrate_ths", |r| num(r.hashrate_ths)),
("expected_ths", |r| num(r.expected_ths)),
("efficiency_j_th", |r| num(r.efficiency)),
("power_w", |r| num(r.power_w)),
("tuning_percent", |r| r.tuning_percent.map(|v| v.to_string()).unwrap_or_default()),
("tuning_percent", |r| {
r.tuning_percent.map(|v| v.to_string()).unwrap_or_default()
}),
("chip_temp_c", |r| num(r.chip_temp_c)),
("fluid_temp_c", |r| num(r.fluid_temp_c)),
("env_temp_c", |r| num(r.env_temp_c)),
("outlet_temp_c", |r| num(r.outlet_temp_c)),
("psu_fan_rpm", |r| num(r.psu_fan_rpm)),
("fan_count", |r| r.fan_count.map(|v| v.to_string()).unwrap_or_default()),
("expected_fans", |r| r.expected_fans.map(|v| v.to_string()).unwrap_or_default()),
("total_chips", |r| r.total_chips.map(|v| v.to_string()).unwrap_or_default()),
("expected_chips", |r| r.expected_chips.map(|v| v.to_string()).unwrap_or_default()),
("hashboards", |r| r.hashboards.map(|v| v.to_string()).unwrap_or_default()),
("expected_hashboards", |r| r.expected_hashboards.map(|v| v.to_string()).unwrap_or_default()),
("uptime_secs", |r| if r.uptime_secs > 0 { r.uptime_secs.to_string() } else { String::new() }),
("fan_count", |r| {
r.fan_count.map(|v| v.to_string()).unwrap_or_default()
}),
("expected_fans", |r| {
r.expected_fans.map(|v| v.to_string()).unwrap_or_default()
}),
("total_chips", |r| {
r.total_chips.map(|v| v.to_string()).unwrap_or_default()
}),
("expected_chips", |r| {
r.expected_chips.map(|v| v.to_string()).unwrap_or_default()
}),
("hashboards", |r| {
r.hashboards.map(|v| v.to_string()).unwrap_or_default()
}),
("expected_hashboards", |r| {
r.expected_hashboards
.map(|v| v.to_string())
.unwrap_or_default()
}),
("uptime_secs", |r| {
if r.uptime_secs > 0 {
r.uptime_secs.to_string()
} else {
String::new()
}
}),
("best_share", |r| r.best_share.map(num).unwrap_or_default()),
("session_best_share", |r| r.session_best_share.map(num).unwrap_or_default()),
("pool_account", |r| r.worker.split_once('.').map(|(a, _)| a).unwrap_or(&r.worker).to_string()),
("session_best_share", |r| {
r.session_best_share.map(num).unwrap_or_default()
}),
("pool_account", |r| {
r.worker
.split_once('.')
.map(|(a, _)| a)
.unwrap_or(&r.worker)
.to_string()
}),
("pool_url", |r| r.pool_url.clone()),
("errors", |r| r.errors.join("; ")),
]
@@ -137,7 +171,10 @@ pub const GROUP_POOLS: &str = "pools";
/// Every selectable export field, in output order: each scalar column header,
/// then the four variable-length group keys.
pub fn export_field_names() -> Vec<String> {
let mut v: Vec<String> = scalar_columns().iter().map(|(h, _)| (*h).to_string()).collect();
let mut v: Vec<String> = scalar_columns()
.iter()
.map(|(h, _)| (*h).to_string())
.collect();
v.push(GROUP_BOARD_TEMPS.to_string());
v.push(GROUP_FANS.to_string());
v.push(GROUP_BOARD_STATUS.to_string());
@@ -152,16 +189,26 @@ pub fn rows_to_csv_selected(
rows: &[MinerRow],
selected: &std::collections::HashSet<String>,
) -> String {
let cols: Vec<Col> =
scalar_columns().into_iter().filter(|(h, _)| selected.contains(*h)).collect();
let cols: Vec<Col> = scalar_columns()
.into_iter()
.filter(|(h, _)| selected.contains(*h))
.collect();
// A group's columns appear only when it is selected; an unselected group's
// width stays 0, so the header/value loops below emit nothing for it.
let width = |want: bool, f: &dyn Fn(&MinerRow) -> usize| -> usize {
if want { rows.iter().map(f).max().unwrap_or(0) } else { 0 }
if want {
rows.iter().map(f).max().unwrap_or(0)
} else {
0
}
};
let max_board_temps = width(selected.contains(GROUP_BOARD_TEMPS), &|r| r.board_temps.len());
let max_board_temps = width(selected.contains(GROUP_BOARD_TEMPS), &|r| {
r.board_temps.len()
});
let max_fans = width(selected.contains(GROUP_FANS), &|r| r.fan_rpms.len());
let max_boards = width(selected.contains(GROUP_BOARD_STATUS), &|r| r.board_status.len());
let max_boards = width(selected.contains(GROUP_BOARD_STATUS), &|r| {
r.board_status.len()
});
let max_pools = width(selected.contains(GROUP_POOLS), &|r| r.pools.len());
// Header.
@@ -193,7 +240,13 @@ pub fn rows_to_csv_selected(
vals.push(r.fan_rpms.get(i).map(|&t| num(t)).unwrap_or_default());
}
for i in 0..max_boards {
vals.push(r.board_status.get(i).map(board_health_str).unwrap_or("").to_string());
vals.push(
r.board_status
.get(i)
.map(board_health_str)
.unwrap_or("")
.to_string(),
);
}
for i in 0..max_pools {
let (u, w) = r.pools.get(i).cloned().unwrap_or_default();
@@ -222,7 +275,11 @@ mod tests {
fan_rpms: vec![6000.0, 6100.0],
..Default::default()
},
MinerRow { ip: "10.0.0.2".into(), model: "M30S".into(), ..Default::default() },
MinerRow {
ip: "10.0.0.2".into(),
model: "M30S".into(),
..Default::default()
},
];
let all: std::collections::HashSet<String> = export_field_names().into_iter().collect();
let csv = rows_to_csv_selected(&rows, &all);
+206 -42
View File
@@ -1,6 +1,6 @@
//! Bench-fleet fixtures: the expected hardware output of the 9 boards on
//! 10.255.1.0/24 (see ../../../HANDOFF.md section 7 and the parent project's
//! [removed]). These are the reference values the workflow tests compare
//! Fixture fleet: the expected hardware output of nine representative miners
//! (one per control-board family / firmware). These are the reference values
//! the workflow tests compare
//! the application's actual output against, and the rows the offline
//! `ALKANE_FAKE_SCAN` demo mode renders. Only miners that respond become rows,
//! so there is no synthetic "offline" fixture.
@@ -42,9 +42,22 @@ impl Board {
let slow = is_slow(self.mining, self.hashrate, self.expected);
// A few extra metrics so the demo/offline mode shows non-empty values
// for some of the additional columns.
let last_octet: u8 = self.ip.rsplit('.').next().and_then(|s| s.parse().ok()).unwrap_or(0);
let last_octet: u8 = self
.ip
.rsplit('.')
.next()
.and_then(|s| s.parse().ok())
.unwrap_or(0);
let (boards, chips, efficiency) = if self.mining {
(Some(3u32), Some(210u32), if self.hashrate > 0.0 { self.power / self.hashrate } else { 0.0 })
(
Some(3u32),
Some(210u32),
if self.hashrate > 0.0 {
self.power / self.hashrate
} else {
0.0
},
)
} else {
(None, None, 0.0)
};
@@ -63,7 +76,11 @@ impl Board {
// Per-board hashrate for the R2 Health tooltip demo: split the total three
// ways with a little variety (index-aligned with the 3 boards).
let board_hashrates = if self.mining && self.hashrate > 0.0 {
vec![self.hashrate * 0.34, self.hashrate * 0.35, self.hashrate * 0.31]
vec![
self.hashrate * 0.34,
self.hashrate * 0.35,
self.hashrate * 0.31,
]
} else {
vec![]
};
@@ -147,7 +164,10 @@ impl Board {
slow,
paused: self.paused,
// offline defaults to false (online); these bench rows are reachable.
mac: format!("AA:BB:CC:00:{:02X}:{last_octet:02X}", last_octet.wrapping_mul(3)),
mac: format!(
"AA:BB:CC:00:{:02X}:{last_octet:02X}",
last_octet.wrapping_mul(3)
),
hostname: format!("miner-{last_octet}"),
hashboards: boards,
expected_hashboards: Some(3),
@@ -156,22 +176,40 @@ impl Board {
psu_fan_rpm: if self.mining { self.fan * 0.9 } else { 0.0 },
// PSU info demo (round 17 R5): mining units show a version + rated
// envelope + live output, so the columns and the R2 PSU tooltip render.
psu_version: if self.mining { "22 (117)".to_string() } else { String::new() },
psu_version: if self.mining {
"22 (117)".to_string()
} else {
String::new()
},
psu_voltage_min_v: self.mining.then_some(11.88),
psu_voltage_max_v: self.mining.then_some(15.18),
psu_out_voltage_v: self.mining.then_some(13.2),
psu_out_current_a: self.mining.then_some(210.0),
uptime_secs: if self.mining { 3600 * 24 * 2 + 3600 * 5 } else { 0 },
uptime_secs: if self.mining {
3600 * 24 * 2 + 3600 * 5
} else {
0
},
// One unit is "being located" so the Light column's yellow dot is
// demonstrable offline (round 11 #10).
light_flashing: Some(self.ip == "10.255.1.167"),
pool_url: if self.worker.is_empty() { String::new() } else { "stratum+tcp://pool.blueflare:3333".to_string() },
pool_url: if self.worker.is_empty() {
String::new()
} else {
"stratum+tcp://pool.blueflare:3333".to_string()
},
pools: if self.worker.is_empty() {
Vec::new()
} else {
vec![
("stratum+tcp://pool.blueflare:3333".to_string(), self.worker.to_string()),
("stratum+tcp://backup.blueflare:3333".to_string(), format!("{}_bak", self.worker)),
(
"stratum+tcp://pool.blueflare:3333".to_string(),
self.worker.to_string(),
),
(
"stratum+tcp://backup.blueflare:3333".to_string(),
format!("{}_bak", self.worker),
),
]
},
operating_state: if self.paused {
@@ -223,9 +261,18 @@ impl Board {
// is exercisable offline on units that advertise preset support.
presets: if self.mining {
vec![
crate::model::MinerPreset { name: "default".into(), pretty: Some("2794 W ~ 121.8 TH @ 590 MHz".into()) },
crate::model::MinerPreset { name: "540MHz".into(), pretty: Some("2485 W ~ 111.5 TH @ 540 MHz".into()) },
crate::model::MinerPreset { name: "490MHz".into(), pretty: Some("2192 W ~ 101.1 TH @ 490 MHz".into()) },
crate::model::MinerPreset {
name: "default".into(),
pretty: Some("2794 W ~ 121.8 TH @ 590 MHz".into()),
},
crate::model::MinerPreset {
name: "540MHz".into(),
pretty: Some("2485 W ~ 111.5 TH @ 540 MHz".into()),
},
crate::model::MinerPreset {
name: "490MHz".into(),
pretty: Some("2192 W ~ 101.1 TH @ 490 MHz".into()),
},
]
} else {
Vec::new()
@@ -247,35 +294,152 @@ pub fn bench_fleet() -> Vec<MinerRow> {
let boards = [
// firmware families span the palette (Stock/VNish/Braiins/LuxOS/ePIC/
// Hive/BixBit/Alkane) so the offline demo shows the Firmware colouring.
Board { ip: "10.255.1.112", make: "Antminer", model_id: "S17", board: "Xilinx", firmware: "Stock", fw_version: "",
hashrate: 0.0, expected: 0.0, power: 0.0, temp: 0.0, fan: 0.0,
worker: "", mining: false, paused: false },
Board { ip: "10.255.1.166", make: "Antminer", model_id: "S19", board: "BeagleBoneBlack", firmware: "VNish", fw_version: "1.2.8",
hashrate: 95.0, expected: 96.0, power: 3250.0, temp: 65.0, fan: 4200.0,
worker: "blueflare.s19", mining: true, paused: false },
Board { ip: "10.255.1.152", make: "Antminer", model_id: "S19jPro", board: "AMLogic", firmware: "Braiins", fw_version: "25.05.1",
hashrate: 100.0, expected: 104.0, power: 3100.0, temp: 62.0, fan: 3900.0,
worker: "blueflare.s19jpro", mining: true, paused: false },
Board { ip: "10.255.1.167", make: "Antminer", model_id: "S19KPro", board: "AMLogic", firmware: "LuxOS", fw_version: "2024.9.0",
hashrate: 120.0, expected: 128.0, power: 3300.0, temp: 68.0, fan: 4500.0,
worker: "blueflare.s19kpro", mining: true, paused: false },
Board { ip: "10.255.1.149", make: "Antminer", model_id: "S21Pro", board: "CVITek", firmware: "ePIC", fw_version: "1.0.3",
hashrate: 60.0, expected: 200.0, power: 1500.0, temp: 55.0, fan: 3000.0,
worker: "blueflare.s21pro", mining: true, paused: false }, // slow: 60/200 = 30%
Board { ip: "10.255.1.126", make: "Whatsminer", model_id: "M30SVE40", board: "H3", firmware: "Stock", fw_version: "H3.0.1",
hashrate: 92.0, expected: 96.0, power: 3400.0, temp: 70.0, fan: 4800.0,
worker: "blueflare.h3", mining: true, paused: false },
Board { ip: "10.255.1.131", make: "Whatsminer", model_id: "M30SPlusVE40", board: "H616", firmware: "Hiveon", fw_version: "1.05",
hashrate: 100.0, expected: 100.0, power: 3450.0, temp: 71.0, fan: 4900.0,
worker: "blueflare.h616", mining: true, paused: false },
Board { ip: "10.255.1.148", make: "Whatsminer", model_id: "M50VH50", board: "H6", firmware: "Bixbit", fw_version: "0.9.9.4",
hashrate: 118.0, expected: 122.0, power: 3300.0, temp: 66.0, fan: 4600.0,
worker: "blueflare.m50", mining: true, paused: false },
Board {
ip: "10.255.1.112",
make: "Antminer",
model_id: "S17",
board: "Xilinx",
firmware: "Stock",
fw_version: "",
hashrate: 0.0,
expected: 0.0,
power: 0.0,
temp: 0.0,
fan: 0.0,
worker: "",
mining: false,
paused: false,
},
Board {
ip: "10.255.1.166",
make: "Antminer",
model_id: "S19",
board: "BeagleBoneBlack",
firmware: "VNish",
fw_version: "1.2.8",
hashrate: 95.0,
expected: 96.0,
power: 3250.0,
temp: 65.0,
fan: 4200.0,
worker: "blueflare.s19",
mining: true,
paused: false,
},
Board {
ip: "10.255.1.152",
make: "Antminer",
model_id: "S19jPro",
board: "AMLogic",
firmware: "Braiins",
fw_version: "25.05.1",
hashrate: 100.0,
expected: 104.0,
power: 3100.0,
temp: 62.0,
fan: 3900.0,
worker: "blueflare.s19jpro",
mining: true,
paused: false,
},
Board {
ip: "10.255.1.167",
make: "Antminer",
model_id: "S19KPro",
board: "AMLogic",
firmware: "LuxOS",
fw_version: "2024.9.0",
hashrate: 120.0,
expected: 128.0,
power: 3300.0,
temp: 68.0,
fan: 4500.0,
worker: "blueflare.s19kpro",
mining: true,
paused: false,
},
Board {
ip: "10.255.1.149",
make: "Antminer",
model_id: "S21Pro",
board: "CVITek",
firmware: "ePIC",
fw_version: "1.0.3",
hashrate: 60.0,
expected: 200.0,
power: 1500.0,
temp: 55.0,
fan: 3000.0,
worker: "blueflare.s21pro",
mining: true,
paused: false,
}, // slow: 60/200 = 30%
Board {
ip: "10.255.1.126",
make: "Whatsminer",
model_id: "M30SVE40",
board: "H3",
firmware: "Stock",
fw_version: "H3.0.1",
hashrate: 92.0,
expected: 96.0,
power: 3400.0,
temp: 70.0,
fan: 4800.0,
worker: "blueflare.h3",
mining: true,
paused: false,
},
Board {
ip: "10.255.1.131",
make: "Whatsminer",
model_id: "M30SPlusVE40",
board: "H616",
firmware: "Hiveon",
fw_version: "1.05",
hashrate: 100.0,
expected: 100.0,
power: 3450.0,
temp: 71.0,
fan: 4900.0,
worker: "blueflare.h616",
mining: true,
paused: false,
},
Board {
ip: "10.255.1.148",
make: "Whatsminer",
model_id: "M50VH50",
board: "H6",
firmware: "Bixbit",
fw_version: "0.9.9.4",
hashrate: 118.0,
expected: 122.0,
power: 3300.0,
temp: 66.0,
fan: 4600.0,
worker: "blueflare.m50",
mining: true,
paused: false,
},
// Rebucketed from idle/not-hashing to paused so the "paused"
// status/KPI bucket is exercisable in the fake-scan/offline demo.
Board { ip: "10.255.1.115", make: "Antminer", model_id: "S19", board: "BeagleBoneBlack", firmware: "Alkane", fw_version: "0.1",
hashrate: 0.0, expected: 0.0, power: 0.0, temp: 0.0, fan: 0.0,
worker: "", mining: false, paused: true },
Board {
ip: "10.255.1.115",
make: "Antminer",
model_id: "S19",
board: "BeagleBoneBlack",
firmware: "Alkane",
fw_version: "0.1",
hashrate: 0.0,
expected: 0.0,
power: 0.0,
temp: 0.0,
fan: 0.0,
worker: "",
mining: false,
paused: true,
},
];
boards.into_iter().map(Board::into_row).collect()
}
+10 -4
View File
@@ -27,14 +27,14 @@ impl Lang {
pub fn label(self) -> &'static str {
match self {
Lang::En => "English",
Lang::Zh => "\u{4e2d}\u{6587}", // 中文
Lang::Zh => "\u{4e2d}\u{6587}", // 中文
Lang::Ru => "\u{0420}\u{0443}\u{0441}\u{0441}\u{043a}\u{0438}\u{0439}", // Русский
Lang::Fr => "Fran\u{e7}ais",
Lang::Es => "Espa\u{f1}ol",
Lang::Pt => "Portugu\u{ea}s",
}
}
fn code(self) -> &'static str {
pub fn code(self) -> &'static str {
match self {
Lang::En => "en",
Lang::Zh => "zh",
@@ -71,8 +71,7 @@ static CURRENT: AtomicU8 = AtomicU8::new(0);
const LANG_FILE: &str = "language.txt";
fn config_path() -> PathBuf {
let home = std::env::var("HOME").unwrap_or_else(|_| ".".into());
PathBuf::from(home).join(".config/alkane-toolkit").join(LANG_FILE)
alkane_core::platform::config_path(LANG_FILE)
}
/// Load the saved language into the global (call once at startup).
@@ -138,6 +137,13 @@ const TABLE: &[(&str, [&str; 6])] = &[
("Credentials", ["Credentials", "\u{51ed}\u{636e}", "\u{0423}\u{0447}\u{0451}\u{0442}\u{043d}\u{044b}\u{0435} \u{0434}\u{0430}\u{043d}\u{043d}\u{044b}\u{0435}", "Identifiants", "Credenciales", "Credenciais"]),
("Language", ["Language", "\u{8bed}\u{8a00}", "\u{042f}\u{0437}\u{044b}\u{043a}", "Langue", "Idioma", "Idioma"]),
("Logs", ["Logs", "\u{65e5}\u{5fd7}", "\u{0416}\u{0443}\u{0440}\u{043d}\u{0430}\u{043b}", "Journaux", "Registros", "Registos"]),
("Bug report", ["Bug report", "\u{95ee}\u{9898}\u{53cd}\u{9988}", "\u{421}\u{43e}\u{43e}\u{431}\u{449}\u{438}\u{442}\u{44c} \u{43e}\u{431} \u{43e}\u{448}\u{438}\u{431}\u{43a}\u{435}", "Signaler un bug", "Informar de un error", "Relatar um erro"]),
("Type", ["Type", "\u{7c7b}\u{578b}", "\u{422}\u{438}\u{43f}", "Type", "Tipo", "Tipo"]),
("Bug", ["Bug", "\u{7f3a}\u{9677}", "\u{41e}\u{448}\u{438}\u{431}\u{43a}\u{430}", "Bug", "Error", "Erro"]),
("UI change", ["UI change", "\u{754c}\u{9762}\u{4fee}\u{6539}", "\u{418}\u{437}\u{43c}\u{435}\u{43d}\u{435}\u{43d}\u{438}\u{435} \u{438}\u{43d}\u{442}\u{435}\u{440}\u{444}\u{435}\u{439}\u{441}\u{430}", "Modification de l'interface", "Cambio de interfaz", "Altera\u{e7}\u{e3}o da interface"]),
("Feature request", ["Feature request", "\u{529f}\u{80fd}\u{5efa}\u{8bae}", "\u{41f}\u{440}\u{435}\u{434}\u{43b}\u{43e}\u{436}\u{435}\u{43d}\u{438}\u{435} \u{444}\u{443}\u{43d}\u{43a}\u{446}\u{438}\u{438}", "Demande de fonctionnalit\u{e9}", "Solicitud de funci\u{f3}n", "Pedido de recurso"]),
("Send", ["Send", "\u{53d1}\u{9001}", "\u{41e}\u{442}\u{43f}\u{440}\u{430}\u{432}\u{438}\u{442}\u{44c}", "Envoyer", "Enviar", "Enviar"]),
("Open issue", ["Open issue", "\u{6253}\u{5f00}\u{95ee}\u{9898}", "\u{41e}\u{442}\u{43a}\u{440}\u{44b}\u{442}\u{44c} \u{437}\u{430}\u{434}\u{430}\u{447}\u{443}", "Ouvrir le ticket", "Abrir incidencia", "Abrir issue"]),
// KPI captions
("Total", ["Total", "\u{603b}\u{6570}", "\u{0412}\u{0441}\u{0435}\u{0433}\u{043e}", "Total", "Total", "Total"]),
("Hashing", ["Hashing", "\u{6b63}\u{5728}\u{6316}\u{77ff}", "\u{0425}\u{0435}\u{0448}\u{0438}\u{0440}\u{043e}\u{0432}\u{0430}\u{043d}\u{0438}\u{0435}", "Minage", "Minando", "Minerando"]),
+10 -3
View File
@@ -32,13 +32,17 @@ pub fn scan_log(ip: &str, brand: &str, timeout_secs: u64) -> Result<LogScan, Str
if brand.eq_ignore_ascii_case("whatsminer") {
let resp = crate::access_probe::whatsminer_get_error_code(ip)
.ok_or_else(|| "WhatsMiner did not answer get_error_code on :4028".to_string())?;
return Ok(LogScan { text: tail(&resp, MAX_LOG_BYTES) });
return Ok(LogScan {
text: tail(&resp, MAX_LOG_BYTES),
});
}
let text = crate::scan::fetch_log(ip, timeout_secs)?;
if text.trim().is_empty() {
return Err("the miner returned an empty log".to_string());
}
Ok(LogScan { text: tail(&text, MAX_LOG_BYTES) })
Ok(LogScan {
text: tail(&text, MAX_LOG_BYTES),
})
}
/// Keep the last `max` bytes of `s` (a log's tail is the freshest), on a line
@@ -55,7 +59,10 @@ fn tail(s: &str, max: usize) -> String {
start += 1;
}
// then advance to the next line boundary so we don't cut a line in half
let start = s[start..].find('\n').map(|i| start + i + 1).unwrap_or(start);
let start = s[start..]
.find('\n')
.map(|i| start + i + 1)
.unwrap_or(start);
format!("[... earlier log trimmed ...]\n{}", &s[start..])
}
+4 -1
View File
@@ -12,7 +12,10 @@ static LOG: Mutex<Vec<String>> = Mutex::new(Vec::new());
/// Local wall-clock HH:MM:SS for a log line. Uses the system clock offset from
/// UTC via the TZ-less epoch; good enough for an activity log timestamp.
fn stamp() -> String {
let secs = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0);
let secs = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let t = secs % 86_400;
format!("{:02}:{:02}:{:02}", t / 3600, (t % 3600) / 60, t % 60)
}
+67 -6
View File
@@ -1,23 +1,39 @@
//! alkane-toolkit — primary view (docs/UI-SPEC.md).
//! alkane-toolkit: primary view (docs/UI-SPEC.md).
//! Pure-Rust wxWidgets app on the vendored, patched wx-rs.
// A GUI application on Windows: no console window opens behind it. The
// headless modes below re-attach to the console they were started from.
#![cfg_attr(windows, windows_subsystem = "windows")]
mod access_probe;
mod alkane_detect;
mod askpass;
mod bug_report;
mod credentials;
mod export;
mod fixtures;
mod i18n;
mod logs;
mod log_scan;
mod logs;
mod model;
mod naming;
mod pool_prefs;
mod presets;
mod restore;
mod scan;
mod stock_ops;
mod ui;
fn main() {
// ssh runs this executable as its askpass helper for password logins
// (askpass.rs); answer and exit before anything else starts.
if let Some(code) = askpass::serve_if_askpass() {
std::process::exit(code);
}
if headless_mode() {
attach_parent_console();
}
// Headless workflow self-test: render the bench-fleet fixtures through the
// real widgets and check the table + KPIs against the expected hardware
// output. Run under a virtual display (see scripts/ui-selftest.sh).
@@ -61,10 +77,10 @@ fn main() {
// Load the saved UI language before any strings are built (round 15 #13).
i18n::init();
// Bootstrap the wx app + main frame (upstream bridge).
// Bootstrap the wx app + main frame (upstream bridge). This also picks the
// light/dark appearance (system, or ALKANE_APPEARANCE=light|dark) before the
// frame exists, which wxMSW requires.
wx_rs::init_app("alkane-toolkit", 1280, 800);
// Follow the system light/dark appearance.
wx_rs::set_appearance_system();
// Build the UI-SPEC primary view into the frame.
let frame = wx_rs::Widget::main_frame();
@@ -86,6 +102,17 @@ fn run_selftest() -> i32 {
let frame = wx_rs::Widget::main_frame();
let mut app = ui::build(frame);
let ok = app.run_fixture_selftest();
// ALKANE_SNAPSHOT=path (macOS): also write a PNG of the window as the app
// draws it, to check rendering without screen-recording permission.
if let Some(path) = std::env::var_os("ALKANE_SNAPSHOT") {
let path = path.to_string_lossy();
let wrote = wx_rs::snapshot_png(&frame, &path);
println!(
"SNAPSHOT {} {}",
if wrote { "wrote" } else { "unavailable" },
path
);
}
println!("SELFTEST {}", if ok { "PASS" } else { "FAIL" });
if ok {
0
@@ -93,3 +120,37 @@ fn run_selftest() -> i32 {
1
}
}
/// True when the process runs one of the headless check modes instead of the GUI.
fn headless_mode() -> bool {
["ALKANE_SELFTEST", "ALKANE_ACCESS_PROBE", "ALKANE_LOG_SCAN"]
.iter()
.any(|v| std::env::var_os(v).is_some())
}
/// A Windows GUI-subsystem process has no console, so output from the headless
/// modes would vanish when they are run from a terminal. Attach to the parent's
/// console in that case. Redirected output (pipes, files, CI) already has valid
/// standard handles and is left alone.
#[cfg(windows)]
fn attach_parent_console() {
type Handle = *mut core::ffi::c_void;
const STD_OUTPUT_HANDLE: u32 = -11i32 as u32;
const ATTACH_PARENT_PROCESS: u32 = u32::MAX;
#[link(name = "kernel32")]
extern "system" {
fn GetStdHandle(which: u32) -> Handle;
fn AttachConsole(process_id: u32) -> i32;
}
// SAFETY: plain Win32 calls with constant arguments; failure (no parent
// console, already attached) is harmless and leaves the process unchanged.
unsafe {
let out = GetStdHandle(STD_OUTPUT_HANDLE);
if out.is_null() || out as isize == -1 {
AttachConsole(ATTACH_PARENT_PROCESS);
}
}
}
#[cfg(not(windows))]
fn attach_parent_console() {}
File diff suppressed because it is too large Load Diff
+68 -17
View File
@@ -234,7 +234,10 @@ fn clean_antminer(id: &str) -> String {
/// Normalise a raw control-board name for matching: drop spaces/punctuation and
/// uppercase, so "BeagleBone Black", "BeagleBoneBlack" and "BBB" all collapse.
fn compact_upper(s: &str) -> String {
s.chars().filter(|c| c.is_ascii_alphanumeric()).flat_map(|c| c.to_uppercase()).collect()
s.chars()
.filter(|c| c.is_ascii_alphanumeric())
.flat_map(|c| c.to_uppercase())
.collect()
}
/// The control-board short code for the Control-board column, e.g.
@@ -365,7 +368,10 @@ mod tests {
assert_eq!(chip_type_for_model("Antminer", "S19"), Some("BM1398"));
assert_eq!(chip_type_for_model("Antminer", "T19"), Some("BM1398"));
// Raw "Unknown" passthrough with brand + parenthetical normalizes to S19.
assert_eq!(chip_type_for_model("Antminer", "ANTMINER S19 (88)"), Some("BM1398"));
assert_eq!(
chip_type_for_model("Antminer", "ANTMINER S19 (88)"),
Some("BM1398")
);
// WhatsMiner chips are not cleanly named -> never derived.
assert_eq!(chip_type_for_model("Whatsminer", "M30S+VE40"), None);
// Unknown Antminer model -> None (no guess).
@@ -431,23 +437,56 @@ mod tests {
#[test]
fn control_board_short_codes() {
// Antminer families (board name as asic-rs renders the enum variant).
assert_eq!(control_board_code("Antminer", "BeagleBoneBlack", "S19"), "BBB (C77)");
assert_eq!(
control_board_code("Antminer", "BeagleBoneBlack", "S19"),
"BBB (C77)"
);
// Also accept the spaced form some layers produce.
assert_eq!(control_board_code("Antminer", "BeagleBone Black", "S19"), "BBB (C77)");
assert_eq!(control_board_code("Antminer", "CVITek", "S21 Pro"), "CVI (C88)");
assert_eq!(control_board_code("Antminer", "Xilinx", "S17 Pro"), "XIL (C49)");
assert_eq!(
control_board_code("Antminer", "BeagleBone Black", "S19"),
"BBB (C77)"
);
assert_eq!(
control_board_code("Antminer", "CVITek", "S21 Pro"),
"CVI (C88)"
);
assert_eq!(
control_board_code("Antminer", "Xilinx", "S17 Pro"),
"XIL (C49)"
);
assert_eq!(control_board_code("Antminer", "Xilinx", "T17"), "XIL (C49)");
assert_eq!(control_board_code("Antminer", "Xilinx", "S19 Pro"), "XIL (C55)");
assert_eq!(control_board_code("Antminer", "AMLogic", "S19j Pro"), "AML (C76)");
assert_eq!(control_board_code("Antminer", "AMLogic", "S19k Pro"), "AML (CBE)");
assert_eq!(control_board_code("Antminer", "AMLogic", "S19 XP"), "AML (CBE)");
assert_eq!(
control_board_code("Antminer", "Xilinx", "S19 Pro"),
"XIL (C55)"
);
assert_eq!(
control_board_code("Antminer", "AMLogic", "S19j Pro"),
"AML (C76)"
);
assert_eq!(
control_board_code("Antminer", "AMLogic", "S19k Pro"),
"AML (CBE)"
);
assert_eq!(
control_board_code("Antminer", "AMLogic", "S19 XP"),
"AML (CBE)"
);
// WhatsMiner families.
assert_eq!(control_board_code("Whatsminer", "H3", "M30S"), "H3 (CB2)");
assert_eq!(control_board_code("Whatsminer", "H6", "M50"), "H6 (CB4)");
assert_eq!(control_board_code("Whatsminer", "H6OS", "M50"), "H6os (CB4)");
assert_eq!(control_board_code("Whatsminer", "H616", "M30S+"), "H616 (CB6)");
assert_eq!(
control_board_code("Whatsminer", "H6OS", "M50"),
"H6os (CB4)"
);
assert_eq!(
control_board_code("Whatsminer", "H616", "M30S+"),
"H616 (CB6)"
);
// Unknown / blank pass through.
assert_eq!(control_board_code("Antminer", "Unknown: FOO", "S19"), "Unknown: FOO");
assert_eq!(
control_board_code("Antminer", "Unknown: FOO", "S19"),
"Unknown: FOO"
);
assert_eq!(control_board_code("Antminer", "", "S19"), "");
}
@@ -455,23 +494,35 @@ mod tests {
fn control_board_cpu_and_board_split() {
// CPU column vs board-code column.
assert_eq!(control_board_cpu("Antminer", "AMLogic", "S19j Pro"), "AML");
assert_eq!(control_board_board("Antminer", "AMLogic", "S19j Pro"), "C76");
assert_eq!(
control_board_board("Antminer", "AMLogic", "S19j Pro"),
"C76"
);
assert_eq!(control_board_cpu("Antminer", "CVITek", "S21 Pro"), "CVI");
assert_eq!(control_board_board("Antminer", "CVITek", "S21 Pro"), "C88");
assert_eq!(control_board_cpu("Whatsminer", "H616", "M30S+"), "H616");
assert_eq!(control_board_board("Whatsminer", "H616", "M30S+"), "CB6");
// S21 Pro on an AMLogic board is the 140mm CBE, not C76.
assert_eq!(control_board_board("Antminer", "AMLogic", "S21 Pro"), "CBE");
assert_eq!(control_board_code("Antminer", "AMLogic", "S21 Pro"), "AML (CBE)");
assert_eq!(
control_board_code("Antminer", "AMLogic", "S21 Pro"),
"AML (CBE)"
);
// Unknown -> cpu holds the raw string, no board code.
assert_eq!(control_board_cpu("Antminer", "Unknown: FOO", "S19"), "Unknown: FOO");
assert_eq!(
control_board_cpu("Antminer", "Unknown: FOO", "S19"),
"Unknown: FOO"
);
assert_eq!(control_board_board("Antminer", "Unknown: FOO", "S19"), "");
}
#[test]
fn firmware_family_splits_vendor_prefix() {
// Stock firmware: vendor word moves out of the family word (round 11 #6).
assert_eq!(firmware_family("AntMiner Stock"), ("Stock".to_string(), Some("AntMiner".to_string())));
assert_eq!(
firmware_family("AntMiner Stock"),
("Stock".to_string(), Some("AntMiner".to_string()))
);
assert_eq!(
firmware_family("WhatsMiner Stock"),
("Stock".to_string(), Some("WhatsMiner".to_string()))
+34 -33
View File
@@ -6,8 +6,6 @@
use std::path::PathBuf;
const CONFIG_DIR: &str = ".config/alkane-toolkit";
/// Which pool field a "+" menu belongs to.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PoolField {
@@ -36,8 +34,20 @@ impl PoolField {
PoolField::Account => Vec::new(),
// Per-miner worker-name placeholders (see MinerRow::expand_worker_template).
PoolField::Worker => vec![
"{ip1}", "{ip2}", "{ip3}", "{ip4}", "{serial}", "{mac}", "{nameplate-hr}",
"{brand}", "{model}", "{submodel}", "{cpu}", "{cb}", "{firmware}", "{hostname}",
"{ip1}",
"{ip2}",
"{ip3}",
"{ip4}",
"{serial}",
"{mac}",
"{nameplate-hr}",
"{brand}",
"{model}",
"{submodel}",
"{cpu}",
"{cb}",
"{firmware}",
"{hostname}",
],
PoolField::Password => vec!["x"],
}
@@ -60,15 +70,20 @@ pub const POOL_STRATUMS: &[(&str, &str)] = &[
];
fn config_path(file: &str) -> PathBuf {
let home = std::env::var("HOME").unwrap_or_else(|_| ".".into());
PathBuf::from(home).join(CONFIG_DIR).join(file)
alkane_core::platform::config_path(file)
}
/// The user's saved values for `field`, in save order (most recent last).
pub fn load_saved(field: PoolField) -> Vec<String> {
std::fs::read_to_string(config_path(field.saved_file()))
.ok()
.map(|s| s.lines().map(str::trim).filter(|l| !l.is_empty()).map(String::from).collect())
.map(|s| {
s.lines()
.map(str::trim)
.filter(|l| !l.is_empty())
.map(String::from)
.collect()
})
.unwrap_or_default()
}
@@ -88,28 +103,9 @@ pub fn save_all(field: PoolField, values: &[String]) -> std::io::Result<usize> {
Ok(out.len())
}
/// Write `data` to `path` with owner-only (0600) permissions from creation on
/// Unix, so a secret is never momentarily world-readable between write and chmod.
/// `mode()` only takes effect when the file is created, so an already-existing
/// file is also re-tightened; elsewhere this is a plain write.
/// Saved pool values can carry worker passwords, so they are written owner-only.
fn write_private(path: &std::path::Path, data: &[u8]) -> std::io::Result<()> {
#[cfg(unix)]
{
use std::io::Write;
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
let mut f = std::fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.mode(0o600)
.open(path)?;
let _ = std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o600));
f.write_all(data)
}
#[cfg(not(unix))]
{
std::fs::write(path, data)
}
alkane_core::platform::write_private(path, data)
}
/// Trim every value, then drop empties, values equal to a built-in preset, and
@@ -153,13 +149,18 @@ mod tests {
#[test]
fn dedupe_saved_trims_drops_empties_presets_and_dupes() {
let presets = ["x", "{ip1}"];
let vals: Vec<String> = [" ", "myworker", "myworker", "x", " keep ", "{ip1}", "keep"]
.iter()
.map(|s| s.to_string())
.collect();
let vals: Vec<String> = [
" ", "myworker", "myworker", "x", " keep ", "{ip1}", "keep",
]
.iter()
.map(|s| s.to_string())
.collect();
// " " (empty), the second "myworker", "x"/"{ip1}" (presets) and the second
// "keep" all drop; " keep " is trimmed and kept.
assert_eq!(dedupe_saved(&presets, &vals), vec!["myworker".to_string(), "keep".to_string()]);
assert_eq!(
dedupe_saved(&presets, &vals),
vec!["myworker".to_string(), "keep".to_string()]
);
}
#[test]
+20 -4
View File
@@ -43,7 +43,12 @@ impl PresetView {
PresetView {
order: v.order.clone(),
// keep the visible columns in display order for stability
visible: v.order.iter().copied().filter(|c| v.visible.contains(c)).collect(),
visible: v
.order
.iter()
.copied()
.filter(|c| v.visible.contains(c))
.collect(),
sort: v.sort,
filters: v.filters.iter().map(|(k, f)| (*k, f.clone())).collect(),
}
@@ -62,7 +67,12 @@ impl PresetView {
let mut visible: HashSet<Column> = self.visible.iter().copied().collect();
visible.insert(Column::Ip); // IP is always shown
let filters: HashMap<Column, ColFilter> = self.filters.iter().cloned().collect();
ViewState { order, visible, sort: self.sort, filters }
ViewState {
order,
visible,
sort: self.sort,
filters,
}
}
}
@@ -134,8 +144,14 @@ mod tests {
// The Health column (round 13 #3) replaced these in the default profile.
assert!(!view.visible.contains(&Column::Error));
// Columns dropped from the default profile in round 11.
assert!(!view.visible.contains(&Column::BoardCode), "not in the default profile");
assert!(!view.visible.contains(&Column::Fan1), "not in the default profile");
assert!(
!view.visible.contains(&Column::BoardCode),
"not in the default profile"
);
assert!(
!view.visible.contains(&Column::Fan1),
"not in the default profile"
);
// to_view covers every column in `order`.
assert_eq!(view.order.len(), ALL_COLUMNS.len());
// Round-trip a snapshot back out.
+123 -37
View File
@@ -16,16 +16,20 @@
use std::io::{Read, Write};
use std::net::{SocketAddr, TcpStream};
use std::process::Command;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{Receiver, channel};
use std::sync::mpsc::{channel, Receiver};
use std::sync::Arc;
use std::time::Duration;
use crate::scan::fake_scan_enabled;
pub enum RestoreMsg {
Started,
Result { ip: String, ok: bool, detail: String },
Result {
ip: String,
ok: bool,
detail: String,
},
Done,
}
@@ -87,7 +91,14 @@ pub fn start_restore(
break;
}
let (ok, detail) = restore_one(&t, &vnish_pass, &ssh_user, &ssh_pass);
if tx.send(RestoreMsg::Result { ip: t.ip, ok, detail }).is_err() {
if tx
.send(RestoreMsg::Result {
ip: t.ip,
ok,
detail,
})
.is_err()
{
return;
}
}
@@ -106,7 +117,12 @@ pub fn start_restore(
RestoreHandle { rx, cancel }
}
fn restore_one(t: &RestoreTarget, vnish_pass: &str, ssh_user: &str, ssh_pass: &str) -> (bool, String) {
fn restore_one(
t: &RestoreTarget,
vnish_pass: &str,
ssh_user: &str,
ssh_pass: &str,
) -> (bool, String) {
let fw = t.firmware.to_ascii_lowercase();
if fw.contains("vnish") || fw.contains("wildrose") || fw.contains("anthill") {
restore_vnish(&t.ip, vnish_pass)
@@ -115,7 +131,10 @@ fn restore_one(t: &RestoreTarget, vnish_pass: &str, ssh_user: &str, ssh_pass: &s
} else if fw.contains("braiins") || fw.contains("bos") {
restore_braiins(&t.ip, ssh_user, ssh_pass)
} else {
(false, format!("no restore-to-stock path for firmware '{}'", t.firmware))
(
false,
format!("no restore-to-stock path for firmware '{}'", t.firmware),
)
}
}
@@ -127,9 +146,17 @@ fn restore_vnish(ip: &str, pass: &str) -> (bool, String) {
let body = serde_json::json!({ "pw": pass }).to_string();
let unlock = match curl(
&[
"-s", "--connect-timeout", "5", "--max-time", "9",
"-X", "POST", "-H", "Content-Type: application/json",
"-d", "@-",
"-s",
"--connect-timeout",
"5",
"--max-time",
"9",
"-X",
"POST",
"-H",
"Content-Type: application/json",
"-d",
"@-",
&format!("http://{ip}/api/v1/unlock"),
],
Some(body.as_bytes()),
@@ -146,8 +173,15 @@ fn restore_vnish(ip: &str, pass: &str) -> (bool, String) {
};
match curl(
&[
"-s", "--connect-timeout", "5", "--max-time", "12",
"-X", "POST", "-H", &format!("Authorization: Bearer {token}"),
"-s",
"--connect-timeout",
"5",
"--max-time",
"12",
"-X",
"POST",
"-H",
&format!("Authorization: Bearer {token}"),
&format!("http://{ip}/api/v1/firmware/remove"),
],
None,
@@ -174,7 +208,10 @@ fn restore_luxos(ip: &str) -> (bool, String) {
.map(str::to_string)
});
let Some(session) = session.filter(|s| !s.is_empty()) else {
return (false, format!("no SessionID in logon response: {}", logon.trim()));
return (
false,
format!("no SessionID in logon response: {}", logon.trim()),
);
};
// serde-encode so the miner-supplied SessionID can't break or inject into the
// JSON-RPC command (round 18 #12).
@@ -206,22 +243,32 @@ fn restore_luxos(ip: &str) -> (bool, String) {
/// Braiins: SSH `uninstall.sh` (re-flashes the retained on-NAND stock backup).
fn restore_braiins(ip: &str, user: &str, pass: &str) -> (bool, String) {
if pass.is_empty() {
return (false, "Braiins restore needs an SSH password (set the SSH login)".into());
return (
false,
"Braiins restore needs an SSH password (Credentials > SSH)".into(),
);
}
let target = format!("{user}@{ip}");
// sshpass reads the password from $SSHPASS (-e) rather than argv (-p), so it
// never shows up in the process list (round 18 #12). Host-key checking is
// deliberately disabled: these are LAN miners whose SSH host key changes on
// every reflash, so pinning it would break the very revert this performs.
// BatchMode stops any interactive prompt from hanging out the 60 s cap.
let mut cmd = Command::new("sshpass");
cmd.env("SSHPASS", pass);
cmd.arg("-e").arg("ssh");
// The password reaches ssh through the toolkit's own askpass helper (its
// environment, never argv, so it stays out of the process list; round 18
// #12), which works the same with Linux OpenSSH and Windows' ssh.exe. One
// password attempt and no terminal: a bad password fails fast instead of
// hanging out the 60 s cap. Host-key checking is deliberately disabled: these
// are LAN miners whose SSH host key changes on every reflash, so pinning it
// would break the very revert this performs.
let mut cmd = alkane_core::platform::quiet_command("ssh");
if let Err(e) = crate::askpass::ssh_with_password(&mut cmd, pass) {
return (false, e);
}
let known_hosts = format!("UserKnownHostsFile={}", alkane_core::platform::NULL_DEVICE);
cmd.args(crate::askpass::PASSWORD_AUTH_OPTIONS);
cmd.args([
"-o", "StrictHostKeyChecking=no",
"-o", "UserKnownHostsFile=/dev/null",
"-o", "BatchMode=yes",
"-o", "ConnectTimeout=8",
"-o",
"StrictHostKeyChecking=no",
"-o",
&known_hosts,
"-o",
"ConnectTimeout=8",
&target,
"uninstall.sh || /sbin/uninstall.sh",
]);
@@ -247,7 +294,12 @@ fn restore_braiins(ip: &str, user: &str, pass: &str) -> (bool, String) {
/// diagnostic to stderr, leaves stdout empty, and exits non-zero -- must be
/// reported as a FAILURE, never a false success. A dropped connection or a
/// timeout after the command started is the expected signature of the reboot.
fn classify_braiins(stdout: &str, stderr: &str, code: Option<i32>, timed_out: bool) -> (bool, String) {
fn classify_braiins(
stdout: &str,
stderr: &str,
code: Option<i32>,
timed_out: bool,
) -> (bool, String) {
let err = stderr.to_lowercase();
// ssh's own connection/auth failures (exit 255) never reach the remote command.
let conn_fail = [
@@ -264,7 +316,10 @@ fn classify_braiins(stdout: &str, stderr: &str, code: Option<i32>, timed_out: bo
.any(|m| err.contains(m));
if conn_fail {
let why = stderr.lines().map(str::trim).rfind(|l| !l.is_empty());
return (false, format!("SSH failed: {}", why.unwrap_or("connection/auth error")));
return (
false,
format!("SSH failed: {}", why.unwrap_or("connection/auth error")),
);
}
let out = stdout.to_lowercase();
if out.contains("not found") || out.contains("no such") || err.contains("not found") {
@@ -273,14 +328,19 @@ fn classify_braiins(stdout: &str, stderr: &str, code: Option<i32>, timed_out: bo
match code {
Some(0) => (true, "ran uninstall.sh (reverts to stock + reboots)".into()),
None => (true, "SSH dropped (miner likely rebooting to stock)".into()),
_ if timed_out => (true, "SSH timed out (miner likely rebooting to stock)".into()),
_ if timed_out => (
true,
"SSH timed out (miner likely rebooting to stock)".into(),
),
Some(c) => (false, format!("uninstall.sh exited {c}: {}", stderr.trim())),
}
}
/// One luxminer :4028 request/response (line-framed, socket closes after reply).
fn lux_rpc(ip: &str, payload: &str) -> Result<String, String> {
let addr: SocketAddr = format!("{ip}:4028").parse().map_err(|e| format!("bad addr: {e}"))?;
let addr: SocketAddr = format!("{ip}:4028")
.parse()
.map_err(|e| format!("bad addr: {e}"))?;
let t = Duration::from_secs(8);
let mut s = TcpStream::connect_timeout(&addr, t).map_err(|e| e.to_string())?;
s.set_read_timeout(Some(t)).ok();
@@ -300,7 +360,9 @@ fn lux_rpc(ip: &str, payload: &str) -> Result<String, String> {
Err(_) => break,
}
}
Ok(String::from_utf8_lossy(&buf).trim_matches('\u{0}').to_string())
Ok(String::from_utf8_lossy(&buf)
.trim_matches('\u{0}')
.to_string())
}
/// The captured result of a timed subprocess run.
@@ -316,7 +378,7 @@ struct CmdOutput {
/// timed out (a black-holed host); otherwise returns stdout even on a non-zero
/// exit (curl prints useful bodies/status on failures).
fn curl(args: &[&str], stdin_data: Option<&[u8]>) -> Result<String, String> {
let mut cmd = Command::new("curl");
let mut cmd = alkane_core::platform::quiet_command("curl");
cmd.args(args);
let out = run_with_timeout(cmd, Duration::from_secs(15), stdin_data)?;
if out.timed_out && out.stdout.is_empty() {
@@ -391,24 +453,45 @@ mod tests {
// The critical regression guard (round 18 #12): a wrong password or an
// unreachable miner writes to stderr, leaves stdout empty, and exits
// non-zero -- it must report failure, never "restored".
let (ok, msg) = classify_braiins("", "Permission denied, please try again.", Some(255), false);
let (ok, msg) =
classify_braiins("", "Permission denied, please try again.", Some(255), false);
assert!(!ok, "wrong password must not report success");
assert!(msg.to_lowercase().contains("ssh failed"), "{msg}");
let (ok, _) = classify_braiins("", "ssh: connect to host 10.0.0.9 port 22: Connection refused", Some(255), false);
let (ok, _) = classify_braiins(
"",
"ssh: connect to host 10.0.0.9 port 22: Connection refused",
Some(255),
false,
);
assert!(!ok, "unreachable miner must not report success");
let (ok, _) = classify_braiins("", "ssh: Could not resolve hostname miner: Name or service not known", Some(255), false);
let (ok, _) = classify_braiins(
"",
"ssh: Could not resolve hostname miner: Name or service not known",
Some(255),
false,
);
assert!(!ok, "unresolvable host must not report success");
// Genuine outcomes.
let (ok, _) = classify_braiins("uninstalling...\n", "", Some(0), false);
assert!(ok, "clean exit 0 is success");
let (ok, _) = classify_braiins("", "Connection to 10.0.0.5 closed by remote host.", None, false);
let (ok, _) = classify_braiins(
"",
"Connection to 10.0.0.5 closed by remote host.",
None,
false,
);
assert!(ok, "connection dropped mid-command (reboot) is success");
let (ok, _) = classify_braiins("", "", None, true);
assert!(ok, "timeout after the command started (reboot) is success");
let (ok, _) = classify_braiins("bash: uninstall.sh: command not found\n", "", Some(127), false);
let (ok, _) = classify_braiins(
"bash: uninstall.sh: command not found\n",
"",
Some(127),
false,
);
assert!(!ok, "missing uninstall.sh is a failure");
}
@@ -416,7 +499,10 @@ mod tests {
fn firmware_selects_the_right_flow() {
// The dispatcher only recognises the three revertible aftermarket
// families; anything else has no restore path.
let mk = |fw: &str| RestoreTarget { ip: "0.0.0.0".into(), firmware: fw.into() };
let mk = |fw: &str| RestoreTarget {
ip: "0.0.0.0".into(),
firmware: fw.into(),
};
// Unknown firmware is rejected cleanly (no network attempt in the branch).
let (ok, detail) = restore_one(&mk("Stock"), "", "", "");
assert!(!ok);
File diff suppressed because it is too large Load Diff
+284
View File
@@ -0,0 +1,284 @@
//! Install alkane-os onto a board on stock, and restore an alkane board to
//! stock, from the GUI - using the toolkit's own self-contained, network-only
//! engine (`alkane_flash::stock`), the same code the CLI drives. There is no
//! external helper and no runtime dependency on any other tool: the
//! stock-crossing method is compiled into this binary. This module drives that
//! engine on a background thread and reports progress.
//!
//! Both operations are DESTRUCTIVE (they reflash the control board) and run on a
//! background thread so the reboot/flash latency never blocks the wx event loop.
//! Results stream back over a channel, drained by the UI timer tick exactly like
//! restore.rs. The UI gates each behind a typed-FLASH confirmation.
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{channel, Receiver};
use std::sync::Arc;
use alkane_artifacts::afw::{verify_afw, VerifyOptions};
use alkane_artifacts::fetch::{self, ReleaseSource};
use alkane_flash::stock::{self, RestoreImages};
use alkane_flash::stock_firmware;
use crate::scan::fake_scan_enabled;
/// Control boards alkane-os can be installed onto from stock (mirrors the CLI's
/// `SUPPORTED`). Only these are offered as install targets.
pub const SUPPORTED_BOARDS: &[(&str, &str)] =
&[("zynq-7010", "Antminer S17 (Xilinx Zynq-7010 control board)")];
/// The default install board when the user has not chosen another.
pub const DEFAULT_BOARD: &str = "zynq-7010";
pub fn is_supported_board(board: &str) -> bool {
SUPPORTED_BOARDS.iter().any(|(b, _)| *b == board)
}
/// The release asset to install: its filename and download URL, resolved to a
/// local path on the worker thread so the download never blocks the UI. (Local-
/// file install is a CLI feature; the GUI installs from scanned releases.)
pub struct AfwChoice {
pub name: String,
pub url: String,
}
/// Progress + results streamed from the background worker to the UI.
pub enum StockMsg {
Started,
/// A human-readable status line for the status bar (acquiring, verifying...).
Progress(String),
/// One board's outcome.
Result {
ip: String,
ok: bool,
detail: String,
},
Done,
}
pub struct StockHandle {
pub rx: Receiver<StockMsg>,
// Cancellation is honoured between boards; a UI stop control is not wired yet.
#[allow(dead_code)]
cancel: Arc<AtomicBool>,
}
impl StockHandle {
#[allow(dead_code)]
pub fn stop(&self) {
self.cancel.store(true, Ordering::Relaxed);
}
}
fn download_dir() -> PathBuf {
alkane_core::platform::config_path("downloads")
}
/// Install alkane-os onto the given boards (currently on stock), over the
/// network, via the compiled-in from-stock method. `board` is the target board
/// family (gates the `.afw`); `password`, if set, is passed in-process to the
/// method (never to the environment or an argument).
pub fn start_install(
ips: Vec<String>,
board: String,
source: AfwChoice,
allow_unsigned: bool,
password: Option<String>,
) -> StockHandle {
let (tx, rx) = channel();
let cancel = Arc::new(AtomicBool::new(false));
if fake_scan_enabled() {
let _ = tx.send(StockMsg::Started);
let _ = tx.send(StockMsg::Progress(
"install (demo): no hardware touched".into(),
));
for ip in ips {
let _ = tx.send(StockMsg::Result {
ip,
ok: true,
detail: "installed alkane-os (demo)".into(),
});
}
let _ = tx.send(StockMsg::Done);
return StockHandle { rx, cancel };
}
let tc = cancel.clone();
let err_tx = tx.clone();
let spawned = std::thread::Builder::new()
.name("install-from-stock".into())
.spawn(move || {
let _ = tx.send(StockMsg::Started);
// 1. Download the chosen release asset (on this worker thread).
let _ = tx.send(StockMsg::Progress("acquiring .afw...".into()));
let afw_path = match fetch::fetch_afw_url(
&ReleaseSource::alkane_os(),
&source.name,
&source.url,
&download_dir(),
) {
Ok(p) => p,
Err(e) => {
// One failure line per target so the UI clears its op-status.
for ip in &ips {
let _ = tx.send(StockMsg::Result {
ip: ip.clone(),
ok: false,
detail: format!("could not fetch .afw: {e}"),
});
}
let _ = tx.send(StockMsg::Done);
return;
}
};
// 2. Verify + gate the bundle once (board/arch/bootloader + integrity).
let _ = tx.send(StockMsg::Progress("verifying .afw...".into()));
let verified = match verify_afw(
&afw_path,
&VerifyOptions {
allow_unsigned,
expect_board: Some(board.clone()),
},
) {
Ok(v) => v,
Err(e) => {
for ip in &ips {
let _ = tx.send(StockMsg::Result {
ip: ip.clone(),
ok: false,
detail: format!(".afw rejected: {e}"),
});
}
let _ = tx.send(StockMsg::Done);
return;
}
};
if !is_supported_board(&verified.manifest.board) {
for ip in &ips {
let _ = tx.send(StockMsg::Result {
ip: ip.clone(),
ok: false,
detail: format!(
"{} is not a supported install target",
verified.manifest.board
),
});
}
let _ = tx.send(StockMsg::Done);
return;
}
// 3. Install onto each board via the network-only from-stock method.
for ip in ips {
if tc.load(Ordering::Relaxed) {
break;
}
let _ = tx.send(StockMsg::Progress(format!(
"installing {} onto {ip} (from stock)...",
verified.manifest.board
)));
let (ok, detail) =
match stock::install_from_stock(&ip, &afw_path, &verified, password.as_deref())
{
Ok(()) => (
true,
"installed alkane-os (verify liveness over the network)".to_string(),
),
Err(e) => (false, format!("install failed: {e}")),
};
if tx.send(StockMsg::Result { ip, ok, detail }).is_err() {
return;
}
}
let _ = tx.send(StockMsg::Done);
});
if spawned.is_err() {
let _ = err_tx.send(StockMsg::Result {
ip: String::new(),
ok: false,
detail: "could not start the install worker thread".into(),
});
let _ = err_tx.send(StockMsg::Done);
}
StockHandle { rx, cancel }
}
/// Restore one board to genuine Bitmain stock using the user-supplied vendor
/// firmware package: parse it into the stock images and write them back over the
/// network. `password`, if given, is the board's alkane root credential.
fn restore_one(ip: &str, firmware: &Path, password: Option<&str>) -> (bool, String) {
let fw = match stock_firmware::parse(firmware) {
Ok(f) => f,
Err(e) => return (false, format!("firmware: {e}")),
};
// The device tree comes from the toolkit's per-board asset, not the package,
// so any genuine Bitmain firmware (OTA or SD) provides a usable kernel+rootfs.
let images = RestoreImages {
kernel: &fw.kernel,
rootfs: &fw.rootfs,
};
match stock::restore_to_stock(ip, &images, password) {
Ok(()) => (
true,
"restored to stock (verify independently it no longer answers as alkane)".to_string(),
),
Err(e) => (false, format!("restore failed: {e}")),
}
}
/// Restore the given alkane boards to genuine Bitmain stock, over the network,
/// by writing the stock images from `firmware` (a genuine vendor firmware
/// package) back to NAND. `password`, if set, is the board's alkane root
/// credential.
pub fn start_restore(ips: Vec<String>, firmware: PathBuf, password: Option<String>) -> StockHandle {
let (tx, rx) = channel();
let cancel = Arc::new(AtomicBool::new(false));
if fake_scan_enabled() {
let _ = tx.send(StockMsg::Started);
for ip in ips {
let _ = tx.send(StockMsg::Result {
ip,
ok: true,
detail: "restored to stock (demo)".into(),
});
}
let _ = tx.send(StockMsg::Done);
return StockHandle { rx, cancel };
}
let tc = cancel.clone();
let err_tx = tx.clone();
let spawned = std::thread::Builder::new()
.name("restore-to-stock".into())
.spawn(move || {
let _ = tx.send(StockMsg::Started);
for ip in ips {
if tc.load(Ordering::Relaxed) {
break;
}
let _ = tx.send(StockMsg::Progress(format!(
"restoring {ip} to stock (network-only)..."
)));
let (ok, detail) = restore_one(&ip, &firmware, password.as_deref());
if tx.send(StockMsg::Result { ip, ok, detail }).is_err() {
return;
}
}
let _ = tx.send(StockMsg::Done);
});
if spawned.is_err() {
let _ = err_tx.send(StockMsg::Result {
ip: String::new(),
ok: false,
detail: "could not start the restore worker thread".into(),
});
let _ = err_tx.send(StockMsg::Done);
}
StockHandle { rx, cancel }
}
+1882 -312
View File
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,45 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<!--
Application manifest for alkane-toolkit.exe (embedded by windows/alkane-toolkit.rc).
- Common Controls v6: themed native controls (Windows 10/11 visual styles)
instead of the Windows 95 look.
- Per-monitor DPI awareness v2: crisp at any scale factor; wx rescales
windows when they move between monitors.
- supportedOS Windows 10/11 (the Rust toolchain's own minimum).
- activeCodePage UTF-8: the C runtime and any narrow-string Win32 call speak
the same UTF-8 the Rust side does.
- longPathAware: settings/export paths beyond MAX_PATH work when enabled.
- asInvoker: never asks for elevation.
-->
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
<assemblyIdentity type="win32" name="Blueflare.AlkaneToolkit" version="1.0.0.0"
processorArchitecture="amd64"/>
<description>Alkane Toolkit</description>
<dependency>
<dependentAssembly>
<assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls"
version="6.0.0.0" processorArchitecture="*"
publicKeyToken="6595b64144ccf1df" language="*"/>
</dependentAssembly>
</dependency>
<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
<application>
<supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
</application>
</compatibility>
<application xmlns="urn:schemas-microsoft-com:asm.v3">
<windowsSettings>
<dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/pm</dpiAware>
<dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2, PerMonitor</dpiAwareness>
<longPathAware xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">true</longPathAware>
<activeCodePage xmlns="http://schemas.microsoft.com/SMI/2019/WindowsSettings">UTF-8</activeCodePage>
</windowsSettings>
</application>
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
<security>
<requestedPrivileges>
<requestedExecutionLevel level="asInvoker" uiAccess="false"/>
</requestedPrivileges>
</security>
</trustInfo>
</assembly>
Binary file not shown.

After

Width:  |  Height:  |  Size: 48 KiB

@@ -0,0 +1,42 @@
// Windows resources for alkane-toolkit.exe, compiled by crates/alkane-gui/build.rs
// with the windres named by `wx-config --rescomp`. ALKANE_VER_* come from the
// crate version (which CI stamps per release).
// wxMSW's own resources (stock cursors and bitmaps). Its built-in manifest is
// suppressed: the application manifest below replaces it.
#define wxUSE_NO_MANIFEST 1
#include "wx/msw/wx.rc"
// The first icon in the file is the one Explorer and the taskbar show.
aaaa ICON "alkane-toolkit.ico"
CREATEPROCESS_MANIFEST_RESOURCE_ID RT_MANIFEST "alkane-toolkit.exe.manifest"
VS_VERSION_INFO VERSIONINFO
FILEVERSION ALKANE_VER_MAJOR, ALKANE_VER_MINOR, ALKANE_VER_PATCH, 0
PRODUCTVERSION ALKANE_VER_MAJOR, ALKANE_VER_MINOR, ALKANE_VER_PATCH, 0
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
FILEFLAGS 0
FILEOS VOS_NT_WINDOWS32
FILETYPE VFT_APP
FILESUBTYPE VFT2_UNKNOWN
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "040904B0"
BEGIN
VALUE "CompanyName", "BlueFlare Energy Solutions Inc."
VALUE "FileDescription", "Alkane Toolkit"
VALUE "FileVersion", ALKANE_VER_STR
VALUE "InternalName", "alkane-toolkit"
VALUE "LegalCopyright", "Copyright (c) 2026 BlueFlare Energy Solutions Inc. (MIT License)"
VALUE "OriginalFilename", "alkane-toolkit.exe"
VALUE "ProductName", "Alkane Toolkit"
VALUE "ProductVersion", ALKANE_VER_STR
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x0409, 1200
END
END
+21
View File
@@ -0,0 +1,21 @@
#!/bin/sh
# Regenerate alkane-toolkit.ico (the Windows executable/taskbar icon) from the
# in-repo microchip glyph: a white chip on a rounded amber tile, at the sizes
# Windows asks for (16-256 px). Needs rsvg-convert and ImageMagick; the .ico is
# committed, so a normal build never runs this.
set -e
cd "$(dirname "$0")"
GLYPH=../assets/icons/microchip-solid-full.svg
TMP=$(mktemp -d)
trap 'rm -rf "$TMP"' 0
sed 's/currentColor/#ffffff/g; s/<svg /<svg fill="#ffffff" /' "$GLYPH" > "$TMP/glyph.svg"
for s in 16 20 24 32 40 48 64 256; do
r=$((s * 22 / 100)); g=$((s * 64 / 100)); o=$(((s - g) / 2))
rsvg-convert -w "$g" -h "$g" "$TMP/glyph.svg" -o "$TMP/g$s.png"
convert -size "${s}x${s}" xc:none -fill '#d9822b' \
-draw "roundrectangle 0,0 $((s - 1)),$((s - 1)) $r,$r" \
"$TMP/g$s.png" -geometry "+$o+$o" -composite "PNG32:$TMP/i$s.png"
done
convert "$TMP"/i16.png "$TMP"/i20.png "$TMP"/i24.png "$TMP"/i32.png "$TMP"/i40.png \
"$TMP"/i48.png "$TMP"/i64.png "$TMP"/i256.png alkane-toolkit.ico
echo "wrote $(pwd)/alkane-toolkit.ico"
+48
View File
@@ -0,0 +1,48 @@
# ADR 0004: Windows port
Date: 2026-11-02
## Context
The GUI is wxWidgets through the patched `wx-rs` bridge (ADR 0002), so most
of it is portable, but the patches and the app had only ever run on GTK. The
Windows build has to look and behave like a native Windows 10/11 application,
ship from the same CI as Linux, and stay maintainable for a team that develops
on Linux.
## Decision
- Build on Linux: cross-compile with mingw-w64 (posix threads) against the
vendored wxWidgets built as static wxMSW (`scripts/build-wx-windows.sh`).
The `wx-rs` build script now picks the platform from `CARGO_CFG_TARGET_*`
(a build script's `cfg!()` describes the host) and builds Windows/GNU through
`wx-config` exactly like GTK. The C++ runtime is linked statically; the
`.exe` imports only Windows system DLLs.
- Native look comes from wxMSW plus an application manifest
(`crates/alkane-gui/windows/`): Common Controls v6, per-monitor DPI
awareness v2, UTF-8 code page, Windows 10/11 compatibility, icon and
version resources. Light/dark follows the Windows app mode.
- Platform code is contained: OS differences in Rust live in
`alkane_core::platform` (config directory, owner-only secret files, null
device, console-less child processes); in C++ they are `#ifdef __WXMSW__` /
`__WXGTK__` sections of the bridge, with shared logic (icon hit-testing) in
plain functions both use.
- Sizes cross the Rust/C++ boundary in DIPs, converted per window with
`FromDIP`/`ToDIP`. That is the identity on GTK, so Linux output is unchanged.
- SSH password logins use `SSH_ASKPASS` with the toolkit's own executable as
the helper, on every platform, replacing `sshpass` (absent on Windows).
- CI tests the Windows build under Wine on the existing Linux runners (the
release gate), and again on real Windows 11 through a self-hosted VM runner
(advisory, never blocking).
- The `wx-rs` patch queue must reproduce the patched tree from the pristine
upstream crate; `scripts/wx_rs_patches.py check` enforces it in CI.
## Consequences
- One toolchain and one CI fleet for both platforms; no Windows build machine.
- Wine is a good but not perfect stand-in for Windows; the native VM job
covers the gap without making releases depend on the VM being up.
- Bridge changes need checking on both toolkits: GTK uses the native tree
view, wxMSW the generic data view, which differ in input routing, painting
and selection style (see docs/windows.md).
- macOS remains out of scope (no Mac to build or test on).
+171
View File
@@ -0,0 +1,171 @@
# Installing and removing alkane-os
Two front-ends drive the same self-contained engine:
- The CLI (`alkane-cli afw ...`), documented below, is the scriptable path.
- The GUI (`alkane-toolkit`) can scan the fleet, then right-click a board to
install alkane-os onto it from stock or restore it to stock. See
"GUI (right-click install / uninstall)" at the end. (The GUI's older asic-rs
firmware-upload path stays disabled; these two actions use the compiled-in
network-only engine, the same one the CLI uses.)
## Compatible miners
```
alkane-cli afw compat
```
Lists the control boards alkane-os can be installed on. For now that is the
Antminer S17 (`zynq-7010`). The install/restore commands refuse any board whose
`.afw` is not one of these.
## Install
From a local bundle:
```
alkane-cli afw install path/to/alkane-os-<ver>-zynq-7010-armv7.afw \
--host <miner-ip> --confirm FLASH
```
From the latest release (pulled from Gitea, not GitHub, which is retired):
```
alkane-cli afw install --latest --board zynq-7010 --host <miner-ip> --confirm FLASH
# or fetch only:
alkane-cli afw fetch-latest --board zynq-7010 --output ./downloads
```
A private release repo needs a token, read from `ALKANE_RELEASE_TOKEN` (else
`GITEA_TOKEN`) at run time and passed to curl through a 0600 config file - never
on the command line, never stored by the toolkit.
### A board still on stock
Writing our first image onto a board that is still on genuine stock (past the
stock gates and getting root) is done by the toolkit itself, over the network.
The method is part of this binary; nothing else needs to be installed on your
machine. On first use it fetches a small set of per-board assets from our Gitea
(repo `blueflare/alkane-stock-assets`, release `zynq-7010-v1`) and caches them
locally, verifying each against a known SHA-256. That repo is public, so no token
is needed for the stock assets. The asset base URL can be overridden with
`ALKANE_STOCK_ASSETS_BASE`.
Add `--from-stock` (the token below is only to resolve `--latest` from the
private alkane-os release repo; a local `.afw` needs no token):
```
export ALKANE_RELEASE_TOKEN=<your-gitea-token>
alkane-cli afw install --latest --board zynq-7010 --host <miner-ip> \
--from-stock --confirm FLASH
```
The toolkit acquires and verifies the `.afw`, gates on compatibility, fetches
and verifies its assets, performs the network-only stock-side install, then you
verify the board came up as alkane:
```
alkane-cli afw verify-live --host <miner-ip> --timeout 300
```
On Zynq (S17/S19 class) pass the `.afw` (or `--board zynq-7010`) and the board's
alkane root credential; the check needs the web page to carry the image marker
and SSH to report alkane with the installed kernel, and prints the running kernel
command line (on a NAND boot it is the board's U-Boot env bootargs):
```
alkane-cli afw verify-live path/to/alkane-os-<ver>-zynq-7010-armv7.afw \
--host <miner-ip> --password-file <alkane-root-pw> --timeout 300
```
For a bench image that is not signed, add `--allow-unsigned`.
Without `--from-stock`, `install` performs a tier-2 update of a board already on
alkane, in place, over the network:
```
alkane-cli afw install path/to/alkane-os-<ver>-zynq-7010-armv7.afw \
--host <miner-ip> --password-file <alkane-root-pw> --dry-run
alkane-cli afw install path/to/alkane-os-<ver>-zynq-7010-armv7.afw \
--host <miner-ip> --password-file <alkane-root-pw> --confirm FLASH
```
On Zynq (S17/S19 class) the update refuses a board that is not running alkane.
Alkane does not expose the NAND boot regions to Linux (only the small
`stock-cfg` and `alkane-cfg` partitions), so the toolkit re-registers them
first, the same way a restore does. It saves each boot slot to `--backup-dir`
(default: the toolkit's `backups` directory) before any erase, then writes the
rootfs (absolute NAND `0x2800000`), dtb (`0x1a00000`) and kernel (`0x2000000`),
with the kernel and rootfs wrapped as the legacy uImages the board's stock
U-Boot boots, and reads each back (md5) before rebooting. Nothing below
`0x1a00000` (BOOT.bin: FSBL, FPGA bitstream, U-Boot) is ever written.
`afw preflight` runs the same checks read-only. `--no-reboot` skips the reboot.
## Remove (back to stock)
```
alkane-cli afw restore-stock --host <miner-ip> \
--stock-firmware <genuine-Bitmain-firmware> \
--password-file <alkane-root-pw> --confirm FLASH
```
Returning an aftermarket board to genuine stock is done by the toolkit itself,
over the network. It writes the genuine Bitmain stock **kernel and rootfs** -
parsed from a vendor firmware file you supply with `--stock-firmware` (an OTA
update `.tar.gz` or an SD recovery `.zip` for the board) - back to NAND,
preserving BOOT.bin.
The one piece that is NOT in Bitmain's distributable firmware is the kernel
**device tree**: it is factory-provisioned and preserved by every vendor update,
so no OTA/SD package ships it. The toolkit supplies the correct per-board dtb
itself (fetched + verified from the public assets repo, so no token is needed)
and pairs it with the genuine kernel/rootfs. The board's alkane root credential
is given with `--password-file` (or
`ALKANE_BOARD_PASSWORD`/`ALKANE_BOARD_PASSWORD_FILE`).
After a restore the board returns to stock under its stock MAC and typically
takes a new DHCP lease, so it may not reappear on the same address; verify
independently that the board no longer answers as alkane and presents its stock
OS.
## GUI (right-click install / uninstall)
The GUI binary is `alkane-toolkit`. Launch it, let the scan list the fleet, then
right-click one or more boards. The scan finds boards running Alkane OS too
(Firmware column "Alkane"): they expose no cgminer socket or vendor web UI, so the
toolkit identifies them itself from the board's public read-only
`GET /api/identity` (alkane-os 0.1.2 and later; earlier images are found from
`/api/summary`). Each action below is offered only when it applies to every
selected board:
- "Install alkane OS..." - for a supported board (one alkane-os has an image
for; today the Zynq-7010 Antminer S17/S17 Pro/T17) that is not running Alkane
OS yet. Scans the alkane-os releases on Gitea, lets you pick one (newest first;
pre-releases are marked), optionally takes a board password and an "allow
unsigned .afw (bench)" toggle, and - after you type FLASH to confirm -
downloads/verifies the `.afw` and installs it onto each selected board over the
network, via the same compiled-in engine the CLI uses.
- "Update alkane OS..." - for a supported board already running Alkane OS: the
same release picker and confirmation; the board is updated in place (BOOT.bin
is never written).
- "Uninstall alkane OS (restore to stock)..." - for a board running Alkane OS:
takes the board's alkane root password, a genuine Bitmain firmware package and
a typed FLASH confirmation, then restores each selected board to genuine stock
over the network.
A stock board the scan identifies but cannot place on a supported control board
(or a mixed stock/Alkane selection) gets neither Install nor Update.
Progress and per-board results appear on the status bar; verify board state
independently afterwards (the GUI does not claim liveness on its own).
Release scanning reads the private `alkane-os` repo, so it needs a Gitea token.
A read-only token can be baked into the GUI at build time
(`ALKANE_EMBEDDED_TOKEN=<token>` when building), so the shipped binary scans
releases with no setup; otherwise set `ALKANE_RELEASE_TOKEN` (or `GITEA_TOKEN`)
in the environment before launching. The stock-asset fetch needs no token (that
repo is public), so install-from-stock and restore-to-stock work without one -
only the release picker needs it.
Runtime dependencies (Linux): the GUI links wxWidgets 3.2 (wxGTK) and GTK 3, so
the target machine needs `libwxgtk3.2-1` and `libgtk-3-0` installed.
+62
View File
@@ -0,0 +1,62 @@
# macOS
The macOS build is one universal app, `Alkane Toolkit.app`, that runs natively
on Apple Silicon and Intel Macs with macOS 11 (Big Sur) or later. It ships as
`alkane-toolkit-vX.Y.Z-macos-universal.zip`, holding the app, `LICENSE` and a
`README.txt`.
## Using it
- Settings live in `~/.config/alkane-toolkit`, the same files as on Linux.
- SSH actions use the system `ssh`; HTTP actions use the system `curl`.
- The app is ad-hoc signed but not notarized, so macOS blocks the first launch.
On macOS 15 or later, try to open it, then choose **Open Anyway** in
System Settings > Privacy & Security. On macOS 11 to 14, Control-click the
app and choose **Open**. Or clear the quarantine flag once:
`xattr -dr com.apple.quarantine "/Applications/Alkane Toolkit.app"`.
- The first scan asks for permission to find devices on the local network
(macOS 15 and later). Scanning needs it.
- Offline demo: `ALKANE_FAKE_SCAN=1 "/Applications/Alkane Toolkit.app/Contents/MacOS/alkane-toolkit"`.
## Building
macOS builds only on a Mac. It needs the Xcode Command Line Tools
(`xcode-select --install`) and rustup with both Apple targets:
```sh
rustup target add aarch64-apple-darwin x86_64-apple-darwin
scripts/build-wx-macos.sh # once: universal static wxOSX 3.3.3 in ~/.cache/wx-3.3.3-macos
scripts/build-gui-macos.sh # both slices, merged with lipo
python3 ci/package-macos.py X.Y.Z target/universal-apple-darwin/release/alkane-toolkit dist
```
`build-wx-macos.sh` builds wxWidgets once for arm64 and x86_64 together, with
wx's bundled image, zlib, regex and expat libraries, so the app links only
against system frameworks. `build-gui-macos.sh` builds each Rust target
against that prefix and merges them. `package-macos.py` writes the bundle
(Info.plist, icon), ad-hoc signs it and zips it with `ditto`.
To test on the Mac:
```sh
ALKANE_SELFTEST=1 target/universal-apple-darwin/release/alkane-toolkit # headless UI self-test
cargo test --release --offline --target aarch64-apple-darwin --workspace --exclude wx-rs
```
The self-test opens a window briefly, so it needs a logged-in desktop
session. Running the x86_64 slice on Apple Silicon needs Rosetta 2.
## Why macOS 11
Current Xcode SDKs ship a libc++ that supports macOS 11 and later only;
building for an older target compiles, but the app could fail at run time on
the older system. macOS 11 is also the first release for Apple Silicon. Older
Intel Macs would need a build with an older SDK.
## Notes for the bridge
wxOSX reports logical (point) sizes, like the GTK and MSW bridges; the
bridge never scales to physical pixels. wxOSX's Objective-C uses
`@available`, so `build.rs` links clang's compiler runtime
(`libclang_rt.osx.a`), which rustc's link does not include by itself. Both
are wx-rs patch `0009`.
+66
View File
@@ -0,0 +1,66 @@
# Getting started
Alkane Toolkit finds the ASIC miners on your network and shows them in one
table: model, firmware, hashrate, power, temperatures, fans and the health of
every hashboard. From the same table you can run the controls each miner's
firmware supports, such as pausing, restarting or changing pools.
## Download
Get the latest release from the
[downloads page](https://gitea.bluefla.re/blueflare/alkane-toolkit/releases).
| Platform | File | Notes |
|---|---|---|
| Windows 10 and 11 (x86_64) | `alkane-toolkit-vX.Y.Z-windows-x86_64.zip` | One signed `alkane-toolkit.exe`; nothing to install |
| Linux (x86_64) | `alkane-toolkit-vX.Y.Z-linux-x86_64.tar.gz` | One binary; needs GTK 3 (`sudo apt install libgtk-3-0`) |
| macOS 11 or later (Apple Silicon and Intel) | `alkane-toolkit-vX.Y.Z-macos-universal.zip` | One app; not notarized, so confirm the first launch |
### Windows
1. Download the zip, right-click it, choose **Properties**, tick **Unblock** if
it is shown, then extract it.
2. Run `alkane-toolkit.exe`. Windows shows *BlueFlare Energy Solutions Inc.* as
the verified publisher. To check the signature yourself, right-click the exe,
choose **Properties** and open **Digital Signatures**.
### macOS
1. Download the zip and open it; drag **Alkane Toolkit** to Applications.
2. Open it. The app is not notarized, so macOS blocks the first launch:
- macOS 15 or later: open **System Settings > Privacy & Security** and
choose **Open Anyway** for Alkane Toolkit.
- macOS 11 to 14: Control-click the app, choose **Open**, then **Open**.
3. When asked, allow it to find devices on your local network. Scanning
needs this.
### Linux
```sh
tar xzf alkane-toolkit-vX.Y.Z-linux-x86_64.tar.gz
./alkane-toolkit-vX.Y.Z-linux-x86_64/alkane-toolkit
```
## First run
The toolkit starts a scan as soon as it opens. Set your own ranges first with
**Scan ranges** (see [Scanning](02-scanning.md)); until you do, it scans
192.168.1.0/24, the usual router subnet.
To look around without touching any miner, start it in demo mode. It shows a
built-in sample fleet and simulates every action:
| Platform | Command |
|---|---|
| Windows (Command Prompt) | `set ALKANE_FAKE_SCAN=1 && alkane-toolkit.exe` |
| Linux | `ALKANE_FAKE_SCAN=1 ./alkane-toolkit` |
## Where settings are kept
| Platform | Folder |
|---|---|
| Windows | `%APPDATA%\alkane-toolkit` |
| Linux | `~/.config/alkane-toolkit` |
See [Settings and credentials](06-settings.md) for the files in that folder.
Deleting the folder resets the toolkit to its defaults.
+51
View File
@@ -0,0 +1,51 @@
# Scanning
Discovery is read-only: a scan asks each address what it is and records what
it reports. It never changes a miner.
## Scan ranges
Click **Scan ranges** to edit the addresses to scan. Put one entry per line;
blank lines and lines starting with `#` are ignored.
| Form | Example | Scans |
|---|---|---|
| Single address | `192.168.1.50` | that address |
| CIDR block | `192.168.1.0/24` | the whole block |
| Full range | `192.168.1.10-192.168.2.40` | every address between the two, inclusive |
| Short range | `192.168.1.10-90` | `.10` to `.90` within the same /24 |
| Per-octet ranges | `10.1-4.0-1.1-255` | every combination (10.1.0.1 ... 10.4.1.255) |
Commas or spaces between several entries on one line are not accepted; use one
line each. Duplicates are removed automatically. One line, and all lines
together, may cover at most 1,000,000 addresses.
**Apply** saves the ranges and starts a scan. A mistake keeps the dialog open
and the status bar explains it, for example `invalid range: bad octet range`.
The same dialog has three numbers:
| Field | Meaning | Default |
|---|---|---|
| Rescan (s) | seconds between automatic rescans; `0` turns auto-rescan off | 300 |
| Timeout (s) | how long to wait for one miner (scans, refreshes, actions and log fetches) | 10 |
| Concurrency | how many addresses are probed at once (8 to 256); higher is faster but slow miners may report fewer values | 128 |
When the ranges change, miners outside the new ranges leave the table at the
next scan.
## Running, pausing and stopping
The three buttons next to **Scan ranges** control scanning:
- **Play** (green) turns auto-rescan on and starts a scan now if none is running.
- **Pause** (amber) turns auto-rescan off and lets the current scan finish.
- **Stop** (red) turns auto-rescan off and cancels the current scan.
While a scan runs, a progress bar spans the top of the table and the status bar
shows progress such as `1935/4590 - scanning 192.168.1.86 (92 found)`. Afterwards
it shows the count and the time to the next scan, for example
`245 miners - next scan in 4m 12s`.
Actions that change miners wait for the scan to finish; see
[Actions](05-actions.md).
+80
View File
@@ -0,0 +1,80 @@
# The table and header
## Summary cards
The cards at the top count the miners **currently shown** (after any filter).
Each miner is in exactly one status: slow, paused, hashing or not hashing.
| Card | Counts | Click |
|---|---|---|
| Total | rows in the view | - |
| Hashing (green rabbit) | mining at 80% of expected hashrate or more | show only these; click again to clear |
| Slow (amber turtle) | mining below 80% of expected hashrate | show only these |
| Not hashing (red glass) | answering but not mining | show only these |
| Paused (blue otter) | stopped on purpose (paused, stopped, suspended) | show only these |
| SHA-256 Hashrate | total hashrate, per algorithm | switch algorithm when the fleet runs more than one |
| Est. power | total reported power draw | - |
On a narrow window the hashrate and power cards are hidden.
## Columns
IP is always the first column. The default view shows Model, Health,
Hashrate, Power, Chip temp, Firmware, CPU, Access and Light. More than seventy
other columns are available, grouped as Identity, Firmware and board, Health
and status, Performance, Temperature, Cooling, Hardware and Pools.
- **Columns** opens a checklist: tick to show, drag to reorder, or sort the list
alphabetically or by category. *Hide columns with no scanned values* hides
columns that are empty for every miner (it resets when the app restarts).
- Drag a column header to move it.
- Right-click a header to sort by it, auto-size one or all columns, hide it, or
open the column chooser.
Some values worth knowing:
| Column | Shows |
|---|---|
| Hashrate | actual/expected, for example `95.0T/96.0T`; the actual part is red at 50% of expected or less, amber around 75%, green at 100% |
| Chip temp | hottest chip on each hashboard, for example `77 / 64 / 74`; blue when cool, red at 90 C and above |
| Firmware | the firmware family, coloured (Braiins purple, LuxOS gold, VNish green, ePIC light blue, Hiveon orange, Bixbit pink); stock firmware uses the normal text colour |
| Pool account / Worker | the pool user split at the first dot |
| Board HR / V / freq | per-hashboard hashrate, voltage and frequency |
A blank cell means the miner did not report that value.
## Sorting
Click a header to sort ascending, again for descending, again to clear.
- **Hashrate** also sorts by *relative* hashrate (actual as a share of
expected), shown as `%^` and `%v` in the header.
- **Health** sorts by overall health, then by power (`Pwr`), fans (`Fan`) and
hashboards (`Brd`). Ascending puts the most broken miners first.
## Selecting miners
Click a row to select it; Ctrl-click and Shift-click add to the selection, and
you can drag across rows to select a block. The selection follows miners by IP,
so it survives rescans. Double-click a row (or press Enter) to open the miner's
web page in your browser. Right-click the selection for [actions](05-actions.md).
## Filters and presets
**Filter** keeps only the rows that match. Pick a column, then:
- for numbers: between, =, !=, >, >=, < or <= (blank cells never match);
- for text: *is any of* (tick values; `(blank)` matches empty cells), contains,
does not contain, begins with, ends with or equals (case does not matter).
Filters on different columns must all match. **Reset** clears them. Clicking a
status card is a quick filter of its own.
**Presets** saves and loads whole views: column order and visibility, sort and
filters. *Default* is built in and cannot be deleted; saving under an existing
name replaces it.
## Zoom and theme
The slider in the bottom-right corner zooms the table: text, icons and column
widths scale together. The window follows the system light or dark theme.
+54
View File
@@ -0,0 +1,54 @@
# Health, access and light
## The Health column
Each miner gets a row of icons, always in the same order, so problems line up
across the table:
1. **Bolt**: the power supply
2. **Brain**: the control board
3. **Fan**: one icon per fan
4. **Chip**: one icon per hashboard
Hover over any icon to see its details: PSU voltage and current, the fan speed,
or a hashboard's actual and expected hashrate, frequency and voltage, and any
fault message with its code.
| Colour | Meaning |
|---|---|
| Green | healthy |
| Amber | working but below par (a slow board, a fan well below the others, a PSU fault while still mining) |
| Red | detected but down (a faulted board, a stopped fan, a PSU that is not delivering) |
| Grey | expected but not detected or not reachable |
| Blue | the miner is paused, so its boards and stopped fans are idle on purpose |
How each part is judged:
- **Power** is green when the miner draws power, its PSU fan turns or it is
mining; a reported PSU fault makes it amber (still mining) or red.
- **Control board** is red for a control-board fault and amber for a
miner-wide warning such as a high ambient temperature.
- **Fans** are red at 0 rpm and amber below half the speed of the fastest fan.
- **Hashboards** follow the status the miner reports for each board. When the
firmware names the failing boards, only those turn red. A board the miner
cannot see is grey.
While an action runs on a miner, its Health cell shows progress such as
`restarting...` or `refreshing...`.
## Access
The padlock shows whether the toolkit can change the miner:
- **green, open**: changes are possible with the saved credentials;
- **red, closed**: view only;
- **blank**: not known yet.
After a scan the padlock is an estimate from what the firmware offers. Use
**Check access (auth)** in the right-click menu for a real, read-only login
test.
## Light
A flashing green-over-red dot means the miner's locate light is on. Turn it on
or off with **Flash lights** / **Stop flashing lights**.
+60
View File
@@ -0,0 +1,60 @@
# Actions
Right-click one or more selected miners for the actions menu. With several
miners selected, labels show the count, for example *Restart (12)*. An action
appears only when **every** selected miner's firmware supports it, so the menu
changes with the selection.
| Action | What it does | Changes the miner |
|---|---|---|
| Open in browser | opens each miner's web page | no |
| Refresh | re-reads just these miners | no |
| Check access (auth) | tests whether the saved login is accepted | no |
| View log (API)... | shows the first selected miner's log (WhatsMiner: its active fault codes) | no |
| Restore to stock firmware... | removes aftermarket firmware; see [Restore to stock](07-restore.md) | yes, reboots |
| Flash lights / Stop flashing lights | locate light on or off | yes, harmless |
| Pause mining / Resume mining | stop or start hashing | yes |
| Set tuning %... | tuning level, 0 to 100 | yes |
| Set power target... | power target in watts; the prompt shows the current value and the allowed range | yes |
| Set hashrate target... | hashrate target in TH/s, for firmware that tunes by hashrate | yes |
| Set profile... | pick a firmware profile or preset (only profiles every selected miner has are listed) | yes |
| Restart | reboot | yes |
| Configure pools... | set up to three pools | yes |
| Set timezone... | IANA time zone, for example `America/Edmonton` | yes |
| Change password... | new web/API password | yes |
| Factory reset... | wipes pools, tuning and network settings and reboots; the miner may come back on a new DHCP address | yes, destructive |
## Safety
- Pause, Resume, Restart and Factory reset ask for confirmation. Value prompts
(tuning, targets, timezone, password) apply when you confirm the value.
- Actions that change miners do not start while a scan is running, including an
automatic rescan. Wait for it to finish or press **Pause**. Scans in turn wait
for running actions.
- Each changed miner is re-read automatically when the action finishes. Results
and failures appear in the bottom-right corner of the status bar and in
**Settings > Logs**.
- If **Change password** succeeds on every selected miner, the saved global
login is updated to the new password. If only some succeed, the saved login
is left alone and the log says so.
## Configuring pools
The pool dialog has three rows: Address, Account, Worker and Password. A row is
used only when it has an address and an account. A blank password becomes `x`.
The miner's username becomes `account.worker`.
Each field has a **+** menu with common pool addresses and the values you saved
before (**Add new...** edits that list). Worker names can use placeholders that
are filled in per miner:
| Placeholder | Becomes |
|---|---|
| `{ip1}` to `{ip4}` | one octet of the miner's IP |
| `{serial}`, `{mac}` | serial number; MAC without colons |
| `{hostname}` | the miner's hostname |
| `{brand}`, `{model}`, `{submodel}` | make and model |
| `{firmware}`, `{cpu}`, `{cb}` | firmware family, control-board CPU and board |
| `{nameplate-hr}` | the model's rated hashrate |
For example, `rack3-{ip3}-{ip4}` gives `rack3-1-50` for `10.0.1.50`.
+72
View File
@@ -0,0 +1,72 @@
# Settings and credentials
**Settings** opens a menu with Credentials, Language and Logs.
## Credentials
Miners need a login for anything beyond basic discovery: for some details, and
for every action. The Credentials dialog has three parts:
- **All firmwares** at the top: one username and password tried on every miner.
The saved password is never shown; leave the field blank to keep it. Blank
username and password clear it.
- **SSH (restore)**: the control-board SSH login used to restore Braiins OS to
stock (see [SSH login](#ssh-login)).
- **One row per firmware**, pre-filled with that firmware's factory default.
Change a row to override the login for that firmware only.
The toolkit tries, in order, the firmware's own row, then the global login,
then the firmware's built-in default.
| Firmware | Factory default (user / password) |
|---|---|
| AntMiner Stock | root / root |
| WhatsMiner Stock | admin / admin |
| Braiins | root / root |
| VNish | (none) / admin |
| LuxOS | root / root |
| UMC OS | (none) / letmein |
| Marathon | root / root |
| VolcMiner Stock | root / ltc@dog |
| Elphapex Stock | root / root |
| FutureBit Stock | futurebit / futurebit123 |
| SealMiner Stock | seal / seal |
| Auradine Stock | admin / admin |
**Reset to defaults** clears every override, the global login and the SSH
login at once.
Logins are stored as plain text in the settings folder, readable only by your
user account (Linux file mode 0600; on Windows, your profile folder's
permissions).
### SSH login
Restoring Braiins to stock runs a command over SSH, using the system `ssh`
client (built into Windows 10/11). Set its login in the **SSH (restore)** row
of the Credentials dialog. The username defaults to `root`. As with the global
login, the saved password is never shown and a blank password keeps it.
## Language
English, Chinese, Russian, French, Spanish and Portuguese. The toolbar, cards
and column headers switch immediately; menus and dialogs not yet translated
stay in English.
## Logs
An activity log of scans, actions, errors and exports, newest last, kept for
the current session (the last 2000 lines). Times are shown in UTC.
## Files in the settings folder
| File | Holds |
|---|---|
| `scan-ranges.txt` | scan ranges, one per line |
| `auto-rescan-secs.txt`, `scan-timeout-secs.txt`, `scan-concurrency.txt` | the three scan numbers |
| `scan-credentials.txt` | global login |
| `firmware-credentials.txt` | per-firmware logins |
| `ssh-credentials.txt` | SSH login |
| `presets.json` | saved views |
| `language.txt` | UI language |
| `pool-addresses.txt`, `pool-accounts.txt`, `pool-workers.txt`, `pool-passwords.txt` | saved pool values |
+18
View File
@@ -0,0 +1,18 @@
# Restore to stock firmware
**Restore to stock firmware...** removes aftermarket firmware and returns the
miner to the manufacturer's firmware it keeps on board. Nothing is uploaded.
The miner reboots, and some firmwares come back on a new address.
It is offered when the selection includes a supported firmware, and asks for
confirmation with the list of miners first.
| Firmware | How it is removed | Login used |
|---|---|---|
| VNish (and builds based on it) | web API: unlock, then remove firmware; reboots in seconds | the VNish row in Credentials, else `admin` |
| LuxOS | miner API: log on, then uninstall | none |
| Braiins OS | SSH: runs the firmware's own `uninstall.sh` | the SSH row in Credentials (see [Settings](06-settings.md#ssh-login)) |
Miners are restored one at a time. A dropped connection after the command is
sent counts as success, because that is the reboot. A refused login counts as
a failure and leaves the miner unchanged.

Some files were not shown because too many files have changed in this diff Show More