diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/access/sshsig.rs | 16 | ||||
| -rw-r--r-- | src/api/dashboard/mod.rs | 5 | ||||
| -rw-r--r-- | src/config/mod.rs | 4 | ||||
| -rw-r--r-- | src/federation/agent.rs | 45 | ||||
| -rw-r--r-- | src/federation/attacks.rs | 17 | ||||
| -rw-r--r-- | src/federation/event.rs | 25 | ||||
| -rw-r--r-- | src/federation/held.rs | 3 | ||||
| -rw-r--r-- | src/federation/keys.rs | 443 | ||||
| -rw-r--r-- | src/federation/mod.rs | 1 | ||||
| -rw-r--r-- | src/federation/party.rs | 143 | ||||
| -rw-r--r-- | src/federation/vectors.rs | 44 | ||||
| -rw-r--r-- | src/files.rs | 29 | ||||
| -rw-r--r-- | src/identity.rs | 6 | ||||
| -rw-r--r-- | src/swarm/auth.rs | 3 |
14 files changed, 718 insertions, 66 deletions
diff --git a/src/access/sshsig.rs b/src/access/sshsig.rs index e25d8a7..740a727 100644 --- a/src/access/sshsig.rs +++ b/src/access/sshsig.rs @@ -198,7 +198,12 @@ pub(crate) fn sign(key: &SigningKey, namespace: &str, message: &[u8]) -> String } /// What a signature is made over. -fn signed_data(namespace: &[u8], reserved: &[u8], algorithm: &[u8], hash: &[u8]) -> Vec<u8> { +pub(crate) fn signed_data( + namespace: &[u8], + reserved: &[u8], + algorithm: &[u8], + hash: &[u8], +) -> Vec<u8> { let mut signed = MAGIC.to_vec(); string(&mut signed, namespace); string(&mut signed, reserved); @@ -207,13 +212,14 @@ fn signed_data(namespace: &[u8], reserved: &[u8], algorithm: &[u8], hash: &[u8]) signed } -fn string(out: &mut Vec<u8>, bytes: &[u8]) { +/// `bytes` as SSH's string: a big-endian `u32` length, then the bytes. +pub(crate) fn string(out: &mut Vec<u8>, bytes: &[u8]) { out.extend_from_slice(&(bytes.len() as u32).to_be_bytes()); out.extend_from_slice(bytes); } /// Reads SSH's encoding. -struct Reader<'a>(&'a [u8]); +pub(crate) struct Reader<'a>(pub(crate) &'a [u8]); impl<'a> Reader<'a> { fn u32(&mut self) -> Result<u32, String> { @@ -222,7 +228,7 @@ impl<'a> Reader<'a> { Ok(u32::from_be_bytes(*bytes)) } - fn string(&mut self) -> Result<&'a [u8], String> { + pub(crate) fn string(&mut self) -> Result<&'a [u8], String> { let length = self.u32()? as usize; if self.0.len() < length { return Err("cut short".to_owned()); @@ -232,7 +238,7 @@ impl<'a> Reader<'a> { Ok(bytes) } - fn end(&self) -> Result<(), String> { + pub(crate) fn end(&self) -> Result<(), String> { if self.0.is_empty() { Ok(()) } else { diff --git a/src/api/dashboard/mod.rs b/src/api/dashboard/mod.rs index 15b8cf9..c0de169 100644 --- a/src/api/dashboard/mod.rs +++ b/src/api/dashboard/mod.rs @@ -913,8 +913,8 @@ mod tests { #[test] #[ignore] fn dashboard_in_a_browser() { - let file = - std::env::temp_dir().join(format!("continuum-dashboard-{}.html", std::process::id())); + let dir = crate::files::scratch_dir("dashboard"); + let file = dir.join("page.html"); std::fs::write(&file, &page().1).expect("page written"); let check = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src/api/dashboard/check.js"); @@ -928,7 +928,6 @@ mod tests { PATH, with Playwright's library and its Chromium (check.nix)" ) }); - let _ = std::fs::remove_file(&file); assert!(status.success(), "the browser checks failed"); } diff --git a/src/config/mod.rs b/src/config/mod.rs index 710376d..8196db6 100644 --- a/src/config/mod.rs +++ b/src/config/mod.rs @@ -746,9 +746,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", + "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/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<Vec<u8>, 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/attacks.rs b/src/federation/attacks.rs index d153f22..0d90461 100644 --- a/src/federation/attacks.rs +++ b/src/federation/attacks.rs @@ -1102,6 +1102,7 @@ fn federation_attack_61() { #[test] fn federation_attack_62() { + use super::vectors::{ECDSA_KEY, ECDSA_WRITE}; use base64::{Engine, engine::general_purpose::STANDARD as BASE64}; let mut fed = three(); let root = fed.root(); @@ -1150,6 +1151,22 @@ fn federation_attack_62() { ), ); assert_eq!(fed.refused(commented), Refusal::None); + // Signed with an ECDSA key (the vectors'), its signature spelled otherwise: `s` high, + // or `r` longer. The write as it was signed is taken. + let mut first = Spec::first(&[&tv, &lass()], &[]); + first.parties[0].keys = vec![ECDSA_KEY.to_owned()]; + let mut fed = Fed { + store: Store::new(first.root(), Vec::new()).expect("a root"), + first, + }; + let event = super::jcs::read(ECDSA_WRITE.as_bytes()).expect("JCS"); + let sig = event.get("sig").and_then(Json::as_str).expect("a sig"); + let key = super::keys::key(ECDSA_KEY).expect("a key"); + for other in super::keys::respelled(&key, sig) { + let respelled = ECDSA_WRITE.replace(sig, &other).into_bytes(); + assert_eq!(fed.refused(respelled), Refusal::None); + } + fed.take(ECDSA_WRITE.as_bytes().to_vec()); } #[test] diff --git a/src/federation/event.rs b/src/federation/event.rs index 00c7018..864bedb 100644 --- a/src/federation/event.rs +++ b/src/federation/event.rs @@ -5,7 +5,6 @@ use super::jcs::{self, Json}; use super::keys; use super::store::Id; use super::version::{self, Version}; -use crate::access::sshsig::PublicKey; /// The most bytes an event may have. pub(crate) const LARGEST: usize = 256 * 1024; @@ -22,6 +21,21 @@ pub(crate) fn signed( deps: &[Id], does: (&str, Json), ) -> Vec<u8> { + 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<String, String>, +) -> Result<Vec<u8>, String> { let mut members = vec![ ("deps".to_owned(), ids(deps)), ("party".to_owned(), Json::Str(party.to_owned())), @@ -29,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. @@ -229,7 +240,7 @@ impl Event { } /// The key a signed event is signed with. - pub(crate) fn public(signed: &Signed) -> PublicKey { + pub(crate) fn public(signed: &Signed) -> keys::Key { keys::key(&signed.key).expect("an event's key was read as one") } } diff --git a/src/federation/held.rs b/src/federation/held.rs index 3ca74a9..abb3d30 100644 --- a/src/federation/held.rs +++ b/src/federation/held.rs @@ -1795,7 +1795,8 @@ mod tests { for event in [&write, &beside, &proposal, &yes] { put(&mut doc, event); } - let record = crate::files::scratch_dir("held-votes-above").join("makefu.json"); + let dir = crate::files::scratch_dir("held-votes-above"); + let record = dir.join("makefu.json"); let version = Version::read(&first.json()).unwrap(); let mut begun = Record::begin(Id::of(&root), "makefu", &version); begun.began = Id::of(b"before the federation").to_string(); diff --git a/src/federation/keys.rs b/src/federation/keys.rs index 7df0bd9..22940ad 100644 --- a/src/federation/keys.rs +++ b/src/federation/keys.rs @@ -1,28 +1,111 @@ //! Keys, node IDs and signatures, each spelled one way (`docs/federation.md`, Events): //! -//! * a key: `ssh-ed25519`, one space, and the key's base64, padded and canonical, with no -//! comment, its 32 bytes an Ed25519 public key; +//! * a key: its type, one space, and the base64 of its SSH encoding, padded and canonical, +//! with no comment: `ssh-ed25519`, its 32 bytes an Ed25519 public key, or +//! `ecdsa-sha2-nistp256`, its point on NIST P-256 uncompressed; //! * a node ID: as continuum spells it, `continuum:` and the 64 lower-case hex digits of //! the node's Ed25519 public key; //! * a signature: SSHSIG of version 1 over the event's bytes without `sig`, for the //! namespace `continuum-federation`, hashed with `sha512`, its reserved field empty, its -//! key the event's, in base64, padded and canonical, unarmored; checked strictly. +//! key the event's, in base64, padded and canonical, unarmored; checked strictly. An +//! ECDSA signature's `r` and `s` are SSH's shortest mpints, and its `s` low: at most +//! half the curve's order, as `s` and the order less `s` both check. //! //! 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; +use sha2::{Digest, Sha512}; -use crate::access::sshsig::{self, PublicKey}; +use crate::access::sshsig::{self, PublicKey, Reader, string}; use crate::identity; /// What a party's signature is for. pub(crate) const NAMESPACE: &str = "continuum-federation"; +const ED25519: &str = "ssh-ed25519"; +const P256: &str = "ecdsa-sha2-nistp256"; +const CURVE: &[u8] = b"nistp256"; + +/// A party's key. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum Key { + Ed25519(PublicKey), + /// ECDSA on NIST P-256: its point, SEC1-encoded, uncompressed. + P256([u8; 65]), +} + +impl Key { + /// From an `authorized_keys` line: its type, its base64, and maybe a comment. + pub(crate) fn parse(line: &str) -> Result<Key, String> { + let mut parts = line.split_whitespace(); + let (Some(kind), Some(encoded)) = (parts.next(), parts.next()) else { + return Err(format!("not `{ED25519}|{P256} <base64> [comment]`")); + }; + match kind { + ED25519 => return PublicKey::parse(line).map(Key::Ed25519), + P256 => {} + _ => { + return Err(format!( + "a {kind} key: only {ED25519} and {P256} keys are taken" + )); + } + } + let blob = BASE64 + .decode(encoded) + .map_err(|error| format!("its base64 doesn't decode: {error}"))?; + let mut reader = Reader(&blob); + if reader.string()? != P256.as_bytes() || reader.string()? != CURVE { + return Err(format!("not an {P256} key")); + } + let point: [u8; 65] = reader + .string()? + .try_into() + .map_err(|_| "a point that isn't 65 bytes".to_owned())?; + reader.end()?; + p256::ecdsa::VerifyingKey::from_sec1_bytes(&point) + .map_err(|_| "not a point on NIST P-256".to_owned())?; + Ok(Key::P256(point)) + } + + fn kind(&self) -> &'static str { + match self { + Key::Ed25519(_) => ED25519, + Key::P256(_) => P256, + } + } + + /// Its SSH encoding. + pub(crate) fn blob(&self) -> Vec<u8> { + match self { + Key::Ed25519(key) => key.blob(), + Key::P256(point) => { + let mut blob = Vec::new(); + string(&mut blob, P256.as_bytes()); + string(&mut blob, CURVE); + string(&mut blob, point); + blob + } + } + } + + /// As an `authorized_keys` line has it, without a comment. + pub(crate) fn line(&self) -> String { + format!("{} {}", self.kind(), BASE64.encode(self.blob())) + } +} + /// The key `text` spells, where it spells one as the federation does. -pub(crate) fn key(text: &str) -> Option<PublicKey> { - let key = PublicKey::parse(text).ok()?; - (key.line() == text && VerifyingKey::from_bytes(&key.0).is_ok()).then_some(key) +pub(crate) fn key(text: &str) -> Option<Key> { + let key = Key::parse(text).ok()?; + let valid = match &key { + Key::Ed25519(public) => VerifyingKey::from_bytes(&public.0).is_ok(), + Key::P256(_) => true, + }; + (key.line() == text && valid).then_some(key) } /// Whether `text` is a node ID spelled as continuum spells one. @@ -31,19 +114,77 @@ pub(crate) fn node_id(text: &str) -> bool { } /// Whether `sig` is `key`'s signature of `message`, spelled as the federation spells one. -pub(crate) fn verifies(key: &PublicKey, sig: &str, message: &[u8]) -> bool { +pub(crate) fn verifies(key: &Key, sig: &str, message: &[u8]) -> bool { let Ok(blob) = BASE64.decode(sig) else { return false; }; - if BASE64.encode(&blob) != sig || blob.len() < 64 { + if BASE64.encode(&blob) != sig { return false; } // The blob reads back to itself: what signing with this key writes around its - // signature, the last 64 bytes. - if blob != written(key, &blob[blob.len() - 64..]) { + // signature, all that follows what it writes around none. + let Some(signature) = blob.get(written(key, &[]).len()..) else { + return false; + }; + if blob != written(key, signature) { + return false; + } + match key { + Key::Ed25519(public) => { + sshsig::verify_blob(&blob, NAMESPACE, message).is_ok_and(|signer| signer == *public) + } + Key::P256(point) => p256_verifies(point, signature, message), + } +} + +/// Whether `signature`, `r` and `s` as SSH's mpints, is the P-256 key `point`'s of +/// `message`, spelled one way: each mpint its shortest, `s` low. +fn p256_verifies(point: &[u8; 65], signature: &[u8], message: &[u8]) -> bool { + let Some(parsed) = ecdsa_signature(signature) else { + return false; + }; + if mpints(&parsed) != signature || parsed.normalize_s() != parsed { return false; } - sshsig::verify_blob(&blob, NAMESPACE, message).is_ok_and(|signer| signer == *key) + p256::ecdsa::VerifyingKey::from_sec1_bytes(point) + .is_ok_and(|key| key.verify(&signed(message), &parsed).is_ok()) +} + +/// An ECDSA signature from `r` and `s`, SSH's mpints, where each is an integer from 1 to +/// below the curve's order, spelled any way SSH reads. +fn ecdsa_signature(bytes: &[u8]) -> Option<p256::ecdsa::Signature> { + /// A non-negative mpint of up to 32 bytes, leading zeros aside, as 32 bytes. + fn scalar(mpint: &[u8]) -> Option<[u8; 32]> { + if mpint.first().is_some_and(|byte| byte & 0x80 != 0) { + return None; + } + let digits = &mpint[mpint.iter().take_while(|byte| **byte == 0).count()..]; + let mut out = [0; 32]; + out.get_mut(32usize.checked_sub(digits.len())?..)? + .copy_from_slice(digits); + Some(out) + } + let mut reader = Reader(bytes); + let r = scalar(reader.string().ok()?)?; + let s = scalar(reader.string().ok()?)?; + reader.end().ok()?; + p256::ecdsa::Signature::from_scalars(r, s).ok() +} + +/// `signature`'s `r` and `s`, each SSH's shortest mpint. +fn mpints(signature: &p256::ecdsa::Signature) -> Vec<u8> { + let (r, s) = signature.split_bytes(); + let mut out = Vec::new(); + for value in [r, s] { + let digits = &value[value.iter().take_while(|byte| **byte == 0).count()..]; + let mut mpint = Vec::new(); + if digits.first().is_some_and(|byte| byte & 0x80 != 0) { + mpint.push(0); + } + mpint.extend_from_slice(digits); + string(&mut out, &mpint); + } + out } /// `message` signed with `key`, as the federation spells a signature: what @@ -54,11 +195,55 @@ 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<String, String> { + let answer = super::agent::sign(socket, &key.blob(), &signed(message)) + .map_err(|why| format!("{}: {why}", key.line()))?; + 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<String, String> { + 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<u8> { + sshsig::signed_data( + NAMESPACE.as_bytes(), + b"", + b"sha512", + &Sha512::digest(message), + ) +} + /// The SSHSIG blob of a signature by `key`, of version 1, for the federation's namespace, -/// its reserved field empty, hashed with `sha512`: as `ssh-keygen` writes it. -fn written(key: &PublicKey, signature: &[u8]) -> Vec<u8> { +/// its reserved field empty, hashed with `sha512`: as `ssh-keygen` writes it around +/// `signature`, the key type's own. +fn written(key: &Key, signature: &[u8]) -> Vec<u8> { let mut inner = Vec::new(); - string(&mut inner, b"ssh-ed25519"); + string(&mut inner, key.kind().as_bytes()); string(&mut inner, signature); let mut blob = b"SSHSIG".to_vec(); blob.extend_from_slice(&1u32.to_be_bytes()); @@ -70,37 +255,73 @@ fn written(key: &PublicKey, signature: &[u8]) -> Vec<u8> { blob } -fn string(out: &mut Vec<u8>, bytes: &[u8]) { - out.extend_from_slice(&(bytes.len() as u32).to_be_bytes()); - out.extend_from_slice(bytes); +/// Of `sig`, an ECDSA signature by `key` as the federation spells it, two others of the +/// same key and message that check as SSH checks them: `s` high, the order less `s`; and +/// `r` with a zero byte more in front, the same number to SSH. +#[cfg(test)] +pub(crate) fn respelled(key: &Key, sig: &str) -> [String; 2] { + let blob = BASE64.decode(sig).expect("base64"); + let rs = &blob[written(key, &[]).len()..]; + let (r, s) = ecdsa_signature(rs).expect("r and s").split_scalars(); + let high = p256::ecdsa::Signature::from_scalars(r, -s).expect("a signature"); + let mut reader = Reader(rs); + let (r, s) = (reader.string().expect("r"), reader.string().expect("s")); + let mut longer = Vec::new(); + string(&mut longer, &[&[0], r].concat()); + string(&mut longer, s); + [mpints(&high), longer].map(|numbers| BASE64.encode(written(key, &numbers))) } #[cfg(test)] mod tests { use super::*; + use crate::federation::event::Event; + use crate::federation::jcs::{self, Json}; + use crate::federation::vectors::{ECDSA_KEY, ECDSA_WRITE}; fn signer(seed: u8) -> SigningKey { SigningKey::from_bytes(&[seed; 32]) } - fn public(key: &SigningKey) -> PublicKey { - PublicKey(key.verifying_key().to_bytes()) + fn public(key: &SigningKey) -> Key { + Key::Ed25519(PublicKey(key.verifying_key().to_bytes())) } #[test] fn a_key_is_spelled_one_way() { - let line = public(&signer(1)).line(); - assert!(key(&line).is_some()); - assert!(key(&format!("{line} comment")).is_none()); - assert!(key(&line.replacen(' ', " ", 1)).is_none()); - assert!(key(&format!(" {line}")).is_none()); - let unpadded = line.trim_end_matches('='); - if unpadded != line { - assert!(key(unpadded).is_none()); + for line in [public(&signer(1)).line(), ECDSA_KEY.to_owned()] { + assert_eq!(key(&line).map(|key| key.line()), Some(line.clone())); + assert!(key(&format!("{line} comment")).is_none()); + assert!(key(&line.replacen(' ', " ", 1)).is_none()); + assert!(key(&format!(" {line}")).is_none()); + let unpadded = line.trim_end_matches('='); + if unpadded != line { + assert!(key(unpadded).is_none()); + } } } #[test] + fn an_ecdsa_key_is_a_point_on_the_curve_uncompressed() { + let Some(Key::P256(point)) = key(ECDSA_KEY) else { + panic!("an ECDSA key"); + }; + let line = |point: &[u8]| { + let mut blob = Vec::new(); + string(&mut blob, P256.as_bytes()); + string(&mut blob, CURVE); + string(&mut blob, point); + format!("{P256} {}", BASE64.encode(blob)) + }; + assert_eq!(line(&point), ECDSA_KEY); + let compressed = [&[2 + (point[64] & 1)], &point[1..33]].concat(); + assert!(Key::parse(&line(&compressed)).is_err()); + let mut off = point; + off[64] ^= 1; + assert!(Key::parse(&line(&off)).is_err()); + } + + #[test] fn a_node_id_is_spelled_one_way() { let id = identity::node_id_of(&signer(2).verifying_key().to_bytes()); assert!(node_id(&id)); @@ -144,4 +365,170 @@ mod tests { b"an event" )); } + + /// The ECDSA vector's write: its key, its `sig`, and the bytes it signs. + fn ecdsa_write() -> (Key, String, Vec<u8>) { + let event = jcs::read(ECDSA_WRITE.as_bytes()).expect("JCS"); + let sig = event.get("sig").and_then(Json::as_str).expect("a sig"); + ( + key(ECDSA_KEY).expect("a key"), + sig.to_owned(), + event.without("sig").bytes(), + ) + } + + /// The `r` and `s` of `sig`, a signature by `key` as the federation spells one. + fn rs<'a>(key: &Key, sig: &'a [u8]) -> &'a [u8] { + &sig[written(key, &[]).len()..] + } + + #[test] + fn an_ecdsa_signature_is_low_s_and_spelled_one_way() { + let (key, sig, message) = ecdsa_write(); + assert!(verifies(&key, &sig, &message)); + assert!(!verifies(&key, &sig, b"another event")); + let blob = BASE64.decode(&sig).expect("base64"); + let ours = ecdsa_signature(rs(&key, &blob)).expect("r and s"); + let refused = |rs: &[u8]| { + let other = BASE64.encode(written(&key, rs)); + assert!(!verifies(&key, &other, &message)); + assert!(Event::read(ECDSA_WRITE.replace(&sig, &other).as_bytes()).is_none()); + }; + // Its twin of the order less `s`, high, checks as ECDSA, and is none here. + let (r, s) = ours.split_scalars(); + let twin = p256::ecdsa::Signature::from_scalars(r, -s).expect("a signature"); + let Key::P256(point) = key else { + unreachable!("an ECDSA key") + }; + let verifying = p256::ecdsa::VerifyingKey::from_sec1_bytes(&point).expect("a point"); + assert!(verifying.verify(&signed(&message), &twin).is_ok()); + assert_ne!(twin, ours); + assert_eq!(twin.normalize_s(), ours); + refused(&mpints(&twin)); + // `r` with a zero byte more in front: the same number to SSH, and none here. + let mut reader = Reader(rs(&key, &blob)); + let (r, s) = (reader.string().unwrap(), reader.string().unwrap()); + let mut longer = Vec::new(); + string(&mut longer, &[&[0], r].concat()); + string(&mut longer, s); + assert_eq!(ecdsa_signature(&longer), Some(ours)); + refused(&longer); + // Nor a negative `r`. + let mut negative = Vec::new(); + string(&mut negative, &[&[0x80], r].concat()); + 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`. The machine testing needs OpenSSH (`ssh-agent`, + /// `ssh-add`, `ssh-keygen`): without it, the test fails. + #[test] + fn signs_through_an_ssh_agent() { + use std::process::{Command, Stdio}; + let dir = crate::files::scratch_dir("agent"); + let socket = dir.join("agent"); + // The agent, stopped when the test ends: dropped before its directory, declared + // after it. + struct Stop(std::process::Child); + impl Drop for Stop { + fn drop(&mut self) { + let _ = self.0.kill(); + let _ = self.0.wait(); + } + } + let _agent = Stop( + Command::new("ssh-agent") + .arg("-D") + .arg("-a") + .arg(&socket) + .stdout(Stdio::null()) + .spawn() + .expect("ssh-agent, of OpenSSH, which this test needs"), + ); + for _ in 0..100 { + if socket.exists() { + break; + } + std::thread::sleep(std::time::Duration::from_millis(50)); + } + assert!( + socket.exists(), + "ssh-agent made no socket at {}", + socket.display() + ); + let run = |command: &mut Command| { + let out = command + .env("SSH_AUTH_SOCK", &socket) + .output() + .expect("OpenSSH, which this test needs"); + 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 f0ae288..9d9c268 100644 --- a/src/federation/party.rs +++ b/src/federation/party.rs @@ -1,5 +1,6 @@ //! `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 +//! 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, 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 @@ -42,6 +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::{self, Key}; use super::store::Id; use super::store::memory::Store; use super::version::Version; @@ -282,7 +284,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}")) }) @@ -341,25 +343,102 @@ fn strings(matches: &ArgMatches, name: &str) -> Vec<String> { .collect() } -fn signing_key(options: &Options) -> Result<SigningKey> { - let file = options +/// 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<Given> { + 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<Signing> { + 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}"))?; - client::signing_key(&text).map_err(|why| anyhow!("{file}: {why}")) + 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. +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<u8> { - 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<Vec<u8>> { + 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) => { + // 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) + }) + .map_err(|why| anyhow!(why)) + } + } } } @@ -372,7 +451,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 @@ -437,7 +516,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 @@ -671,6 +750,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() { diff --git a/src/federation/vectors.rs b/src/federation/vectors.rs index 25c6a41..3d839c8 100644 --- a/src/federation/vectors.rs +++ b/src/federation/vectors.rs @@ -5,9 +5,11 @@ //! change of the federation, which takes its next number. use super::event::{self, Checkpoint, Event}; +use super::fold::Federation; use super::harness::{self, Party, Spec}; use super::jcs::Json; use super::store::Id; +use super::store::memory::{Offered, Store}; use super::version::{self, Version}; /// A write by tv (keys from seeds: tv's of 1s, lass's of 2s), on the ID of @@ -145,6 +147,48 @@ fn events_at_federation_1s_sizes_and_just_past_them() { assert!(Event::read(&tv.write(&[dep()], "home/tv/n", largest)).is_some()); } +/// tv's key on NIST P-256, made by `ssh-keygen -t ecdsa -b 256`; the first version naming +/// it for tv, beside lass's key of 2s, with tv's node and a namespace each; its root; and a +/// write and a key set tv signed with it, on the root, by `ssh-keygen -Y sign -n +/// continuum-federation`, each signature's `s` low. +pub(crate) const ECDSA_KEY: &str = "ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBI6uK92X+y9N7jbrgH7grypeMRnxRsEFGnbhV97LJ/7UFKmBtDn0p6V5EBz9WAeeb3BUMCMlkFq3VxEvySs35ss="; +const ECDSA_VERSION: &str = r#"{"changes":null,"federation":1,"keys":{"lass":{"keys":["ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIE5dw6ofRdfVqNUZsNMfszLjYqRtO43ol32D1uPybOU"],"since":0},"tv":{"keys":["ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBI6uK92X+y9N7jbrgH7grypeMRnxRsEFGnbhV97LJ/7UFKmBtDn0p6V5EBz9WAeeb3BUMCMlkFq3VxEvySs35ss="],"since":0}},"nodes":{"lass":{"nodes":[],"since":0},"tv":{"nodes":["continuum:e5687b6d11ccfb632abbafe844f8f1693d160aa582156ed66eea38ab5e7d1e12"],"since":0}},"number":0,"rules":[{"path":"home/{party}/**","writer":"{party}"}]}"#; +const ECDSA_ROOT_ID: &str = "6bca61798e124250309330835c674f3c4e7b4547e13fad954674c41b338d7859"; +pub(crate) const ECDSA_WRITE: &str = r#"{"deps":["6bca61798e124250309330835c674f3c4e7b4547e13fad954674c41b338d7859"],"key":"ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBI6uK92X+y9N7jbrgH7grypeMRnxRsEFGnbhV97LJ/7UFKmBtDn0p6V5EBz9WAeeb3BUMCMlkFq3VxEvySs35ss=","party":"tv","sig":"U1NIU0lHAAAAAQAAAGgAAAATZWNkc2Etc2hhMi1uaXN0cDI1NgAAAAhuaXN0cDI1NgAAAEEEjq4r3Zf7L03uNuuAfuCvKl4xGfFGwQUaduFX3ssn/tQUqYG0OfSnpXkQHP1YB55vcFQwIyWQWrdXES/JKzfmywAAABRjb250aW51dW0tZmVkZXJhdGlvbgAAAAAAAAAGc2hhNTEyAAAAYwAAABNlY2RzYS1zaGEyLW5pc3RwMjU2AAAASAAAACA9LGG7MLFobYksXCVEMCda7M5iGcxB8vunTxypmyf3+wAAACBWct5p0CI3w3+OpKCS4w7DJKqpP8+oxgCbRFkvlhZ73A==","write":{"path":"home/tv/laptop","value":"10.243.7.3"}}"#; +const ECDSA_WRITE_ID: &str = "f1f4bf7c1226d920c37d20a8228d490ea7249a4df4005a38f7d5993bd6923cb2"; +const ECDSA_KEYS: &str = r#"{"deps":["6bca61798e124250309330835c674f3c4e7b4547e13fad954674c41b338d7859"],"key":"ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBI6uK92X+y9N7jbrgH7grypeMRnxRsEFGnbhV97LJ/7UFKmBtDn0p6V5EBz9WAeeb3BUMCMlkFq3VxEvySs35ss=","keys":["ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBI6uK92X+y9N7jbrgH7grypeMRnxRsEFGnbhV97LJ/7UFKmBtDn0p6V5EBz9WAeeb3BUMCMlkFq3VxEvySs35ss=","ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIAzB4a38+wy5iWPeKWbYF5hoHAxLVqYMO73eO8on/XYH"],"party":"tv","sig":"U1NIU0lHAAAAAQAAAGgAAAATZWNkc2Etc2hhMi1uaXN0cDI1NgAAAAhuaXN0cDI1NgAAAEEEjq4r3Zf7L03uNuuAfuCvKl4xGfFGwQUaduFX3ssn/tQUqYG0OfSnpXkQHP1YB55vcFQwIyWQWrdXES/JKzfmywAAABRjb250aW51dW0tZmVkZXJhdGlvbgAAAAAAAAAGc2hhNTEyAAAAZAAAABNlY2RzYS1zaGEyLW5pc3RwMjU2AAAASQAAACEA8W+2M0hB62y5PDq3TrERSA/TJBFjI21dg+u3GJzU7cUAAAAgYqFtgJ/74JtWUWGN/kBQBibbCE5EbXR/Phz4VbzBbko="}"#; +const ECDSA_KEYS_ID: &str = "4703ad7b712372f737fcd52c73c071f81d9c48f8cd63404e91cdec249a33347d"; + +#[test] +fn an_ecdsa_key_and_what_it_signs() { + let (write, keys) = (ECDSA_WRITE.as_bytes(), ECDSA_KEYS.as_bytes()); + assert!( + Event::read(write).is_some(), + "a write signed with an ECDSA key" + ); + assert!( + Event::read(keys).is_some(), + "a key set signed with an ECDSA key" + ); + assert_eq!(Id::of(write).to_string(), ECDSA_WRITE_ID); + assert_eq!(Id::of(keys).to_string(), ECDSA_KEYS_ID); + let mut spec = Spec::first(&[&tv(), &Party::new("lass", 2)], &[]); + spec.parties[0].keys = vec![ECDSA_KEY.to_owned()]; + assert_eq!( + String::from_utf8(spec.json().bytes()).expect("UTF-8"), + ECDSA_VERSION + ); + let root = spec.root(); + assert_eq!(Id::of(&root).to_string(), ECDSA_ROOT_ID); + let mut store = Store::<Federation>::new(root, Vec::new()).expect("a root"); + for event in [write, keys] { + assert_eq!( + store.offer(event.to_vec()), + Offered::Taken(vec![Id::of(event)]) + ); + } +} + /// The changes founding the swarm of `first`'s root, and those founding the fork whose /// root is `FORK_ROOT`, keeping tv's write: each its hash and its bytes. Automerge encodes /// them, so no script apart computes them; a run of this code printed them, and they were diff --git a/src/files.rs b/src/files.rs index 3e27066..320543f 100644 --- a/src/files.rs +++ b/src/files.rs @@ -261,13 +261,34 @@ fn with_suffix(path: &Path, suffix: &str) -> PathBuf { } /// An empty directory for the test `name`: `continuum-<name>-<process ID>` in the -/// temporary directory, emptied first. +/// temporary directory, emptied first, and removed with all it holds once dropped, the +/// test passing or failing. #[cfg(test)] -pub(crate) fn scratch_dir(name: &str) -> PathBuf { +pub(crate) fn scratch_dir(name: &str) -> Scratch { let dir = std::env::temp_dir().join(format!("continuum-{name}-{}", std::process::id())); let _ = std::fs::remove_dir_all(&dir); std::fs::create_dir_all(&dir).unwrap(); - dir + Scratch(dir) +} + +/// A test's directory (`scratch_dir`), removed when dropped. +#[cfg(test)] +pub(crate) struct Scratch(PathBuf); + +#[cfg(test)] +impl std::ops::Deref for Scratch { + type Target = Path; + + fn deref(&self) -> &Path { + &self.0 + } +} + +#[cfg(test)] +impl Drop for Scratch { + fn drop(&mut self) { + let _ = std::fs::remove_dir_all(&self.0); + } } #[cfg(test)] @@ -302,7 +323,5 @@ mod tests { ); assert_eq!(files.counts()[0].1.appended_bytes, 1); assert_eq!(files.counts()[1].1.reads, 0); - - std::fs::remove_dir_all(&dir).unwrap(); } } diff --git a/src/identity.rs b/src/identity.rs index 1012d23..23c4f0f 100644 --- a/src/identity.rs +++ b/src/identity.rs @@ -118,7 +118,8 @@ mod tests { #[test] fn created_only_when_asked_and_then_kept() { - let path = scratch_dir("identity-create").join("node.key"); + let dir = scratch_dir("identity-create"); + let path = dir.join("node.key"); assert!(NodeKey::load(&path, false).is_err()); assert!(!path.exists()); @@ -138,7 +139,8 @@ mod tests { #[test] fn a_key_of_the_wrong_size_is_refused() { - let path = scratch_dir("identity-size").join("node.key"); + let dir = scratch_dir("identity-size"); + let path = dir.join("node.key"); std::fs::write(&path, [7u8; 16]).unwrap(); assert!(NodeKey::load(&path, true).is_err()); } diff --git a/src/swarm/auth.rs b/src/swarm/auth.rs index 98a004c..7ac813b 100644 --- a/src/swarm/auth.rs +++ b/src/swarm/auth.rs @@ -166,7 +166,8 @@ mod tests { /// A swarm key file is made only when asked, then read as any other. #[test] fn swarm_key_created_only_when_asked() { - let path = crate::files::scratch_dir("swarm-key-create").join("swarm.key"); + let dir = crate::files::scratch_dir("swarm-key-create"); + let path = dir.join("swarm.key"); assert!(SwarmKey::from_file(&path, false).is_err()); assert!(!path.exists()); let created = SwarmKey::from_file(&path, true).unwrap(); |
