From 75e78d4e06a3b7e35f78bf5cba5951035d46fd85 Mon Sep 17 00:00:00 2001 From: "kitokey-marc[bot]" <356215105+kitokey-marc[bot]@users.noreply.github.com> Date: Sat, 14 Nov 2026 15:32:04 +0100 Subject: [PATCH 1/4] =?UTF-8?q?shell:=20D56's=20oracle=20=E2=80=94=20the?= =?UTF-8?q?=20list=20read=20again=20under=20the=20key=20built=20in,=20the?= =?UTF-8?q?=20decider's=20(red)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The key built in is the decider's, by its number (28AD0E835D7AF31E). Under it, a list signed by another key, changed after the decider signed it, or unsigned is refused for its signature; the list on main with the decider's signature is taken. The test lists are signed by a key the test makes, or are main's with the signature the decider made of it. The e2e's W reads the list again through the window the same way. Red: no key is built in. Taken up from #643, by dime-hermes. Agent-Session: 14f73956-90b9-46a3-9fcc-52dc45c43948 Co-Authored-By: dime-hermes[bot] <349604419+dime-hermes[bot]@users.noreply.github.com> Co-Authored-By: Claude Opus 5.5 --- modules/shell/AGENTS.md | 2 +- modules/shell/README.md | 4 +- modules/shell/scripts/e2e_window.py | 60 +++++++++++++++++---------- modules/shell/tests/registry_fetch.rs | 52 +++++++++++++++++++++++ 4 files changed, 94 insertions(+), 24 deletions(-) diff --git a/modules/shell/AGENTS.md b/modules/shell/AGENTS.md index 6171380d..4dfce03b 100644 --- a/modules/shell/AGENTS.md +++ b/modules/shell/AGENTS.md @@ -18,7 +18,7 @@ Puts Kitokey's four steps in the user's hands: a tray, a global shortcut, notifi ## Internal conventions nobody could guess - Every sentence the user reads is in `src/words.rs`, in each language the interface speaks — English and French, following the system's (the decider, 2026-10-13). They are the product's content: the one place where this repository holds another language than English. A sentence written anywhere else is a defect. They are written to the voice guide, [`docs/voice.md`](docs/voice.md): its principles, its lexicon, its templates and the comment each sentence carries. -- The Whisper models Settings offer are `registry/models.json`, built in (`src/registry.rs`, D40, ADR-0010): a model is added or removed there, never in the code. Each says what it is good for by a key whose sentence is in `src/words.rs`; a new key needs its sentence first. The shell's tests read the file: one that does not read, or names a host other than `registry::HOSTS`, fails them. Its first model stays this build's default (`model::DEFAULT`): a list read again that puts another first is refused, the default being what a transcript waits for and the tray fetches. Read again, a list is taken only signed by the decider's key (`registry::PUBLIC_KEY`, D56): once that key is built in, a change to the file is followed by their `minisign -Sm`, or the shell's tests refuse it. `registry/.gitattributes` keeps the file's bytes as signed, on Windows too. +- The Whisper models Settings offer are `registry/models.json`, built in (`src/registry.rs`, D40, ADR-0010): a model is added or removed there, never in the code. Each says what it is good for by a key whose sentence is in `src/words.rs`; a new key needs its sentence first. The shell's tests read the file: one that does not read, or names a host other than `registry::HOSTS`, fails them. Its first model stays this build's default (`model::DEFAULT`): a list read again that puts another first is refused, the default being what a transcript waits for and the tray fetches. Read again, a list is taken only signed by the decider's key (`registry::PUBLIC_KEY`, `28AD0E835D7AF31E`, D56). **A change to the file is signed by the decider**, in their own terminal — `minisign -Sm modules/shell/registry/models.json` —, and its `models.json.minisig` committed with it: an agent never holds, makes or asks for the private key, and never signs; until the decider's signature is there, the shell's tests refuse the change. `registry/.gitattributes` keeps the file's bytes as signed, on Windows too. - Decided before any code (ADR-0002, cycle 01 *D1*): Tauri v2; under GNOME the global shortcut and the window's coming forward go through the desktop's portal, not the toolkit's plugin; the tray's menu holds the actions themselves, since it cannot bring a window forward there. ## Business invariants diff --git a/modules/shell/README.md b/modules/shell/README.md index 72212383..1671b3e7 100644 --- a/modules/shell/README.md +++ b/modules/shell/README.md @@ -265,8 +265,8 @@ the Whisper models of [`registry/models.json`](registry/models.json), the list s ADR-0010), and for the minutes `qwen3:8b` fetched by Ollama's own pull (`POST /api/pull`) —, one fetch at a time. The Whisper models are read again from `main` only on *Mettre à jour la liste (raw.githubusercontent.com)*, and offered then until Kitokey quits, only when the -decider's minisign key signed them (D56). Until that key is built in, no list is read again and -*Réglages* say it waits on it; a list that cannot be read, unsigned, signed by another key or changed since leaves the one offered, and says so; a model fetched joins those to choose, the choice staying the +decider's minisign key signed them (D56): its public key, `28AD0E835D7AF31E`, is built in +(`registry::PUBLIC_KEY`). A list that cannot be read, unsigned, signed by another key or changed since leaves the one offered, and says so; a model fetched joins those to choose, the choice staying the user's. With no Ollama answering, the row says where to get it: Kitokey never installs it (D37). A model the settings name, and which is not there, is said with where it was looked for: it is the user's own, never fetched. diff --git a/modules/shell/scripts/e2e_window.py b/modules/shell/scripts/e2e_window.py index 62d59350..f2e3bf67 100644 --- a/modules/shell/scripts/e2e_window.py +++ b/modules/shell/scripts/e2e_window.py @@ -903,19 +903,23 @@ def copyfile(self, source, sink): def list_refreshed(now: dt.datetime) -> None: - """W. The list of models is read again only signed by the decider's key: until it is built in, none is (D40, D56).""" - print("W. Settings: no list of models read again until the decider's key is built in, and it is said (D40, D56)") - # When registry::PUBLIC_KEY is set, this scenario changes: the button is back, its host shown, - # and an unsigned list served here is refused. The signed path is the shell's tests' - # (tests/registry_fetch.rs), with a key of their own: no window can hold a key a test made. - asked = [] + """W. The list of models is read again only signed by the decider's key, built in (D40, D56).""" + print("W. Settings: a list of models read again is taken only signed by the decider's key; refused, it is said (D40, D56)") + # Served here: the list on main, with the decider's signature of it (registry/models.json.minisig), + # none, or the list changed after it was signed. A key a test made is the shell's tests' only + # (tests/registry_fetch.rs): no window holds one. + registry = Path(__file__).parent.parent / "registry" + shipped, signature = (registry / "models.json").read_bytes(), (registry / "models.json.minisig").read_bytes() + asked, serving = [], {"list": shipped, "signature": signature} class List(http.server.BaseHTTPRequestHandler): def do_GET(self): asked.append(self.path) - self.send_response(404) - self.send_header("Content-Length", "0") + body = serving["signature"] if self.path.endswith(".minisig") else serving["list"] + self.send_response(404 if body is None else 200) + self.send_header("Content-Length", str(len(body or b""))) self.end_headers() + self.wfile.write(body or b"") def log_message(self, *_): pass @@ -930,21 +934,35 @@ def log_message(self, *_): window.env.update(KITOKEY_REGISTRY=f"http://{at}/models.json") with window as browser: browser.find_element(By.ID, "settings-link").click() - waits = wait_for(browser, lambda b: "attend la clé qui la signe" in b.execute_script(said), 10) - check("Settings say the list waits on the key that signs it, and the models stay offered", - waits and "restent proposés" in browser.execute_script(said) - and browser.find_elements(By.CSS_SELECTOR, '[data-offered="ggml-small-q8_0.bin"]'), - browser.execute_script(said)) - check("no button offers to read it again", not browser.find_elements(By.ID, "offered-refresh")) - # Asked all the same, it is refused, and logged so, with nothing asked of anyone. - browser.execute_script("window.__TAURI__.core.invoke('registry_refresh').then(() => { window.listRead = 'read'; }, () => { window.listRead = 'refused'; })") - answered = wait_for(browser, lambda b: b.execute_script("return window.listRead || ''"), 10) - check("asked all the same, it is refused, and nothing crosses the network", - answered and browser.execute_script("return window.listRead") == "refused" and asked == [], - (browser.execute_script("return window.listRead"), asked)) + button = wait_for(browser, lambda b: b.find_elements(By.ID, "offered-refresh"), 10) + check("the key built in: a button offers to read the list again, its host shown, nothing said of a key awaited", + button and at in browser.find_element(By.ID, "offered-refresh").text and "attend la clé" not in browser.execute_script(said) + and asked == [], (browser.execute_script(said), asked)) + + def read_again(what: str, list_: bytes, signature: bytes | None) -> str: + """The list served as `what` says, the button pressed: what the page says after it.""" + serving.update(list=list_, signature=signature) + asked.clear() + browser.find_element(By.ID, "offered-refresh").click() + wait_for(browser, lambda b: b.execute_script(said) or len(asked) == 2 and b.find_elements(By.ID, "offered-refresh") + and b.find_element(By.ID, "offered-refresh").is_enabled(), 10) + time.sleep(0.5) + return browser.execute_script(said) + + for what, list_, signature_ in [("unsigned", shipped, None), + ("changed after the decider signed it", shipped.replace(b'"version": 1', b'"version": 1', 1), signature), + ("its signature none", shipped, b"")]: + refusal = read_again(what, list_, signature_) + check(f"a list {what}: refused, said, the models shipped still offered", + "n’a pas pu être mise à jour" in refusal and "restent proposés" in refusal + and asked == ["/models.json", "/models.json.minisig"] + and browser.find_elements(By.CSS_SELECTOR, '[data-offered="ggml-small-q8_0.bin"]'), (refusal, asked)) + taken = read_again("the decider's", shipped, signature) + check("the list the decider signed: taken, nothing said against it, its models offered", + "n’a pas pu" not in taken and asked == ["/models.json", "/models.json.minisig"] + and browser.find_elements(By.CSS_SELECTOR, '[data-offered="ggml-small-q8_0.bin"]'), (taken, asked)) server.shutdown() - def speech_offered(now: dt.datetime) -> None: """X. On a Mac, Apple's SpeechAnalyzer is offered among who hears, its model fetched on the click (D42).""" print("X. Settings: Apple's SpeechAnalyzer offered where this Mac offers it, its model fetched on the click (D42)") diff --git a/modules/shell/tests/registry_fetch.rs b/modules/shell/tests/registry_fetch.rs index 00b6dd9b..5139bd6e 100644 --- a/modules/shell/tests/registry_fetch.rs +++ b/modules/shell/tests/registry_fetch.rs @@ -221,3 +221,55 @@ fn the_list_in_the_repository_verifies_or_waits_on_the_key_and_the_check_says_wh // Straight to the error stream: what the test harness captures would not be seen when it passes. writeln!(std::io::stderr(), "registry/models.json: {said}").unwrap(); } + +// Under the key built in (D56): the decider's, made in their own terminal — its private key in no +// repository and no session. The lists here are signed by a test's key, or are the list on `main` +// with the signature the decider made of it, `registry/models.json.minisig`. + +/// The decider's key, as its `.pub` names it: `minisign public key 28AD0E835D7AF31E`. +const DECIDERS_KEY_ID: &str = "28AD0E835D7AF31E"; + +/// The signature the decider made of the list in the repository. +fn deciders_signature() -> String { + std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/registry/models.json.minisig")) + .expect("registry/models.json.minisig, the decider's signature of the list") +} + +#[test] +fn the_key_built_in_is_the_deciders() { + let key = registry::PUBLIC_KEY.expect("a key built in"); + let key = minisign::PublicKey::from_base64(key).unwrap(); + // minisign shows a key's number as its eight bytes read little-endian. + let id: String = key.keynum().iter().rev().map(|byte| format!("{byte:02X}")).collect(); + assert_eq!(id, DECIDERS_KEY_ID); +} + +#[test] +fn under_the_key_built_in_a_list_signed_by_another_key_changed_after_it_was_signed_or_unsigned_is_refused() { + let list = registry::SHIPPED.to_owned(); + let refused = [ + ("signed by another key", signed_by(&test_key(), list.clone())), + ( + "changed after the decider signed it", + served_with( + 200, + list.replacen("\"version\": 1", "\"version\": 1", 1), + "", + Some(deciders_signature()), + ), + ), + ("unsigned", served_with(200, list.clone(), "", None)), + ]; + for (what, served) in refused { + let why = registry::fetch(&served.address, registry::PUBLIC_KEY).expect_err(what); + assert!(why.contains("signature") && !why.contains("waits"), "{what}: {why}"); + assert_eq!(*served.asked.lock().unwrap(), ["/models.json", "/models.json.minisig"], "{what}"); + } +} + +#[test] +fn under_the_key_built_in_the_list_the_decider_signed_is_taken() { + let served = served_with(200, registry::SHIPPED.to_owned(), "", Some(deciders_signature())); + let listed = registry::fetch(&served.address, registry::PUBLIC_KEY).unwrap(); + assert_eq!(listed, registry::shipped()); +} From 8cfec817da46fdcf8191422efe5f8e511438cd06 Mon Sep 17 00:00:00 2001 From: "kitokey-marc[bot]" <356215105+kitokey-marc[bot]@users.noreply.github.com> Date: Sat, 14 Nov 2026 15:32:23 +0100 Subject: [PATCH 2/4] =?UTF-8?q?shell:=20the=20decider's=20key=20built=20in?= =?UTF-8?q?=20=E2=80=94=20a=20list=20read=20again=20is=20taken=20only=20un?= =?UTF-8?q?der=20it=20(D56)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `registry::PUBLIC_KEY`, `minisign public key 28AD0E835D7AF31E`, made in the decider's own terminal. Settings offer the list read again from then on; one unsigned, signed by another key or changed since is refused, and said. The list in the repository is signed by the decider alone, its .minisig committed beside it. Taken up from #643, by dime-hermes. Agent-Session: 14f73956-90b9-46a3-9fcc-52dc45c43948 Co-Authored-By: dime-hermes[bot] <349604419+dime-hermes[bot]@users.noreply.github.com> Co-Authored-By: Claude Opus 5.5 --- modules/shell/src/registry.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/modules/shell/src/registry.rs b/modules/shell/src/registry.rs index a1a5cdbe..1aeba653 100644 --- a/modules/shell/src/registry.rs +++ b/modules/shell/src/registry.rs @@ -13,10 +13,10 @@ pub const SHIPPED: &str = include_str!("../registry/models.json"); /// Where the list is read again from, on the user's gesture: the file on `main`. pub const ADDRESS: &str = "https://raw.githubusercontent.com/NapkinStack/wholeheard/main/modules/shell/registry/models.json"; -/// The decider's public key, as `minisign -G` writes it on the second line of its `.pub` file. -/// None until they give it (cycle 05, *Dependency with a date*): no list is read again, Settings -/// say so, and so does the check of the list in the repository. -pub const PUBLIC_KEY: Option<&str> = None; +/// The decider's public key, as `minisign -G` writes it on the second line of its `.pub` file: +/// `minisign public key 28AD0E835D7AF31E`, made in their own terminal (D56). Its private key is in +/// no repository and no session: a list is signed by the decider alone (`AGENTS.md`). +pub const PUBLIC_KEY: Option<&str> = Some("RWQe83pdgw6tKGbfv/lHOXQkpVU+KJcfXp3KiOmb2JIVn9Lz0ojPkotS"); /// What no list is read again without, said to the logs and to whoever reads the check. const WAITS: &str = "the list is not read again: it waits on the decider's key"; From c5b31c289350e1c51d29552f35b304d75f25b07b Mon Sep 17 00:00:00 2001 From: "kitokey-marc[bot]" <356215105+kitokey-marc[bot]@users.noreply.github.com> Date: Sat, 14 Nov 2026 15:33:06 +0100 Subject: [PATCH 3/4] shell: the decider's signature of the list, and their public key's file (D56) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit models.json.minisig, made by the decider in their own terminal over models.json at 1d6ee69 (sha256 1627839e…046b), verified by minisign -Vm against kitokey-models.pub. Both public. A change to models.json is signed again by the decider. Agent-Session: 14f73956-90b9-46a3-9fcc-52dc45c43948 Co-Authored-By: dime-hermes[bot] <349604419+dime-hermes[bot]@users.noreply.github.com> Co-Authored-By: Claude Opus 5.5 --- modules/shell/registry/kitokey-models.pub | 2 ++ modules/shell/registry/models.json.minisig | 4 ++++ 2 files changed, 6 insertions(+) create mode 100644 modules/shell/registry/kitokey-models.pub create mode 100644 modules/shell/registry/models.json.minisig diff --git a/modules/shell/registry/kitokey-models.pub b/modules/shell/registry/kitokey-models.pub new file mode 100644 index 00000000..126ef485 --- /dev/null +++ b/modules/shell/registry/kitokey-models.pub @@ -0,0 +1,2 @@ +untrusted comment: minisign public key 28AD0E835D7AF31E +RWQe83pdgw6tKGbfv/lHOXQkpVU+KJcfXp3KiOmb2JIVn9Lz0ojPkotS diff --git a/modules/shell/registry/models.json.minisig b/modules/shell/registry/models.json.minisig new file mode 100644 index 00000000..73bfd2d4 --- /dev/null +++ b/modules/shell/registry/models.json.minisig @@ -0,0 +1,4 @@ +untrusted comment: signature from minisign secret key +RUQe83pdgw6tKImxS0WO+2AtWJxhUZW8MwcdKJSoAfZ+6m8wvlJLg37hMFYt6jN3APScM0ql3hN5doGMauTQo4MJ3uPmhklIoAw= +trusted comment: timestamp:1794666686 file:models.json hashed +i8noTVJYzVjkIq8Lz3xIs0izQPgaMbaHj5evFVNUkc2YCQo5WOWM0QDSW1sE6t0LyxilorV6mLEVxSlecefaCA== From 044856c0a3b361866753a224cd9c0af9688f3520 Mon Sep 17 00:00:00 2001 From: "kitokey-marc[bot]" <356215105+kitokey-marc[bot]@users.noreply.github.com> Date: Sat, 14 Nov 2026 15:49:54 +0100 Subject: [PATCH 4/4] shell: a list signed in minisign's legacy form is refused, and a test says so (D56) `LEGACY_ALLOWED`, false, named where `verify` passes it. The test's lists are signed by a key made outside it (openssl's Ed25519, minisign's boxes; its private key not kept), the same bytes both ways: pre-hashed, verified; legacy, refused. With `true` passed, the test fails (ines's survivor on #825). Agent-Session: 14f73956-90b9-46a3-9fcc-52dc45c43948 Co-Authored-By: Claude Opus 5.5 --- modules/shell/src/registry.rs | 6 +++++- modules/shell/tests/registry_fetch.rs | 19 +++++++++++++++++++ 2 files changed, 24 insertions(+), 1 deletion(-) diff --git a/modules/shell/src/registry.rs b/modules/shell/src/registry.rs index 1aeba653..1605a073 100644 --- a/modules/shell/src/registry.rs +++ b/modules/shell/src/registry.rs @@ -99,13 +99,17 @@ fn answered(agent: &ureq::Agent, address: &str, limit: usize) -> Result Result<(), String> { let key = minisign_verify::PublicKey::from_base64(key).map_err(|error| format!("the key built in does not read ({error})"))?; let signature = minisign_verify::Signature::decode(signature).map_err(|error| format!("the list's signature does not read ({error})"))?; - key.verify(list.as_bytes(), &signature, false) + key.verify(list.as_bytes(), &signature, LEGACY_ALLOWED) .map_err(|error| format!("the list's signature does not verify ({error})")) } diff --git a/modules/shell/tests/registry_fetch.rs b/modules/shell/tests/registry_fetch.rs index 5139bd6e..ab18e179 100644 --- a/modules/shell/tests/registry_fetch.rs +++ b/modules/shell/tests/registry_fetch.rs @@ -273,3 +273,22 @@ fn under_the_key_built_in_the_list_the_decider_signed_is_taken() { let listed = registry::fetch(&served.address, registry::PUBLIC_KEY).unwrap(); assert_eq!(listed, registry::shipped()); } + +/// A key made for this test, outside it (openssl's Ed25519, the boxes as minisign writes them): +/// `minisign` the crate writes the pre-hashed form only. Its private key was not kept. +const FIXED_KEY: &str = "RWQBI0VniavN7wWzl40CApIQMFl5I82eP9r51HLn0+S12rpml2YUEJMN"; +/// What that key signed, both ways. +const FIXED_LIST: &str = "A list signed by a key made for this test.\n"; +/// Its signature in minisign's pre-hashed form, `ED`: what `minisign -S` writes. +const PREHASHED: &str = "untrusted comment: signature from minisign secret key\nRUQBI0VniavN7wrzXTMs5fdRG6KVz+5THLiu+a8cBCxN3Z4DuDpIiu2Cuw6V6r3uIeRW5H2FQ8B7Md7iETvI1lBzIvFSaYz98gs=\ntrusted comment: timestamp:1794666686\tfile:models.json\thashed\njSaui6oed+w24Xpc7qoBDxGb4ESZQFH+G1ZlPTqlNFx0oGA4rwdySDORy0ZpX4bGnpIEqTcPo1qHunqdHT7GAg==\n"; +/// The same bytes signed in the legacy form, `Ed`: the list itself, not its hash. +const LEGACY: &str = "untrusted comment: signature from minisign secret key\nRWQBI0VniavN77JORcfb0/qk/S+eZJButt7IBOw0QkA5tgFZ6PaeIDWMDMQx9jpkVazHbKuJl/LBc6SjE2HJrM8V5/wcGoAWZgo=\ntrusted comment: timestamp:1794666686\tfile:models.json\thashed\ns6BDg+gP07KNfUzg51q7MJUZRhiw6Jt2I5D/UARqlcYKY/Z/aty8y7kYp9vXkt8Ezy0bjBGe/WWugAD6UjjkBA==\n"; + +#[test] +fn a_list_signed_in_minisigns_legacy_form_is_refused() { + // The same key and bytes, pre-hashed: verified — the refusal below is the form's alone. + assert_eq!(registry::verify(FIXED_LIST, PREHASHED, FIXED_KEY), Ok(())); + let why = registry::verify(FIXED_LIST, LEGACY, FIXED_KEY).unwrap_err(); + assert!(why.contains("signature"), "{why}"); + assert!(registry::in_the_repository(FIXED_LIST, Some(LEGACY), Some(FIXED_KEY)).is_err()); +}