Claude
d7b2f6bf54
sk_v4_genesis never wiped its seed or its read-back; sk_v4_drive_arrived
never wiped the proxy's seed after her login; sk_v4_real_zuse_arrived wiped
the seed only on a match. (The logged-in Zuse's own key stays in g_zuse_seed,
by design.)
Option 1: the three use one buffer the identity module owns, g_seeds (seed,
then its read-back), and sk_v4_drive_arrived -- which every drive goes through,
and which alone calls the other two -- runs the drive's handling (now
handle_drive()) and then wipes it, whichever way it went.
sk_v4_identity_seeds() lets the host tests read it.
kernel/tests/test_sk_v4_identity.c, 10 checks, through the real drive-arrival
path: a fake xHCI controller marks a slot attach-pending, the identity code's
idle beat handles it, the real gpt.c reads the stick's table from the RAM disk;
the block layer, signatures, key mint, marker and console faked. Genesis; a
genesis not read back; the proxy logging in; a real Zuse named, then her stick
logging in. Against the code before the wipe: 5 failures (every case's seeds
left). Now: 0. The harness gains fake_disk_bind. Built for amd64, aarch64,
riscv64. #176 done with 2bac2ac8 (the mint).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017RzZgrf7V7Zk2iczBXDRbm
68 lines
3.0 KiB
C
68 lines
3.0 KiB
C
/* SPDX-License-Identifier: LicenseRef-Starship-1.0
|
|
* Copyright (c) 2023-2026 Robert A. James
|
|
*/
|
|
/* sk_v4_identity.h -- the identity gate for the v4 boot: no identity drive,
|
|
* headless; Zuse's minted thumbdrive, a console.
|
|
* docs/v4.0.0/plans/2026-10-26-engine-step4-identity-gate.md.
|
|
*
|
|
* Built only with STARFORTH_V4=1 (Kconfig.kernel).
|
|
*/
|
|
#ifndef STARKERNEL_V4_SK_V4_IDENTITY_H
|
|
#define STARKERNEL_V4_SK_V4_IDENTITY_H
|
|
|
|
#include "uefi.h" /* BootDisk */
|
|
#include "blkio.h"
|
|
#include "starkernel/v4/sk_v4_marker.h"
|
|
|
|
/* After POST and the block chain: every xHCI controller brought up, and the
|
|
* heartbeat started, as the v3 path does before its headless wait. `boot_disk`
|
|
* is the loader's (uefi_loader.c): a USB disk is this system's stick if it is
|
|
* that disk, or -- when the boot disk is not a stick -- the first USB disk
|
|
* with both StarshipOS partitions. Zuse's public key is read once the stick's
|
|
* Artemis partition is attached (docs/v4.0.0/plans/2026-10-27-stick-4-one-disk.md,
|
|
* Task 4). */
|
|
void sk_v4_identity_boot(const BootDisk *boot_disk);
|
|
|
|
/* 1 while Zuse's session holds: her drive is attached and checked. */
|
|
int sk_v4_identity_present(void);
|
|
|
|
/* Service the heartbeat and, once a second, the USB drives that have arrived
|
|
* or left (v3's idle beat, its USB part). Called while waiting for a key
|
|
* with nothing typed. */
|
|
void sk_v4_identity_beat(void);
|
|
|
|
/* The USB drives that have arrived or left, now, not waiting for the next
|
|
* beat: before each prompt, so that a drive pulled while the last line ran
|
|
* is seen before a prompt is shown. */
|
|
void sk_v4_identity_check_now(void);
|
|
|
|
/* MINT-ZUSE (plan 2026-10-29-stick-5, Task 4): beat until a stick that is not
|
|
* this system's arrives -- it is offered, not attached or refused: 1, its raw
|
|
* device and size in bytes -- or a key is pressed, or the system stick
|
|
* leaves: 0. */
|
|
int sk_v4_identity_offer_wait(blkio_dev_t **raw, uint64_t *bytes);
|
|
|
|
/* For the mint: the system stick's Artemis is attached; the offered stick is
|
|
* still plugged in; the offered stick handed back unused (a mint refused or
|
|
* stopped -- the next mint offers it again); the genesis marker as read, and
|
|
* as the mint has just written it. */
|
|
int sk_v4_identity_stick_in(void);
|
|
int sk_v4_identity_offered_present(void);
|
|
void sk_v4_identity_release_offered(void);
|
|
const sk_v4_marker_t *sk_v4_identity_marker(void);
|
|
void sk_v4_identity_set_marker(const sk_v4_marker_t *m);
|
|
|
|
/* The arrival check run again on the offered stick, now that the mint has
|
|
* written its GPT and identity (it is then recognised as the real Zuse's). */
|
|
void sk_v4_identity_recheck_offered(void);
|
|
|
|
/* The 64 bytes the identity code mints and reads Zuse's seed into while it handles a drive (seed,
|
|
* then its read-back): zero whenever no drive is being handled (#176). For the host tests. */
|
|
const uint8_t *sk_v4_identity_seeds(void);
|
|
|
|
/* Headless: no prompt, and what is typed is read and dropped, until Zuse's
|
|
* session begins (v3's sk_repl_headless_wait()). */
|
|
void sk_v4_identity_wait(void);
|
|
|
|
#endif /* STARKERNEL_V4_SK_V4_IDENTITY_H */
|