From a1e398621eec9472ad67f1eafeba9ff23b012c2f Mon Sep 17 00:00:00 2001 From: slopulus Date: Tue, 17 Nov 2026 19:57:56 +0100 Subject: keys: a party's key may be ecdsa-sha2-nistp256, its signature low-S only A party's keys may be held where no file has them, in a Secure Enclave or a phone, and those are ECDSA keys on NIST P-256. Everywhere a party's key counts (a version's keys, a key set, the key an event is signed with) such a key is taken beside an Ed25519 one, spelled as `ssh-keygen` writes it, without a comment: `ecdsa-sha2-nistp256`, a space, and the base64 of its SSH encoding, its point uncompressed and on the curve. Its signature is SSHSIG as an Ed25519 one is, hashed with `sha512`, its inner signature over SHA-256 as SSH signs with such a key. ECDSA signatures are malleable: of `s` and the curve's order less `s`, both check. So the federation takes one spelling alone: `s` low, at most half the order, `r` and `s` each SSH's shortest mpint, and the blob reading back to itself as an Ed25519 one does. What anyone makes of a party's signature is then none, as before. The vectors are a key `ssh-keygen -t ecdsa -b 256` made, a first version naming it, and a write and a key set `ssh-keygen -Y sign` signed with it, each taken; the signature's high-S twin, which checks as ECDSA, and its `r` spelled longer are none. Ed25519 keys and signatures are spelled and checked as they were. --- src/federation/party.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'src/federation/party.rs') diff --git a/src/federation/party.rs b/src/federation/party.rs index f0ae288..21e1fb7 100644 --- a/src/federation/party.rs +++ b/src/federation/party.rs @@ -42,6 +42,7 @@ use super::client::{self, Record}; use super::event::{self, Does, Event, Signed}; use super::fold::Federation; use super::jcs::Json; +use super::keys::Key; use super::store::Id; use super::store::memory::Store; use super::version::Version; @@ -282,7 +283,7 @@ pub(crate) async fn main() -> Result<()> { let keys = strings(sub, "keys") .iter() .map(|line| { - PublicKey::parse(line) + Key::parse(line) .map(|key| key.line()) .map_err(|why| anyhow!("{line:?}: {why}")) }) -- cgit v1.3.1 From bcda4d67483239691b045c5b978047f017f3b9e3 Mon Sep 17 00:00:00 2001 From: slopulus Date: Tue, 17 Nov 2026 20:01:42 +0100 Subject: continuum-party: signing through an ssh-agent A key held in hardware is never a file: only an ssh-agent signs with it. Given a public key as `--key` (a `.pub` file, `ssh-ed25519` or `ecdsa-sha2-nistp256`), the client asks the agent at `SSH_AUTH_SOCK` to sign what SSHSIG signs (a sign request with the key's blob, no flags) and writes the blob around the agent's signature as `ssh-keygen -Y sign` does. An ECDSA signature the agent gives with a high `s` is made low, the other of its two spellings, which the federation takes. What it makes is checked before it is used. A private key file signs as it did. A test starts `ssh-agent`, adds an ECDSA and an Ed25519 key to it and deletes their files, signs through it, and has both continuum and `ssh-keygen -Y verify` check each signature, one of an agent's high-S answers among them. Without OpenSSH it asks nothing. --- src/config/mod.rs | 2 +- src/federation/agent.rs | 45 +++++++++++++++ src/federation/event.rs | 22 ++++++-- src/federation/keys.rs | 146 ++++++++++++++++++++++++++++++++++++++++++++++++ src/federation/mod.rs | 1 + src/federation/party.rs | 55 +++++++++++++----- 6 files changed, 251 insertions(+), 20 deletions(-) create mode 100644 src/federation/agent.rs (limited to 'src/federation/party.rs') diff --git a/src/config/mod.rs b/src/config/mod.rs index 533b44c..2ff0a45 100644 --- a/src/config/mod.rs +++ b/src/config/mod.rs @@ -752,7 +752,7 @@ pub(crate) const PARTY_OPTIONS: &[OptionSpec] = &[ Kind::Text, "PATH", None, - "The party's key it signs with: an OpenSSH private key file, unencrypted", + "The party's key it signs with: an OpenSSH private key file, unencrypted, of an Ed25519 key; or a public key file (ssh-ed25519 or ecdsa-sha2-nistp256), signed with through the ssh-agent at SSH_AUTH_SOCK", ), option( "record", diff --git a/src/federation/agent.rs b/src/federation/agent.rs new file mode 100644 index 0000000..a41cf1a --- /dev/null +++ b/src/federation/agent.rs @@ -0,0 +1,45 @@ +//! What a party's client asks of an ssh-agent (draft-ietf-sshm-ssh-agent, as OpenSSH's +//! `ssh-agent` speaks it): a signature by a key it holds, so the key itself needn't be a +//! file, or anywhere but the agent. + +use std::io::{Read, Write}; +use std::os::unix::net::UnixStream; +use std::path::Path; + +use crate::access::sshsig::{Reader, string}; + +const SIGN_REQUEST: u8 = 13; +const SIGN_RESPONSE: u8 = 14; +/// The longest answer read: a signature is far shorter. +const LONGEST: usize = 64 * 1024; + +/// The signature of `data` by the key whose SSH encoding is `key`, from the agent at +/// `socket`: its type and its bytes, each a string, as SSH encodes a signature. +pub(crate) fn sign(socket: &Path, key: &[u8], data: &[u8]) -> Result, String> { + let failed = |error: std::io::Error| format!("the ssh-agent at {}: {error}", socket.display()); + let mut request = vec![SIGN_REQUEST]; + string(&mut request, key); + string(&mut request, data); + request.extend_from_slice(&0u32.to_be_bytes()); + let mut message = Vec::new(); + string(&mut message, &request); + let mut stream = UnixStream::connect(socket).map_err(failed)?; + stream.write_all(&message).map_err(failed)?; + let mut length = [0; 4]; + stream.read_exact(&mut length).map_err(failed)?; + let length = u32::from_be_bytes(length) as usize; + if length > LONGEST { + return Err("the ssh-agent's answer is longer than a signature".to_owned()); + } + let mut answer = vec![0; length]; + stream.read_exact(&mut answer).map_err(failed)?; + let Some((&SIGN_RESPONSE, rest)) = answer.split_first() else { + return Err( + "the ssh-agent signs nothing: it holds no such key, or was told not to".to_owned(), + ); + }; + let mut reader = Reader(rest); + let signature = reader.string()?; + reader.end()?; + Ok(signature.to_vec()) +} diff --git a/src/federation/event.rs b/src/federation/event.rs index 15cee45..864bedb 100644 --- a/src/federation/event.rs +++ b/src/federation/event.rs @@ -21,6 +21,21 @@ pub(crate) fn signed( deps: &[Id], does: (&str, Json), ) -> Vec { + signed_by(party, key, deps, does, |bytes| { + Ok(keys::sign(signer, bytes)) + }) + .expect("a key at hand signs") +} + +/// An event `party` signs, its key spelled `key`, on `deps`, doing `does`: its bytes, as +/// JCS, with the signature `sign` makes of them without `sig`, where it makes one. +pub(crate) fn signed_by( + party: &str, + key: &str, + deps: &[Id], + does: (&str, Json), + sign: impl FnOnce(&[u8]) -> Result, +) -> Result, String> { let mut members = vec![ ("deps".to_owned(), ids(deps)), ("party".to_owned(), Json::Str(party.to_owned())), @@ -28,11 +43,8 @@ pub(crate) fn signed( (does.0.to_owned(), does.1), ]; let unsigned = Json::object(members.clone()).expect("names once each"); - members.push(( - "sig".to_owned(), - Json::Str(keys::sign(signer, &unsigned.bytes())), - )); - Json::object(members).expect("names once each").bytes() + members.push(("sig".to_owned(), Json::Str(sign(&unsigned.bytes())?))); + Ok(Json::object(members).expect("names once each").bytes()) } /// What writing `value` at `path` does. diff --git a/src/federation/keys.rs b/src/federation/keys.rs index ee5f01e..a795db7 100644 --- a/src/federation/keys.rs +++ b/src/federation/keys.rs @@ -13,6 +13,8 @@ //! //! So nobody but its signer makes another event of what a party signed. +use std::path::Path; + use base64::{Engine, engine::general_purpose::STANDARD as BASE64}; use ed25519_dalek::{SigningKey, VerifyingKey}; use p256::ecdsa::signature::Verifier; @@ -193,6 +195,38 @@ pub(crate) fn sign(key: &SigningKey, message: &[u8]) -> String { BASE64.encode(blob) } +/// `message` signed with `key` by the ssh-agent at `socket`, as the federation spells a +/// signature: what `ssh-keygen -Y sign -n continuum-federation` makes through the agent, +/// unarmored, an ECDSA signature's `s` made low. +pub(crate) fn sign_through(socket: &Path, key: &Key, message: &[u8]) -> Result { + let answer = super::agent::sign(socket, &key.blob(), &signed(message))?; + from_agent(key, &answer, message) +} + +/// The federation's signature of `message` by `key` from `answer`, the signature the agent +/// made of what SSHSIG signs, as SSH encodes one. +fn from_agent(key: &Key, answer: &[u8], message: &[u8]) -> Result { + let mut reader = Reader(answer); + if reader.string()? != key.kind().as_bytes() { + return Err(format!("the agent's signature isn't an {} one", key.kind())); + } + let signature = reader.string()?; + reader.end()?; + let signature = match key { + Key::Ed25519(_) => signature.to_vec(), + Key::P256(_) => mpints( + &ecdsa_signature(signature) + .ok_or("the agent's signature isn't an ECDSA one")? + .normalize_s(), + ), + }; + let sig = BASE64.encode(written(key, &signature)); + if !verifies(key, &sig, message) { + return Err("the agent's signature doesn't check".to_owned()); + } + Ok(sig) +} + /// What a signature of `message` is made over: SSHSIG's signed data, hashed with `sha512`. fn signed(message: &[u8]) -> Vec { sshsig::signed_data( @@ -367,4 +401,116 @@ mod tests { string(&mut negative, s); refused(&negative); } + + /// A signature through a running `ssh-agent` checks here and with `ssh-keygen -Y + /// verify`, of an ECDSA key the agent alone holds and of an Ed25519 one; of ECDSA, also + /// one the agent gave with a high `s`. Where OpenSSH isn't installed, nothing is asked. + #[test] + fn signs_through_an_ssh_agent() { + use std::process::{Command, Stdio}; + let dir = std::env::temp_dir().join(format!("continuum-agent-{}", std::process::id())); + std::fs::create_dir_all(&dir).expect("a directory"); + let socket = dir.join("agent"); + let agent = match Command::new("ssh-agent") + .arg("-D") + .arg("-a") + .arg(&socket) + .stdout(Stdio::null()) + .spawn() + { + Ok(agent) => agent, + Err(error) if error.kind() == std::io::ErrorKind::NotFound => { + eprintln!("no ssh-agent: skipped"); + return; + } + Err(error) => panic!("ssh-agent: {error}"), + }; + struct Stop(std::process::Child, std::path::PathBuf); + impl Drop for Stop { + fn drop(&mut self) { + let _ = self.0.kill(); + let _ = self.0.wait(); + let _ = std::fs::remove_dir_all(&self.1); + } + } + let _stop = Stop(agent, dir.clone()); + for _ in 0..100 { + if socket.exists() { + break; + } + std::thread::sleep(std::time::Duration::from_millis(50)); + } + let run = |command: &mut Command| { + let out = command + .env("SSH_AUTH_SOCK", &socket) + .output() + .expect("OpenSSH"); + assert!(out.status.success(), "{command:?}: {out:?}"); + }; + for kind in [["-t", "ecdsa", "-b", "256"].as_slice(), &["-t", "ed25519"]] { + let file = dir.join(kind[1]); + run(Command::new("ssh-keygen") + .args(kind) + .args(["-q", "-N", "", "-C", "", "-f"]) + .arg(&file)); + run(Command::new("ssh-add").arg("-q").arg(&file)); + std::fs::remove_file(&file).expect("the private key's file"); + let pub_line = std::fs::read_to_string(file.with_extension("pub")).expect("a .pub"); + let key = Key::parse(&pub_line).expect("a key"); + let allowed = dir.join("allowed"); + std::fs::write(&allowed, format!("party {}\n", key.line())).expect("written"); + let checked = |sig: &str, message: &[u8]| { + assert!(verifies(&key, sig, message)); + let blob = BASE64.decode(sig).expect("base64"); + let mut armored = "-----BEGIN SSH SIGNATURE-----\n".to_owned(); + for line in BASE64.encode(&blob).as_bytes().chunks(70) { + armored.push_str(std::str::from_utf8(line).expect("ASCII")); + armored.push('\n'); + } + armored.push_str("-----END SSH SIGNATURE-----\n"); + let file = dir.join("sig"); + std::fs::write(&file, armored).expect("written"); + let mut verify = Command::new("ssh-keygen") + .args(["-Y", "verify", "-I", "party", "-n", NAMESPACE, "-f"]) + .arg(&allowed) + .arg("-s") + .arg(&file) + .stdin(Stdio::piped()) + .stdout(Stdio::null()) + .spawn() + .expect("ssh-keygen"); + use std::io::Write; + verify + .stdin + .take() + .expect("its input") + .write_all(message) + .expect("written"); + assert!(verify.wait().expect("ssh-keygen").success()); + }; + let message = format!("an event, by {}", kind[1]); + checked( + &sign_through(&socket, &key, message.as_bytes()).expect("signed"), + message.as_bytes(), + ); + if let Key::P256(_) = key { + let data = signed(message.as_bytes()); + let high = (0..64) + .map(|_| { + super::super::agent::sign(&socket, &key.blob(), &data).expect("signed") + }) + .find(|answer| { + let mut reader = Reader(answer); + let _ = reader.string(); + let parsed = ecdsa_signature(reader.string().unwrap()).unwrap(); + parsed.normalize_s() != parsed + }) + .expect("a high `s` among 64 signatures"); + checked( + &from_agent(&key, &high, message.as_bytes()).expect("made low"), + message.as_bytes(), + ); + } + } + } } diff --git a/src/federation/mod.rs b/src/federation/mod.rs index f7853e7..bb14be3 100644 --- a/src/federation/mod.rs +++ b/src/federation/mod.rs @@ -7,6 +7,7 @@ // Built stage by stage: parts of it are used by nothing yet, or by tests alone. #![allow(dead_code)] +pub(crate) mod agent; #[cfg(test)] mod attacks; pub(crate) mod client; diff --git a/src/federation/party.rs b/src/federation/party.rs index 21e1fb7..4ba51ed 100644 --- a/src/federation/party.rs +++ b/src/federation/party.rs @@ -1,9 +1,10 @@ //! `continuum-party`: a party's client of a federation (`docs/federation.md`). It signs its -//! party's events with one of its keys (an OpenSSH private key file, `--key`), puts them -//! through a node's API (`--node`, its user and password in the URL, or `--token`), and -//! keeps its party's record (`--record`, `client::Record`), by which it votes, written -//! before a vote is sent. Its options may be set in configuration files as the node's are -//! (`--config`, `config::PARTY_OPTIONS`): the same format, imports and all. +//! party's events with one of its keys (`--key`: an OpenSSH private key file, or a public +//! key the ssh-agent at `SSH_AUTH_SOCK` holds), puts them through a node's API (`--node`, +//! its user and password in the URL, or `--token`), and keeps its party's record +//! (`--record`, `client::Record`), by which it votes, written before a vote is sent. Its +//! options may be set in configuration files as the node's are (`--config`, +//! `config::PARTY_OPTIONS`): the same format, imports and all. //! //! * `init PARTY`: begins a record of `PARTY`, on the version current now; with `--root //! FILE`, from the file the store's swarm starts from, for a party that never voted in @@ -42,7 +43,7 @@ use super::client::{self, Record}; use super::event::{self, Does, Event, Signed}; use super::fold::Federation; use super::jcs::Json; -use super::keys::Key; +use super::keys::{self, Key}; use super::store::Id; use super::store::memory::Store; use super::version::Version; @@ -342,25 +343,51 @@ fn strings(matches: &ArgMatches, name: &str) -> Vec { .collect() } -fn signing_key(options: &Options) -> Result { +/// The key `--key` names: a private key file's, or a public key's, held by the ssh-agent. +fn signing_key(options: &Options) -> Result { let file = options .key .as_ref() .context("--key names the party's key")?; let text = std::fs::read_to_string(file).with_context(|| format!("Reading {file}"))?; - client::signing_key(&text).map_err(|why| anyhow!("{file}: {why}")) + if let Ok(key) = Key::parse(&text) { + let socket = std::env::var_os("SSH_AUTH_SOCK").with_context(|| { + format!( + "{file} is a public key, signed with through an ssh-agent: SSH_AUTH_SOCK names none" + ) + })?; + return Ok(Signing::Agent(key, PathBuf::from(socket))); + } + let key = client::signing_key(&text).map_err(|why| anyhow!("{file}: {why}"))?; + Ok(Signing::File(key)) +} + +/// What signs: a key at hand, or a key the ssh-agent at a socket holds. +enum Signing { + File(SigningKey), + Agent(Key, PathBuf), } /// Who signs: the party, with one of its keys. struct Signer { - key: SigningKey, + key: Signing, party: String, } impl Signer { - fn sign(&self, deps: &[Id], does: (&str, Json)) -> Vec { - let line = PublicKey(self.key.verifying_key().to_bytes()).line(); - event::signed(&self.key, &self.party, &line, deps, does) + fn sign(&self, deps: &[Id], does: (&str, Json)) -> Result> { + match &self.key { + Signing::File(key) => { + let line = PublicKey(key.verifying_key().to_bytes()).line(); + Ok(event::signed(key, &self.party, &line, deps, does)) + } + Signing::Agent(key, socket) => { + event::signed_by(&self.party, &key.line(), deps, does, |bytes| { + keys::sign_through(socket, key, bytes) + }) + .map_err(|why| anyhow!(why)) + } + } } } @@ -373,7 +400,7 @@ async fn sign( does: (&str, Json), ) -> Result<()> { let (_, heads) = node.summary().await?; - let event = signer.sign(&heads, does); + let event = signer.sign(&heads, does)?; record.signed(&event); record.save(path).map_err(|why| anyhow!(why))?; node.put(&event).await @@ -438,7 +465,7 @@ async fn vote( .map_err(|why| anyhow!(why))?; // On the events proposing it: above the heads it names for a checkpoint wherever they // are, so a version event may be written on it. - let cast = signer.sign(&proposals, event::vote(current.hash, proposal, yes)); + let cast = signer.sign(&proposals, event::vote(current.hash, proposal, yes))?; record.cast(¤t, &cast, kept); record.save(path).map_err(|why| anyhow!(why))?; node.put(&cast).await -- cgit v1.3.1 From ac66571a87cf36e769bb8308568808e3a0c2ce31 Mon Sep 17 00:00:00 2001 From: tv Date: Wed, 18 Nov 2026 11:17:06 +0000 Subject: continuum-party: a key the ssh-agent holds, given itself `--key` gives a public key itself, an `authorized_keys` line, as well as a file of them: of a file of several, the first signs, with a warning naming it, and another is given itself to sign with it. An agent that doesn't hold the key given signs nothing, and the client stops before it records or puts what it would have signed, saying which key it asked for. --- docs/configuration.md | 4 ++ docs/guides/federation/keys.md | 17 +++--- src/config/mod.rs | 4 +- src/federation/keys.rs | 3 +- src/federation/party.rs | 123 +++++++++++++++++++++++++++++++++++------ 5 files changed, 123 insertions(+), 28 deletions(-) (limited to 'src/federation/party.rs') diff --git a/docs/configuration.md b/docs/configuration.md index d246082..989f268 100644 --- a/docs/configuration.md +++ b/docs/configuration.md @@ -256,4 +256,8 @@ record = "/home/tv/.config/continuum/tv.record" continuum-party --config tv.toml write home/tv/motd '"hello"' ``` +`key` is an OpenSSH private key file, or a public key an ssh-agent holds: the key itself +(`key = "ecdsa-sha2-nistp256 AAAA…"`), or a file of such lines, whose first signs +([`guides/federation/keys.md`](guides/federation/keys.md), Keys in an ssh-agent). + `node` and `token` are secrets: never logged, however they are given. diff --git a/docs/guides/federation/keys.md b/docs/guides/federation/keys.md index 6448f9e..3dd2834 100644 --- a/docs/guides/federation/keys.md +++ b/docs/guides/federation/keys.md @@ -41,16 +41,19 @@ Secure Enclave or a phone, held by an agent there. Such a key is `ecdsa-sha2-nis its type ending in `@openssh.com`) is neither: it signs otherwise than the federation takes, and is no party's key. -Give the client its public key, a `.pub` file, as `--key`: it asks the agent at -`SSH_AUTH_SOCK` to sign, and writes the signature as `ssh-keygen -Y sign` does through -that agent. +Give the client its public key as `--key`, the key itself (an `authorized_keys` line) or +a file holding it: it asks the agent at `SSH_AUTH_SOCK` to sign, and writes the signature +as `ssh-keygen -Y sign` does through that agent. Of a file holding several keys (all +`ssh-add -L` lists, say), the first signs, and the client warns: give another itself to +sign with it. An agent that doesn't hold the key given signs nothing, and the client stops +before it records or puts what it would have signed. ```sh ssh-add -L # ecdsa-sha2-nistp256 AAAA… tv@phone -ssh-add -L | grep tv@phone > phone.pub -cut -d' ' -f1,2 phone.pub # the key as a version or a set names it -continuum-party --node http://tv:secret@localhost:3000 --key phone.pub \ - --record tv.record write home/tv/motd '"from the phone"' +ssh-add -L | grep tv@phone | cut -d' ' -f1,2 # the key as a version or a set names it +continuum-party --node http://tv:secret@localhost:3000 \ + --key "$(ssh-add -L | grep tv@phone)" --record tv.record \ + write home/tv/motd '"from the phone"' ``` Of an ECDSA signature, `s` and the curve's order less `s` both check. The federation diff --git a/src/config/mod.rs b/src/config/mod.rs index 2ff0a45..f74f431 100644 --- a/src/config/mod.rs +++ b/src/config/mod.rs @@ -750,9 +750,9 @@ pub(crate) const PARTY_OPTIONS: &[OptionSpec] = &[ option( "key", Kind::Text, - "PATH", + "KEY", None, - "The party's key it signs with: an OpenSSH private key file, unencrypted, of an Ed25519 key; or a public key file (ssh-ed25519 or ecdsa-sha2-nistp256), signed with through the ssh-agent at SSH_AUTH_SOCK", + "The party's key it signs with: an OpenSSH private key file, unencrypted, of an Ed25519 key; or a public key (ssh-ed25519 or ecdsa-sha2-nistp256), signed with through the ssh-agent at SSH_AUTH_SOCK: itself, as an authorized_keys line, or a file of such lines, whose first signs", ), option( "record", diff --git a/src/federation/keys.rs b/src/federation/keys.rs index ed47b9b..22940ad 100644 --- a/src/federation/keys.rs +++ b/src/federation/keys.rs @@ -199,7 +199,8 @@ pub(crate) fn sign(key: &SigningKey, message: &[u8]) -> String { /// signature: what `ssh-keygen -Y sign -n continuum-federation` makes through the agent, /// unarmored, an ECDSA signature's `s` made low. pub(crate) fn sign_through(socket: &Path, key: &Key, message: &[u8]) -> Result { - let answer = super::agent::sign(socket, &key.blob(), &signed(message))?; + let answer = super::agent::sign(socket, &key.blob(), &signed(message)) + .map_err(|why| format!("{}: {why}", key.line()))?; from_agent(key, &answer, message) } diff --git a/src/federation/party.rs b/src/federation/party.rs index 4ba51ed..5d18eb8 100644 --- a/src/federation/party.rs +++ b/src/federation/party.rs @@ -1,10 +1,10 @@ //! `continuum-party`: a party's client of a federation (`docs/federation.md`). It signs its //! party's events with one of its keys (`--key`: an OpenSSH private key file, or a public -//! key the ssh-agent at `SSH_AUTH_SOCK` holds), puts them through a node's API (`--node`, -//! its user and password in the URL, or `--token`), and keeps its party's record -//! (`--record`, `client::Record`), by which it votes, written before a vote is sent. Its -//! options may be set in configuration files as the node's are (`--config`, -//! `config::PARTY_OPTIONS`): the same format, imports and all. +//! key the ssh-agent at `SSH_AUTH_SOCK` holds, given itself or in a file), puts them +//! through a node's API (`--node`, its user and password in the URL, or `--token`), and +//! keeps its party's record (`--record`, `client::Record`), by which it votes, written +//! before a vote is sent. Its options may be set in configuration files as the node's are +//! (`--config`, `config::PARTY_OPTIONS`): the same format, imports and all. //! //! * `init PARTY`: begins a record of `PARTY`, on the version current now; with `--root //! FILE`, from the file the store's swarm starts from, for a party that never voted in @@ -343,23 +343,70 @@ fn strings(matches: &ArgMatches, name: &str) -> Vec { .collect() } -/// The key `--key` names: a private key file's, or a public key's, held by the ssh-agent. +/// What `--key` gives: a private key, from an OpenSSH private key file; or a public key, +/// given itself (an `authorized_keys` line), or the first of a file of such lines, with +/// how many more the file holds. +enum Given { + Private(SigningKey), + Public(Key, usize), +} + +/// What `given`, `--key`'s value, gives (`Given`). +fn given_key(given: &str) -> Result { + let itself = match Key::parse(given) { + Ok(key) => return Ok(Given::Public(key, 0)), + Err(why) => why, + }; + let text = match std::fs::read_to_string(given) { + Ok(text) => text, + Err(error) if error.kind() == std::io::ErrorKind::NotFound => { + bail!("{given}: no file, nor a key ({itself})") + } + Err(error) => return Err(error).with_context(|| format!("Reading {given}")), + }; + if text.trim_start().starts_with("-----BEGIN") { + let key = client::signing_key(&text).map_err(|why| anyhow!("{given}: {why}"))?; + return Ok(Given::Private(key)); + } + let mut lines = text + .lines() + .map(str::trim) + .filter(|line| !line.is_empty() && !line.starts_with('#')); + let first = lines + .next() + .with_context(|| format!("{given} holds no key"))?; + let key = Key::parse(first).map_err(|why| anyhow!("{given}: {why}"))?; + Ok(Given::Public(key, lines.count())) +} + +/// The key `--key` gives (`given_key`): a private key, signing here; or a public key, +/// signing through the ssh-agent at `SSH_AUTH_SOCK`, which must hold it. Of a file of +/// several public keys, the first, with a warning: another is given as `--key` itself. fn signing_key(options: &Options) -> Result { - let file = options + let given = options .key .as_ref() .context("--key names the party's key")?; - let text = std::fs::read_to_string(file).with_context(|| format!("Reading {file}"))?; - if let Ok(key) = Key::parse(&text) { - let socket = std::env::var_os("SSH_AUTH_SOCK").with_context(|| { - format!( - "{file} is a public key, signed with through an ssh-agent: SSH_AUTH_SOCK names none" - ) - })?; - return Ok(Signing::Agent(key, PathBuf::from(socket))); - } - let key = client::signing_key(&text).map_err(|why| anyhow!("{file}: {why}"))?; - Ok(Signing::File(key)) + let key = match given_key(given)? { + Given::Private(key) => return Ok(Signing::File(key)), + Given::Public(key, 0) => key, + Given::Public(key, more) => { + eprintln!( + "Warning: {given} holds {} keys: signing with the first, {}; to sign with \ + another, give that key itself as --key", + more + 1, + key.line() + ); + key + } + }; + let socket = std::env::var_os("SSH_AUTH_SOCK").with_context(|| { + format!( + "{} signs through an ssh-agent: SSH_AUTH_SOCK names none", + key.line() + ) + })?; + Ok(Signing::Agent(key, PathBuf::from(socket))) } /// What signs: a key at hand, or a key the ssh-agent at a socket holds. @@ -699,6 +746,46 @@ mod tests { super::command().debug_assert(); } + /// `--key` gives a public key itself, or the first of a file's with how many more it + /// holds, or a private key file's key; a file of neither, or none, gives nothing. + #[test] + fn the_key_given() { + use super::{Given, given_key}; + use crate::federation::vectors::ECDSA_KEY; + let ed25519 = crate::federation::harness::key_line(1); + let dir = crate::files::scratch_dir("party-key"); + let file = |name: &str, text: &str| { + let path = dir.join(name); + std::fs::write(&path, text).unwrap(); + path.to_str().unwrap().to_owned() + }; + let public = |given: &str| match given_key(given).unwrap() { + Given::Public(key, more) => (key.line(), more), + Given::Private(_) => panic!("{given}: a private key"), + }; + assert_eq!(public(ECDSA_KEY), (ECDSA_KEY.to_owned(), 0)); + assert_eq!( + public(&format!("{ed25519} tv@laptop")), + (ed25519.clone(), 0) + ); + let one = file("phone.pub", &format!("{ECDSA_KEY} tv@phone\n")); + assert_eq!(public(&one), (ECDSA_KEY.to_owned(), 0)); + let two = file( + "agent.pub", + &format!("{ed25519} tv@laptop\n\n{ECDSA_KEY} tv@phone\n"), + ); + assert_eq!(public(&two), (ed25519, 1)); + assert!(given_key(&file("rsa.pub", "ssh-rsa AAAAB3NzaC1yc2E tv\n")).is_err()); + assert!(given_key(&file("empty.pub", "\n")).is_err()); + assert!(given_key(dir.join("missing").to_str().unwrap()).is_err()); + let private = file( + "tv.key", + "-----BEGIN OPENSSH PRIVATE KEY-----\n-----END OPENSSH PRIVATE KEY-----\n", + ); + let why = given_key(&private).err().expect("no key").to_string(); + assert!(why.contains("OpenSSH private key"), "{why}"); + } + /// Its options come from configuration files as the node's do, arguments winning. #[test] fn its_options_come_from_configuration_files_and_arguments() { -- cgit v1.3.1 From 55f36a960a90aedcb6e899ea963cc642fd630a82 Mon Sep 17 00:00:00 2001 From: tv Date: Wed, 18 Nov 2026 11:17:17 +0000 Subject: continuum-party: why waiting for the ssh-agent may block The client signs one event at a time and does nothing else meanwhile, and an agent may wait for its user as long as that takes. --- src/federation/party.rs | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'src/federation/party.rs') diff --git a/src/federation/party.rs b/src/federation/party.rs index 5d18eb8..9d9c268 100644 --- a/src/federation/party.rs +++ b/src/federation/party.rs @@ -429,6 +429,10 @@ impl Signer { Ok(event::signed(key, &self.party, &line, deps, does)) } Signing::Agent(key, socket) => { + // The agent's answer is waited for blocking the thread, in async code: the + // client signs one event at a time and does nothing else meanwhile, and an + // agent may wait for its user (a touch, a confirmation) as long as that + // takes, which nothing here should cut short. event::signed_by(&self.party, &key.line(), deps, does, |bytes| { keys::sign_through(socket, key, bytes) }) -- cgit v1.3.1