From c969f4f1b3f6d39b9ef95d6f7e5f517e57a4f5b7 Mon Sep 17 00:00:00 2001 From: jmwample <8297368+jmwample@users.noreply.github.com> Date: Wed, 18 Sep 2024 15:44:02 -0600 Subject: [PATCH 1/3] getting moving on o5 again --- crates/o5/Cargo.toml | 38 +- crates/o5/README.md | 50 +- crates/o5/src/client.rs | 188 +++++ crates/o5/src/common/README.md | 10 + crates/o5/src/common/ct.rs | 17 + crates/o5/src/common/curve25519.rs | 157 ++++ crates/o5/src/common/drbg.rs | 348 +++++++++ crates/o5/src/common/kdf.rs | 158 ++++ crates/o5/src/common/mod.rs | 37 + crates/o5/src/common/ntor_arti/mod.rs | 180 +++++ crates/o5/src/common/probdist.rs | 268 +++++++ crates/o5/src/common/replay_filter.rs | 255 +++++++ crates/o5/src/common/skip.rs | 64 ++ crates/o5/src/constants.rs | 79 ++ crates/o5/src/error.rs | 245 +++++++ crates/o5/src/framing/codecs.rs | 371 ++++++++++ crates/o5/src/framing/generic_test.rs | 143 ++++ crates/o5/src/framing/handshake.rs | 176 +++++ crates/o5/src/framing/messages_base.rs | 75 ++ crates/o5/src/framing/messages_v1/crypto.rs | 152 ++++ crates/o5/src/framing/messages_v1/mod.rs | 283 +++++++ crates/o5/src/framing/mod.rs | 190 ++++- crates/o5/src/framing/testing.rs | 211 ++++++ crates/o5/src/handshake/README.md | 129 ++++ crates/o5/src/handshake/handshake_client.rs | 335 +++++++++ crates/o5/src/handshake/handshake_server.rs | 284 +++++++ crates/o5/src/handshake/integration.rs | 334 +++++---- crates/o5/src/handshake/kyber.rs | 355 +++++++++ crates/o5/src/handshake/mod.rs | 613 ++++++++-------- crates/o5/src/handshake/ntor_obfs4.rs | 352 +++++++++ crates/o5/src/handshake/utils.rs | 264 +++++++ crates/o5/src/handshake_old/integration.rs | 297 ++++++++ crates/o5/src/handshake_old/mod.rs | 774 ++++++++++++++++++++ crates/o5/src/lib.rs | 41 +- crates/o5/src/proto.rs | 373 ++++++++++ crates/o5/src/pt.rs | 274 +++++++ crates/o5/src/server.rs | 386 ++++++++++ crates/o5/src/sessions.rs | 497 +++++++++++++ crates/o5/src/test_utils/fake_prng.rs | 27 + crates/o5/src/test_utils/mod.rs | 185 +++++ crates/o5/src/test_utils/tests.rs | 101 +++ crates/o5/src/testing.rs | 354 +++++++++ crates/o5/src/transport.rs | 75 -- 43 files changed, 9196 insertions(+), 549 deletions(-) create mode 100644 crates/o5/src/client.rs create mode 100644 crates/o5/src/common/README.md create mode 100644 crates/o5/src/common/ct.rs create mode 100644 crates/o5/src/common/curve25519.rs create mode 100644 crates/o5/src/common/drbg.rs create mode 100644 crates/o5/src/common/kdf.rs create mode 100644 crates/o5/src/common/mod.rs create mode 100644 crates/o5/src/common/ntor_arti/mod.rs create mode 100644 crates/o5/src/common/probdist.rs create mode 100644 crates/o5/src/common/replay_filter.rs create mode 100644 crates/o5/src/common/skip.rs create mode 100644 crates/o5/src/constants.rs create mode 100644 crates/o5/src/error.rs create mode 100644 crates/o5/src/framing/codecs.rs create mode 100644 crates/o5/src/framing/generic_test.rs create mode 100644 crates/o5/src/framing/handshake.rs create mode 100644 crates/o5/src/framing/messages_base.rs create mode 100644 crates/o5/src/framing/messages_v1/crypto.rs create mode 100644 crates/o5/src/framing/messages_v1/mod.rs create mode 100644 crates/o5/src/framing/testing.rs create mode 100644 crates/o5/src/handshake/README.md create mode 100644 crates/o5/src/handshake/handshake_client.rs create mode 100644 crates/o5/src/handshake/handshake_server.rs create mode 100644 crates/o5/src/handshake/kyber.rs create mode 100644 crates/o5/src/handshake/ntor_obfs4.rs create mode 100644 crates/o5/src/handshake/utils.rs create mode 100644 crates/o5/src/handshake_old/integration.rs create mode 100644 crates/o5/src/handshake_old/mod.rs create mode 100644 crates/o5/src/proto.rs create mode 100644 crates/o5/src/pt.rs create mode 100644 crates/o5/src/server.rs create mode 100644 crates/o5/src/sessions.rs create mode 100644 crates/o5/src/test_utils/fake_prng.rs create mode 100644 crates/o5/src/test_utils/mod.rs create mode 100644 crates/o5/src/test_utils/tests.rs create mode 100644 crates/o5/src/testing.rs delete mode 100644 crates/o5/src/transport.rs diff --git a/crates/o5/Cargo.toml b/crates/o5/Cargo.toml index 82aada2..ff78b12 100644 --- a/crates/o5/Cargo.toml +++ b/crates/o5/Cargo.toml @@ -8,19 +8,53 @@ name = "o5" crate-type = ["cdylib", "rlib"] [dependencies] +## Local +ptrs = { path="../ptrs", version="0.1.0" } + +## PRNG getrandom = "0.2.11" rand = { version="0.8.5", features=["getrandom"]} rand_core = "0.6.4" +## Crypto +digest = { version = "0.10.7", features=["mac"]} +siphasher = "1.0.0" +sha2 = "0.10.8" +hmac = { version="0.12.1", features=["reset"]} +hkdf = "0.12.3" +crypto_secretbox = { version="0.1.1", features=["salsa20"]} subtle = "2.5.0" x25519-dalek = { version = "2.0.1", features = ["static_secrets", "getrandom", "reusable_secrets", "elligator2"], git = "https://github.com/jmwample/curve25519-dalek.git", branch = "elligator2-ntor"} -# ntor_arti +## Utils +pin-project = "1.1.3" +hex = "0.4.3" +futures = "0.3.29" +tracing = "0.1.40" +colored = "2.0.4" +serde_json = "1.0.114" +serde = "1.0.197" +base64 = "0.22.0" + +## Networking tools +tokio = { version = "1.33", features = ["io-util", "rt-multi-thread", "net", "rt", "macros", "sync", "signal", "time", "fs"] } +tokio-util = { version = "0.7.10", features = ["codec", "io"]} +bytes = "1.5.0" + +## ntor_arti +tor-cell = "0.16.0" +tor-llcrypto = "0.7.0" +tor-error = "0.6.1" +tor-bytes = "0.10.0" +cipher = "0.4.4" zeroize = "1.7.0" +thiserror = "1.0.56" [dev-dependencies] -hex = "0.4.3" anyhow = "1.0" +tracing-subscriber = "0.3.18" +hex-literal = "0.4.1" +tor-basic-utils = "0.8.0" # o5 pqc test # pqc_kyber = {version="0.7.1", features=["kyber1024", "std"]} diff --git a/crates/o5/README.md b/crates/o5/README.md index 11c6c84..da76dca 100644 --- a/crates/o5/README.md +++ b/crates/o5/README.md @@ -1,7 +1,7 @@ # o5 Pluggable Transport Library -A randomizing look like nothing pluggable transport library, spiritually a successor -to `obfs4`. +This is a spiritual successor to `obfs4` updating some of the more annoying / out of +date elements without worrying about being backward compatible. ⚠️ 🚧 WARNING This crate is still under construction 🚧 ⚠️ @@ -10,30 +10,38 @@ to `obfs4`. - Not production ready - do not rely on this for any security critical applications - -## Changes from obfs4: - - -* adds `Kyber1024` to the Key exchange making it hybrid `Kyber1024X25519` (or `Kyber1024X`) - * Are Kyber1024 keys uniform random? I assume not. -* aligns algorithm with vanilla ntor - - obfs4 does an extra hash -* change mark and MAC from sha256-128 to sha256 - - not sure why this was done in the first place -* padding change (/fix?) -* padding is a frame type, not just appended bytes -* version / params frame for negotiating (non-forward secret in the first exchange alongside PRNG seed) -* might add - - session tickets and resumption - - bidirectional heartbeats - - handshake complete frame type - +## Differences from obfs4 + +- Frame / Packet / Message construction + - In obfs4 a "frame" consists of a signle "packet", encoded using xsalsa20Poly1305. + we use the same frame construction, but change a few key elements: + - the concept of "packets" is now called "messages" + - a frame can contain multiple messages + - update from xsalsa20poly1305 -> chacha20poly1305 + - padding is given an explicit message type different than that of a payload and uses the mesage length header field + - (In obfs4 a frame that decodes to a payload packet type `\x00` with packet length 0 is asummed to all be padding) + - move payload to message type `\x01` + - padding takes message type `\x00` + - (Maybe) add bidirectional heartbeat messages +- Handshake + - x25519 key-exchange -> Kyber1024X25519 key-exchange + - the overhead padding of the current obfs4 handshake (resulting in paket length in [4096:8192]) is mostly unused + we exchange some of this unused padding for a kyber key to provide post-quantum security to the handshake. + - Are Kyber1024 keys uniform random? I assume not. + - NTor V3 handshake + - the obfs4 handshake uses (a custom version of) the ntor handshake to derive key materials + - (Maybe) change mark and MAC from sha256-128 to sha256 + - handshake parameters encrypted under the key exchange public keys + - the client can provide initial parameters during the handshake, knowing that they are not forward secure. + - the server can provide messages with parameters / extensions in the handshake response (like prngseed) + - like the kyber key, this takes space out of the padding already used in the client handshake. + - (Maybe) session tickets and resumption + - (Maybe) handshake complete frame type ### Goals * Stick closer to Codec / Framed implementation for all packets (hadshake included) * use the tor/arti ntor v3 implementation - ### Features to keep - once a session is established, unrecognized frame types are ignored diff --git a/crates/o5/src/client.rs b/crates/o5/src/client.rs new file mode 100644 index 0000000..eae4470 --- /dev/null +++ b/crates/o5/src/client.rs @@ -0,0 +1,188 @@ +#![allow(unused)] + +use crate::{ + common::{colorize, HmacSha256}, + constants::*, + framing::{FrameError, Marshall, O5Codec, TryParse, KEY_LENGTH, KEY_MATERIAL_LENGTH}, + handshake::O5NtorPublicKey, + proto::{MaybeTimeout, O5Stream, IAT}, + sessions, Error, Result, +}; + +use bytes::{Buf, BufMut, BytesMut}; +use hmac::{Hmac, Mac}; +use ptrs::{debug, info, trace, warn}; +use rand::prelude::*; +use subtle::ConstantTimeEq; +use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}; +use tokio::time::{Duration, Instant}; + +use std::{ + fmt, + io::{Error as IoError, ErrorKind as IoErrorKind}, + pin::Pin, + sync::{Arc, Mutex}, +}; + +#[derive(Clone, Debug)] +pub struct ClientBuilder { + pub iat_mode: IAT, + pub station_pubkey: [u8; KEY_LENGTH], + pub station_id: [u8; NODE_ID_LENGTH], + pub statefile_path: Option, + pub(crate) handshake_timeout: MaybeTimeout, +} + +impl Default for ClientBuilder { + fn default() -> Self { + Self { + iat_mode: IAT::Off, + station_pubkey: [0u8; KEY_LENGTH], + station_id: [0_u8; NODE_ID_LENGTH], + statefile_path: None, + handshake_timeout: MaybeTimeout::Default_, + } + } +} + +impl ClientBuilder { + /// TODO: implement client builder from statefile + pub fn from_statefile(location: &str) -> Result { + Ok(Self { + iat_mode: IAT::Off, + station_pubkey: [0_u8; KEY_LENGTH], + station_id: [0_u8; NODE_ID_LENGTH], + statefile_path: Some(location.into()), + handshake_timeout: MaybeTimeout::Default_, + }) + } + + /// TODO: implement client builder from string args + pub fn from_params(param_strs: Vec>) -> Result { + Ok(Self { + iat_mode: IAT::Off, + station_pubkey: [0_u8; KEY_LENGTH], + station_id: [0_u8; NODE_ID_LENGTH], + statefile_path: None, + handshake_timeout: MaybeTimeout::Default_, + }) + } + + pub fn with_node_pubkey(&mut self, pubkey: [u8; KEY_LENGTH]) -> &mut Self { + self.station_pubkey = pubkey; + self + } + + pub fn with_statefile_path(&mut self, path: &str) -> &mut Self { + self.statefile_path = Some(path.into()); + self + } + + pub fn with_node_id(&mut self, id: [u8; NODE_ID_LENGTH]) -> &mut Self { + self.station_id = id; + self + } + + pub fn with_iat_mode(&mut self, iat: IAT) -> &mut Self { + self.iat_mode = iat; + self + } + + pub fn with_handshake_timeout(&mut self, d: Duration) -> &mut Self { + self.handshake_timeout = MaybeTimeout::Length(d); + self + } + + pub fn with_handshake_deadline(&mut self, deadline: Instant) -> &mut Self { + self.handshake_timeout = MaybeTimeout::Fixed(deadline); + self + } + + pub fn fail_fast(&mut self) -> &mut Self { + self.handshake_timeout = MaybeTimeout::Unset; + self + } + + pub fn build(&self) -> Client { + Client { + iat_mode: self.iat_mode, + station_pubkey: O5NtorPublicKey { + id: self.station_id.into(), + pk: self.station_pubkey.into(), + }, + handshake_timeout: self.handshake_timeout.duration(), + } + } + + pub fn as_opts(&self) -> String { + //TODO: String self as command line options + "".into() + } +} + +impl fmt::Display for ClientBuilder { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + //TODO: string self + write!(f, "") + } +} + +/// Client implementing the obfs4 protocol. +pub struct Client { + iat_mode: IAT, + station_pubkey: O5NtorPublicKey, + handshake_timeout: Option, +} + +impl Client { + /// TODO: extract args to create new builder + pub fn get_args(&mut self, _args: &dyn std::any::Any) {} + + /// On a failed handshake the client will read for the remainder of the + /// handshake timeout and then close the connection. + pub async fn wrap<'a, T>(self, mut stream: T) -> Result> + where + T: AsyncRead + AsyncWrite + Unpin + 'a, + { + let session = sessions::new_client_session(self.station_pubkey, self.iat_mode); + + let deadline = self.handshake_timeout.map(|d| Instant::now() + d); + + session.handshake(stream, deadline).await + } + + /// On a failed handshake the client will read for the remainder of the + /// handshake timeout and then close the connection. + pub async fn establish<'a, T, E>( + self, + mut stream_fut: Pin>, + ) -> Result> + where + T: AsyncRead + AsyncWrite + Unpin + 'a, + E: std::error::Error + Send + Sync + 'static, + { + let stream = stream_fut.await.map_err(|e| Error::Other(Box::new(e)))?; + + let session = sessions::new_client_session(self.station_pubkey, self.iat_mode); + + let deadline = self.handshake_timeout.map(|d| Instant::now() + d); + + session.handshake(stream, deadline).await + } +} + +#[cfg(test)] +mod test { + use super::*; + use crate::Result; + + #[test] + fn parse_params() -> Result<()> { + let test_args = [["", "", ""]]; + + for (i, test_case) in test_args.iter().enumerate() { + let cb = ClientBuilder::from_params(test_case.to_vec())?; + } + Ok(()) + } +} diff --git a/crates/o5/src/common/README.md b/crates/o5/src/common/README.md new file mode 100644 index 0000000..6e4cdc9 --- /dev/null +++ b/crates/o5/src/common/README.md @@ -0,0 +1,10 @@ + +# Common tools + + + + +### TODO + +- [ ] better probdist actually using [Distribution]() for [Rng]()? + - we want this to be possible to implement in both rust and golang. diff --git a/crates/o5/src/common/ct.rs b/crates/o5/src/common/ct.rs new file mode 100644 index 0000000..ba0d48a --- /dev/null +++ b/crates/o5/src/common/ct.rs @@ -0,0 +1,17 @@ +//! Constant-time utilities. +use subtle::{Choice, ConstantTimeEq}; + +/// Convert a boolean into a Choice. +/// +/// This isn't necessarily a good idea or constant-time. +pub(crate) fn bool_to_choice(v: bool) -> Choice { + Choice::from(u8::from(v)) +} + +/// Return true if two slices are equal. Performs its operation in constant +/// time, but returns a bool instead of a subtle::Choice. +#[allow(unused)] +pub(crate) fn bytes_eq(a: &[u8], b: &[u8]) -> bool { + let choice = a.ct_eq(b); + choice.unwrap_u8() == 1 +} diff --git a/crates/o5/src/common/curve25519.rs b/crates/o5/src/common/curve25519.rs new file mode 100644 index 0000000..5bdd713 --- /dev/null +++ b/crates/o5/src/common/curve25519.rs @@ -0,0 +1,157 @@ +//! Re-exporting Curve25519 implementations. +//! +//! *TODO*: Eventually we should probably recommend using this code via some +//! key-agreement trait, but for now we are just re-using the APIs from +//! [`x25519_dalek`]. + +// TODO: We may want eventually want to expose ReusableSecret instead of +// StaticSecret, for use in places where we need to use a single secret +// twice in one handshake, but we do not need that secret to be persistent. +// +// The trouble here is that if we use ReusableSecret in these cases, we +// cannot easily construct it for testing purposes. We could in theory +// kludge something together using a fake Rng, but that might be more +// trouble than we want to go looking for. +#[allow(unused)] +pub use x25519_dalek::{ + EphemeralSecret, PublicKey, PublicRepresentative, ReusableSecret, SharedSecret, StaticSecret, +}; + +use rand_core::{CryptoRng, RngCore}; + +pub const REPRESENTATIVE_LENGTH: usize = 32; + +/// Curve25519 keys that are guaranteed to have a valid Elligator2 representative. +/// As only certain Curve25519 keys can be obfuscated with Elligator2, the +/// representative must be checked when generating the secret key. +/// +/// The probablility that a key does not have a representable elligator2 encoding +/// is ~50%, so we are (statistiscally) guaranteed to find a representable key +/// in relatively few iterations. +pub struct Representable; + +const RETRY_LIMIT: usize = 128; + +#[allow(unused)] +impl Representable { + /// Generate a new Elligator2 representable ['StaticSecret'] with the supplied RNG. + pub fn static_from_rng(mut rng: R) -> StaticSecret { + let mut private = StaticSecret::random_from_rng(&mut rng); + let mut repres: Option = (&private).into(); + + for _ in 0..RETRY_LIMIT { + if repres.is_some() { + return private; + } + private = StaticSecret::random_from_rng(&mut rng); + repres = (&private).into(); + } + + panic!("failed to generate representable secret, bad RNG provided"); + } + + /// Generate a new Elligator2 representable ['ReusableSecret'] with the supplied RNG. + pub fn reusable_from_rng(mut rng: R) -> ReusableSecret { + let mut private = ReusableSecret::random_from_rng(&mut rng); + let mut repres: Option = (&private).into(); + + for _ in 0..RETRY_LIMIT { + if repres.is_some() { + return private; + } + private = ReusableSecret::random_from_rng(&mut rng); + repres = (&private).into(); + } + + panic!("failed to generate representable secret, bad RNG provided"); + } + + /// Generate a new Elligator2 representable ['EphemeralSecret'] with the supplied RNG. + pub fn ephemeral_from_rng(mut rng: R) -> EphemeralSecret { + let mut private = EphemeralSecret::random_from_rng(&mut rng); + let mut repres: Option = (&private).into(); + + for _ in 0..RETRY_LIMIT { + if repres.is_some() { + return private; + } + private = EphemeralSecret::random_from_rng(&mut rng); + repres = (&private).into(); + } + + panic!("failed to generate representable secret, bad RNG provided"); + } + + /// Generate a new Elligator2 representable ['StaticSecret']. + pub fn random_static() -> StaticSecret { + let mut private = StaticSecret::random(); + let mut repres: Option = (&private).into(); + + for _ in 0..RETRY_LIMIT { + if repres.is_some() { + return private; + } + private = StaticSecret::random(); + repres = (&private).into(); + } + + panic!("failed to generate representable secret, getrandom failed"); + } + + /// Generate a new Elligator2 representable ['ReusableSecret']. + pub fn random_reusable() -> ReusableSecret { + let mut private = ReusableSecret::random(); + let mut repres: Option = (&private).into(); + + for _ in 0..RETRY_LIMIT { + if repres.is_some() { + return private; + } + private = ReusableSecret::random(); + repres = (&private).into(); + } + + panic!("failed to generate representable secret, getrandom failed"); + } + + /// Generate a new Elligator2 representable ['EphemeralSecret']. + pub fn random_ephemeral() -> EphemeralSecret { + let mut private = EphemeralSecret::random(); + let mut repres: Option = (&private).into(); + + for _ in 0..RETRY_LIMIT { + if repres.is_some() { + return private; + } + private = EphemeralSecret::random(); + repres = (&private).into(); + } + + panic!("failed to generate representable secret, getrandom failed"); + } +} + +#[cfg(test)] +mod test { + use super::*; + use hex::FromHex; + + #[test] + fn representative_match() { + let mut repres = <[u8; 32]>::from_hex( + "8781b04fefa49473ca5943ab23a14689dad56f8118d5869ad378c079fd2f4079", + ) + .unwrap(); + let incorrect = "1af2d7ac95b5dd1ab2b5926c9019fa86f211e77dd796f178f3fe66137b0d5d15"; + let expected = "a946c3dd16d99b8c38972584ca599da53e32e8b13c1e9a408ff22fdb985c2d79"; + + // we are not clearing the high order bits before translating the representative to a + // public key. + repres[31] &= 0x3f; + + let r = PublicRepresentative::from(repres); + let p = PublicKey::from(&r); + assert_ne!(incorrect, hex::encode(p.as_bytes())); + assert_eq!(expected, hex::encode(p.as_bytes())); + } +} diff --git a/crates/o5/src/common/drbg.rs b/crates/o5/src/common/drbg.rs new file mode 100644 index 0000000..92c98fa --- /dev/null +++ b/crates/o5/src/common/drbg.rs @@ -0,0 +1,348 @@ +/// +/// # DRBG +/// +/// Implements a simple Hash based Deterministic Random Bit Generator (DRBG) +/// algorithm in order to match the golang implementation of obfs4. +use crate::{Error, Result}; + +use std::fmt; +use std::str::FromStr; + +use getrandom::getrandom; +use hex::FromHex; +use rand_core::{impls, Error as RandError, RngCore}; +use siphasher::{prelude::*, sip::SipHasher24}; + +pub(crate) const SIZE: usize = 8; +pub(crate) const SEED_LENGTH: usize = 16 + SIZE; + +/// Hash-DRBG seed +#[derive(Debug, PartialEq, Clone)] +pub struct Seed([u8; SEED_LENGTH]); + +impl Seed { + pub fn new() -> Result { + let mut seed = Self([0_u8; SEED_LENGTH]); + getrandom(&mut seed.0)?; + Ok(seed) + } + + // Calling unwraps here is safe because the size of the key is fixed + fn to_pieces(&self) -> ([u8; 16], [u8; SIZE]) { + let key: [u8; 16] = self.0[..16].try_into().unwrap(); + + let ofb: [u8; SIZE] = self.0[16..].try_into().unwrap(); + (key, ofb) + } + + fn to_new_drbg(&self) -> Drbg { + let (key, ofb) = self.to_pieces(); + Drbg { + hash: SipHasher24::new_with_key(&key), + ofb, + } + } + + pub fn to_bytes(&self) -> [u8; SEED_LENGTH] { + self.0 + } + + pub fn as_bytes(&self) -> &[u8] { + &self.0 + } +} + +impl FromHex for Seed { + type Error = Error; + + fn from_hex>(msg: T) -> Result { + let buffer = <[u8; SEED_LENGTH]>::from_hex(msg)?; + Ok(Seed(buffer)) + } +} + +impl TryFrom for Seed { + type Error = Error; + + fn try_from(msg: String) -> Result { + let buffer = <[u8; SEED_LENGTH]>::from_hex(msg)?; + Ok(Seed(buffer)) + } +} + +impl TryFrom<&String> for Seed { + type Error = Error; + + fn try_from(msg: &String) -> Result { + let buffer = <[u8; SEED_LENGTH]>::from_hex(msg)?; + Ok(Seed(buffer)) + } +} + +impl TryFrom<&str> for Seed { + type Error = Error; + + fn try_from(msg: &str) -> Result { + let buffer = <[u8; SEED_LENGTH]>::from_hex(msg)?; + Ok(Seed(buffer)) + } +} + +impl FromStr for Seed { + type Err = Error; + fn from_str(s: &str) -> Result { + Seed::from_hex(s) + } +} + +impl TryFrom<&[u8]> for Seed { + type Error = Error; + fn try_from(arr: &[u8]) -> Result { + let mut seed = Seed::new()?; + if arr.len() != SEED_LENGTH { + let e = format!("incorrect drbg seed length {}!={SEED_LENGTH}", arr.len()); + return Err(Error::Other(e.into())); + } + + seed.0 = arr + .try_into() + .map_err(|e| Error::Other(format!("{e}").into()))?; + + Ok(seed) + } +} + +impl From<[u8; SEED_LENGTH]> for Seed { + fn from(arr: [u8; SEED_LENGTH]) -> Self { + Seed(arr) + } +} + +impl TryFrom> for Seed { + type Error = Error; + fn try_from(arr: Vec) -> Result { + Seed::try_from(arr.as_slice()) + } +} + +impl fmt::Display for Seed { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{}", hex::encode(&self.0[..])) + } +} + +pub struct Drbg { + #[allow(deprecated)] + hash: SipHasher24, + ofb: [u8; SIZE], +} + +impl Drbg { + /// Makes a 'Drbg' instance based off an optional seed. The seed + /// is truncated to SeedLength. + pub fn new(seed_in: Option) -> Result { + let seed = match seed_in { + Some(s) => s, + None => Seed::new()?, + }; + Ok(seed.to_new_drbg()) + } + + /// Returns a uniformly distributed random uint [0, 1 << 64). + pub fn uint64(&mut self) -> u64 { + let ret: u64 = { + self.hash.write(&self.ofb[..]); + self.hash.finish().to_be() + }; + self.ofb = ret.to_be_bytes(); + + ret + } + + /// returns a random u16 selected in the same way as the golang implementation + /// of obfs4 which takes the high bits when casting to u16. + pub(crate) fn length_mask(&mut self) -> u16 { + let ret: u64 = { + self.hash.write(&self.ofb[..]); + self.hash.finish().to_be() + }; + self.ofb = ret.to_be_bytes(); + + (ret >> 48) as u16 + } + + /// Returns a uniformly distributed random integer [0, 1 << 63). + pub fn int63(&mut self) -> i64 { + let mut ret = self.uint64(); + + // This is a safe unwrap as we bit-mask to below overflow + // ret &= (1<<63) -1; + ret &= >::try_into(i64::MAX).unwrap(); + i64::try_from(ret).unwrap() + } + + /// NextBlock returns the next 8 byte DRBG block. + pub fn next_block(&mut self) -> [u8; SIZE] { + let h = self.uint64(); + h.to_be_bytes() + } +} + +impl RngCore for Drbg { + fn next_u32(&mut self) -> u32 { + self.next_u64() as u32 + } + + fn next_u64(&mut self) -> u64 { + self.uint64() + } + + fn fill_bytes(&mut self, dest: &mut [u8]) { + impls::fill_bytes_via_next(self, dest) + } + + fn try_fill_bytes(&mut self, dest: &mut [u8]) -> std::result::Result<(), RandError> { + self.fill_bytes(dest); + Ok(()) + } +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn rand() -> Result<()> { + let seed = Seed::new()?; + + let mut drbg = Drbg::new(Some(seed))?; + + let mut u: u64; + let mut i: i64; + for n in 0..100_000 { + i = drbg.int63(); + assert!(i > 0, "i63 error - {i} < 0 iter:{n}"); + + u = drbg.uint64(); + assert_ne!(u, 0); + } + + Ok(()) + } + + #[test] + fn from_() -> Result<()> { + let expected = Seed([0_u8; SEED_LENGTH]); + + let input = "000000000000000000000000000000000000000000000000"; + assert_eq!(Seed::try_from(input).unwrap(), expected); + assert_eq!(Seed::from_hex(input).unwrap(), expected); + assert_eq!(Seed::from_str(input).unwrap(), expected); + + let input: String = input.into(); + assert_eq!(Seed::try_from(input.clone()).unwrap(), expected); + assert_eq!(Seed::from_hex(input.clone()).unwrap(), expected); + assert_eq!(Seed::try_from(&input.clone()).unwrap(), expected); + assert_eq!(Seed::from_hex(input.clone()).unwrap(), expected); + assert_eq!(Seed::from_str(&input.clone()).unwrap(), expected); + + let input = [0_u8; SEED_LENGTH]; + assert_eq!(Seed::from(input), expected); + assert_eq!(Seed::try_from(&input[..]).unwrap(), expected); + + let input = vec![0_u8; SEED_LENGTH]; + assert_eq!(Seed::try_from(input.clone()).unwrap(), expected); + assert_eq!(Seed::try_from(&input.clone()[..]).unwrap(), expected); + + Ok(()) + } + + /// Make sure bitmasks, overflows, and type assertions work the way I think they do. + #[test] + fn conversions() { + let mut u64_max = u64::MAX; + >::try_into(u64_max).unwrap_err(); + + u64_max &= >::try_into(i64::MAX).unwrap(); + let i: i64 = u64_max.try_into().unwrap(); + // println!("{i:x}, {:x}", i64::MAX); + assert_eq!(i, i64::MAX); + + let mut u64_max = u64::MAX; + u64_max &= (1 << 63) - 1; + let i: i64 = u64_max.try_into().unwrap(); + assert_eq!(i, i64::MAX); + assert_eq!(i, i64::MAX); + + let u64_max: u64 = (1 << 63) - 1; + let i: i64 = u64_max.try_into().unwrap(); + assert_eq!(i, i64::MAX); + assert_eq!(i, i64::MAX); + } + + /// Ensure that we are compatible with the golang hash-drbg so that the + /// libraries are interchangeable. + #[test] + fn sample_compat_compare() -> Result<()> { + struct Case { + seed: &'static str, + out: Vec, + } + + // if we can generate multiple correct rounds for multiple seeds we should be just fine. + let cases = vec![ + Case { + seed: "000000000000000000000000000000000000000000000000", + out: vec![ + 7432626515892259304, + 5773523046280711756, + 4537542203639783680, + ], + }, + // (0, 0) "00000000000000000000000000000000" + // &{v0:8317987319222330741 v1:7237128888997146477 v2:7816392313619706465 v3:8387220255154660723 } k0:0 k1:0 x:[0 0 0 0 0 0 0 0] nx:0 size:8 t:0} + // { v0:8317987319222330741 v1:7237128888997146477 v2:7816392313619706465 v3:8387220255154660723 } + Case { + seed: "0c10867722204c856e78315d669449dcb6e66f2fe5247a80", + out: vec![ + 9059004827137905928, + 6853924365612632173, + 1485252377529977150, + ], + }, + // 854c20227786100c dc4994665d31786e k0:9605087437680676876 k1:15873381529015122030 + // (9605087437680676876, 15873381529015122030) "0c10867722204c856e78315d669449dc" + Case { + seed: "ddbb886aefbe2a65c2509dfc3bb0932c5e881965afca80a0", + out: vec![ + 3952461850862704951, + 6715353867928838006, + 5560038622741453571, + ], + }, + Case { + seed: "e691b1eaa81018e8b16bbf84d71f3ba0c5f965bace2da7cc", + out: vec![ + 8251725530906761037, + 5718043109939568014, + 7585544303175018394, + ], + }, + ]; + + for (j, c) in cases.into_iter().enumerate() { + let seed = Seed::try_from(c.seed)?; + let drbg = &mut Drbg::new(Some(seed))?; + // println!(); + // println!("{:?}", drbg.hash); + + for (k, expected) in c.out.into_iter().enumerate() { + let i = drbg.int63(); + // println!("{:?}", drbg.hash); + assert_eq!(i, expected, "[{},{}]\n0x{i:x}\n0x{expected:x}", j, k); + } + } + + Ok(()) + } +} diff --git a/crates/o5/src/common/kdf.rs b/crates/o5/src/common/kdf.rs new file mode 100644 index 0000000..f0a9401 --- /dev/null +++ b/crates/o5/src/common/kdf.rs @@ -0,0 +1,158 @@ +//! Key derivation functions +//! +//! Tor has three relevant key derivation functions that it uses for +//! deriving keys used for relay encryption. +//! +//! The *KDF-TOR* KDF (implemented by `LegacyKdf`) is used with the old +//! TAP handshake. It is ugly, it is based on SHA-1, and it should be +//! avoided for new uses. It is not even linked here as we will not use it in +//! this obfuscated protocol implementation. +//! +//! The *HKDF-SHA256* KDF (implemented by `Ntor1Kdf`) is used with the +//! Ntor handshake. It is based on RFC5869 and SHA256. +//! +//! The *SHAKE* KDF (implemented by `ShakeKdf` is used with v3 onion +//! services, and is likely to be used by other places in the future. +//! It is based on SHAKE-256. + +use crate::{Error, Result}; + +use digest::{ExtendableOutput, Update, XofReader}; +use tor_bytes::SecretBuf; +use tor_llcrypto::d::{Sha256, Shake256}; + +/// A trait for a key derivation function. +pub(crate) trait Kdf { + /// Derive `n_bytes` of key data from some secret `seed`. + fn derive(&self, seed: &[u8], n_bytes: usize) -> Result; +} + +/// A parameterized KDF, for use with ntor. +/// +/// This KDF is based on HKDF-SHA256. +pub(crate) struct Ntor1Kdf<'a, 'b> { + /// A constant for parameterizing the kdf, during the key extraction + /// phase. + t_key: &'a [u8], + /// Another constant for parameterizing the kdf, during the key + /// expansion phase. + m_expand: &'b [u8], +} + +/// A modern KDF, for use with v3 onion services. +/// +/// This KDF is based on SHAKE256 +pub(crate) struct ShakeKdf(); + +impl<'a, 'b> Ntor1Kdf<'a, 'b> { + /// Instantiate an Ntor1Kdf, with given values for t_key and m_expand. + pub(crate) fn new(t_key: &'a [u8], m_expand: &'b [u8]) -> Self { + Ntor1Kdf { t_key, m_expand } + } +} + +impl Kdf for Ntor1Kdf<'_, '_> { + fn derive(&self, seed: &[u8], n_bytes: usize) -> Result { + let hkdf = hkdf::Hkdf::::new(Some(self.t_key), seed); + + let mut result: SecretBuf = vec![0; n_bytes].into(); + hkdf.expand(self.m_expand, result.as_mut()) + .map_err(|_| Error::InvalidKDFOutputLength)?; + Ok(result) + } +} + +impl ShakeKdf { + /// Instantiate a ShakeKdf. + pub(crate) fn new() -> Self { + ShakeKdf() + } +} +impl Kdf for ShakeKdf { + fn derive(&self, seed: &[u8], n_bytes: usize) -> Result { + let mut xof = Shake256::default(); + xof.update(seed); + let mut result: SecretBuf = vec![0; n_bytes].into(); + xof.finalize_xof().read(result.as_mut()); + Ok(result) + } +} + +#[cfg(test)] +// @@ begin test lint list maintained by maint/add_warning @@ +#[allow(clippy::bool_assert_comparison)] +#[allow(clippy::clone_on_copy)] +#[allow(clippy::dbg_macro)] +#[allow(clippy::print_stderr)] +#[allow(clippy::print_stdout)] +#[allow(clippy::single_char_pattern)] +#[allow(clippy::unwrap_used)] +#[allow(clippy::unchecked_duration_subtraction)] +#[allow(clippy::useless_vec)] +#[allow(clippy::needless_pass_by_value)] +// +mod test { + use super::*; + use hex_literal::hex; + + #[test] + fn clearbox_ntor1_kdf() { + // Calculate Ntor1Kdf, and make sure we get the same result by + // following the calculation in the spec. + let input = b"another example key seed that we will expand"; + let result = Ntor1Kdf::new(&b"key"[..], &b"expand"[..]) + .derive(input, 99) + .unwrap(); + + let kdf = hkdf::Hkdf::::new(Some(&b"key"[..]), &input[..]); + let mut expect_result = vec![0_u8; 99]; + kdf.expand(&b"expand"[..], &mut expect_result[..]).unwrap(); + + assert_eq!(&expect_result[..], &result[..]); + } + + #[test] + fn testvec_ntor1_kdf() { + // From Tor's test_crypto.c; generated with ntor_ref.py + fn expand(b: &[u8]) -> SecretBuf { + let t_key = b"ntor-curve25519-sha256-1:key_extract"; + let m_expand = b"ntor-curve25519-sha256-1:key_expand"; + Ntor1Kdf::new(&t_key[..], &m_expand[..]) + .derive(b, 100) + .unwrap() + } + + let expect = hex!( + "5521492a85139a8d9107a2d5c0d9c91610d0f95989975ebee6 + c02a4f8d622a6cfdf9b7c7edd3832e2760ded1eac309b76f8d + 66c4a3c4d6225429b3a016e3c3d45911152fc87bc2de9630c3 + 961be9fdb9f93197ea8e5977180801926d3321fa21513e59ac" + ); + assert_eq!(&expand(&b"Tor"[..])[..], &expect[..]); + + let brunner_quote = b"AN ALARMING ITEM TO FIND ON YOUR CREDIT-RATING STATEMENT"; + let expect = hex!( + "a2aa9b50da7e481d30463adb8f233ff06e9571a0ca6ab6df0f + b206fa34e5bc78d063fc291501beec53b36e5a0e434561200c + 5f8bd13e0f88b3459600b4dc21d69363e2895321c06184879d + 94b18f078411be70b767c7fc40679a9440a0c95ea83a23efbf" + ); + assert_eq!(&expand(&brunner_quote[..])[..], &expect[..]); + } + + #[test] + fn testvec_shake_kdf() { + // This is just one of the shake test vectors from tor-llcrypto + let input = hex!( + "76891a7bcc6c04490035b743152f64a8dd2ea18ab472b8d36ecf45 + 858d0b0046" + ); + let expected = hex!( + "e8447df87d01beeb724c9a2a38ab00fcc24e9bd17860e673b02122 + 2d621a7810e5d3" + ); + + let result = ShakeKdf::new().derive(&input[..], expected.len()); + assert_eq!(&result.unwrap()[..], &expected[..]); + } +} diff --git a/crates/o5/src/common/mod.rs b/crates/o5/src/common/mod.rs new file mode 100644 index 0000000..3ea0ed6 --- /dev/null +++ b/crates/o5/src/common/mod.rs @@ -0,0 +1,37 @@ +use crate::Result; + +use colored::Colorize; +use hmac::Hmac; +use sha2::Sha256; + +pub(crate) mod ct; +pub(crate) mod curve25519; +pub(crate) mod kdf; + +mod skip; +pub use skip::discard; + +pub mod drbg; +// pub mod ntor; +pub mod ntor_arti; +pub mod probdist; +pub mod replay_filter; + +pub trait ArgParse { + type Output; + + fn parse_args() -> Result; +} + +pub(crate) type HmacSha256 = Hmac; + +pub(crate) fn colorize(b: impl AsRef<[u8]>) -> String { + let id = b.as_ref(); + if id.len() < 3 { + return hex::encode(id); + } + let r = id[0]; + let g = id[1]; + let b = id[2]; + hex::encode(id).truecolor(r, g, b).to_string() +} diff --git a/crates/o5/src/common/ntor_arti/mod.rs b/crates/o5/src/common/ntor_arti/mod.rs new file mode 100644 index 0000000..34ba8dc --- /dev/null +++ b/crates/o5/src/common/ntor_arti/mod.rs @@ -0,0 +1,180 @@ +//! Generic Handshake for Tor. Extension of Tor circuit creation handshake design. +//! +//! Tor circuit handshakes all implement a one-way-authenticated key +//! exchange, where a client that knows a public "onion key" for a +//! relay sends a "client onionskin" to extend to a relay, and receives a +//! "relay onionskin" in response. When the handshake is successful, +//! both the client and relay share a set of session keys, and the +//! client knows that nobody _else_ shares those keys unless they +//! relay's private onion key. +//! +//! Currently, this module implements only the "ntor" handshake used +//! for circuits on today's Tor. +use std::borrow::Borrow; + +use crate::Result; +//use zeroize::Zeroizing; +use tor_bytes::SecretBuf; + +/// A ClientHandshake is used to generate a client onionskin and +/// handle a relay onionskin. +pub(crate) trait ClientHandshake { + /// The type for the onion key. + type KeyType; + /// The type for the state that the client holds while waiting for a reply. + type StateType; + /// A type that is returned and used to generate session keys.x + type KeyGen; + /// Type of extra data sent from client (without forward secrecy). + type ClientAuxData: ?Sized; + /// Type of extra data returned by server (without forward secrecy). + type ServerAuxData; + /// Generate a new client onionskin for a relay with a given onion key, + /// including `client_aux_data` to be sent without forward secrecy. + /// + /// On success, return a state object that will be used to + /// complete the handshake, along with the message to send. + fn client1>( + key: &Self::KeyType, + client_aux_data: &M, + ) -> Result<(Self::StateType, Vec)>; + /// Handle an onionskin from a relay, and produce aux data returned + /// from the server, and a key generator. + /// + /// The state object must match the one that was used to make the + /// client onionskin that the server is replying to. + fn client2>( + state: Self::StateType, + msg: T, + ) -> Result<(Self::ServerAuxData, Self::KeyGen)>; +} + +/// Trait for an object that handles incoming auxiliary data and +/// returns the server's auxiliary data to be included in the reply. +/// +/// This is implemented for `FnMut(&H::ClientAuxData) -> Option` automatically. +pub(crate) trait AuxDataReply +where + H: ServerHandshake + ?Sized, +{ + /// Given a list of extensions received from a client, decide + /// what extensions to send in reply. + /// + /// Return None if the handshake should fail. + fn reply(&mut self, msg: &H::ClientAuxData) -> Option; +} + +impl AuxDataReply for F +where + H: ServerHandshake + ?Sized, + F: FnMut(&H::ClientAuxData) -> Option, +{ + fn reply(&mut self, msg: &H::ClientAuxData) -> Option { + self(msg) + } +} + +/// A ServerHandshake is used to handle a client onionskin and generate a +/// server onionskin. +pub(crate) trait ServerHandshake { + /// The type for the onion key. This is a private key type. + type KeyType; + /// The returned key generator type. + type KeyGen; + /// Type of extra data sent from client (without forward secrecy). + type ClientAuxData: ?Sized; + /// Type of extra data returned by server (without forward secrecy). + type ServerAuxData; + + /// Perform the server handshake. Take as input a function for processing + /// requested extensions, a slice of all our private onion keys, and the + /// client's message. + /// + /// On success, return a key generator and a server handshake message + /// to send in reply. + /// + /// The self parameter is a type / struct for (potentially shared) state + /// accessible during the server handshake. + fn server, T: AsRef<[u8]>>( + &self, + reply_fn: &mut REPLY, + key: &[Self::KeyType], + msg: T, + ) -> RelayHandshakeResult<(Self::KeyGen, Vec)>; +} + +/// A KeyGenerator is returned by a handshake, and used to generate +/// session keys for the protocol. +/// +/// Typically, it wraps a KDF function, and some seed key material. +/// +/// It can only be used once. +#[allow(unreachable_pub)] // This is only exported depending on enabled features. +pub trait KeyGenerator { + /// Consume the key + fn expand(self, keylen: usize) -> Result; +} + +/// Generates keys based on SHAKE-256. +pub(crate) struct ShakeKeyGenerator { + /// Seed for the key generator + seed: SecretBuf, +} + +impl ShakeKeyGenerator { + /// Create a key generator based on a provided seed + #[allow(dead_code)] // We'll construct these for v3 onion services + pub(crate) fn new(seed: SecretBuf) -> Self { + ShakeKeyGenerator { seed } + } +} + +impl KeyGenerator for ShakeKeyGenerator { + fn expand(self, keylen: usize) -> Result { + use crate::common::kdf::{Kdf, ShakeKdf}; + ShakeKdf::new().derive(&self.seed[..], keylen) + } +} + +/// An error produced by a Relay's attempt to handle a client's onion handshake. +#[derive(Clone, Debug, thiserror::Error)] +pub enum RelayHandshakeError { + /// Occurs when a check did not fail, but requires updated input from the + /// calling context. For example, a handshake that requires more bytes to + /// before it can succeed or fail. + #[error("try again with updated input")] + EAgain, + + /// An error in parsing a handshake message. + #[error("Problem decoding onion handshake")] + Fmt(#[from] tor_bytes::Error), + + /// The client asked for a key we didn't have. + #[error("Client asked for a key or ID that we don't have")] + MissingKey, + + /// The client did something wrong with their handshake or cryptography. + #[error("Bad handshake from client")] + BadClientHandshake, + + /// The server did something wrong with their handshake or cryptography or + /// an otherwise invalid response was received + #[error("Bad handshake from server")] + BadServerHandshake, + + /// The client's handshake matched a previous handshake indicating a potential replay attack. + #[error("Handshake from client was seen recently -- potentially replayed.")] + ReplayedHandshake, + + /// Error occured while creating a frame. + #[error("Problem occured while building handshake")] + FrameError(String), + + /// An internal error. + #[error("Internal error")] + Internal(#[from] tor_error::Bug), +} + +/// Type alias for results from a relay's attempt to handle a client's onion +/// handshake. +pub(crate) type RelayHandshakeResult = std::result::Result; diff --git a/crates/o5/src/common/probdist.rs b/crates/o5/src/common/probdist.rs new file mode 100644 index 0000000..d2a176a --- /dev/null +++ b/crates/o5/src/common/probdist.rs @@ -0,0 +1,268 @@ +//! The probdist module implements a weighted probability distribution suitable for +//! protocol parameterization. To allow for easy reproduction of a given +//! distribution, the drbg package is used as the random number source. + +use crate::common::drbg; + +use std::cmp::{max, min}; +use std::fmt; +use std::sync::{Arc, Mutex}; + +use rand::{seq::SliceRandom, Rng}; + +const MIN_VALUES: i32 = 1; +const MAX_VALUES: i32 = 100; + +/// A weighted distribution of integer values. +#[derive(Clone)] +pub struct WeightedDist(Arc>); + +struct InnerWeightedDist { + min_value: i32, + max_value: i32, + biased: bool, + + values: Vec, + weights: Vec, + + alias: Vec, + prob: Vec, +} + +impl WeightedDist { + /// New creates a weighted distribution of values ranging from min to max + /// based on a HashDrbg initialized with seed. Optionally, bias the weight + /// generation to match the ScrambleSuit non-uniform distribution from + /// obfsproxy. + pub fn new(seed: drbg::Seed, min: i32, max: i32, biased: bool) -> Self { + let w = WeightedDist(Arc::new(Mutex::new(InnerWeightedDist { + min_value: min, + max_value: max, + biased, + values: vec![], + weights: vec![], + alias: vec![], + prob: vec![], + }))); + let _ = &w.reseed(seed); + + w + } + + /// Generates a random value according to the generated distribution. + pub fn sample(&self) -> i32 { + let dist = self.0.lock().unwrap(); + + let mut buf = [0_u8; 8]; + // Generate a fair die roll fro a $n$-sided die; call the side $i$. + getrandom::getrandom(&mut buf).unwrap(); + + #[cfg(target_pointer_width = "64")] + let i = usize::from_ne_bytes(buf) % dist.values.len(); + + #[cfg(target_pointer_width = "32")] + let i = usize::from_ne_bytes(buf[0..4].try_into().unwrap()) % dist.values.len(); + + // flip a coin that comes up heads with probability $prob[i]$. + getrandom::getrandom(&mut buf).unwrap(); + let f = f64::from_ne_bytes(buf); + if f < dist.prob[i] { + // if the coin comes up "heads", use $i$ + dist.min_value + dist.values[i] + } else { + // otherwise use $alias[i]$. + dist.min_value + dist.values[dist.alias[i]] + } + } + + /// Generates a new distribution with the same min/max based on a new seed. + pub fn reseed(&self, seed: drbg::Seed) { + let mut drbg = drbg::Drbg::new(Some(seed)).unwrap(); + + let mut dist = self.0.lock().unwrap(); + dist.gen_values(&mut drbg); + if dist.biased { + dist.gen_biased_weights(&mut drbg); + } else { + dist.gen_uniform_weights(&mut drbg); + } + dist.gen_tables(); + } +} + +impl InnerWeightedDist { + // Creates a slice containing a random number of random values that, when + // scaled by adding self.min_value, will fall into [min, max]. + fn gen_values(&mut self, rng: &mut R) { + let mut n_values = self.max_value - self.min_value; + + let mut values: Vec = (0..=n_values).collect(); + values.shuffle(rng); + n_values = max(n_values, MIN_VALUES); + n_values = min(n_values, MAX_VALUES); + + let n_values = rng.gen_range(1..=n_values) as usize; + self.values = values[..n_values].to_vec(); + } + + // generates a non-uniform weight list, similar to the scramblesuit + // prob_dist mode. + fn gen_biased_weights(&mut self, rng: &mut R) { + self.weights = vec![0_f64; self.values.len()]; + + let mut cumul_prob: f64 = 0.0; + for i in 0..self.weights.len() { + self.weights[i] = (1.0 - cumul_prob) * rng.gen::(); + cumul_prob += self.weights[i]; + } + } + + // generates a uniform weight list. + fn gen_uniform_weights(&mut self, rng: &mut R) { + self.weights = vec![0_f64; self.values.len()]; + + for i in 0..self.weights.len() { + self.weights[i] = rng.gen(); + } + } + + // Calculates the alias and prob tables use for Vose's alias Method. + // Algorithm taken from http://www.keithschwarz.com/darts-dice-coins/ + fn gen_tables(&mut self) { + let n = self.weights.len(); + let sum: f64 = self.weights.iter().sum(); + + let mut alias = vec![0_usize; n]; + let mut prob = vec![0_f64; n]; + + // multiply each probability by $n$. + let mut scaled: Vec = self.weights.iter().map(|f| f * (n as f64) / sum).collect(); + // if $p$ < 1$ add $i$ to $small$. + let mut small: Vec = scaled + .iter() + .enumerate() + .filter(|(_, f)| **f < 1.0) + .map(|(i, _)| i) + .collect(); + // if $p$ >= 1$ add $i& to $large$. + let mut large: Vec = scaled + .iter() + .enumerate() + .filter(|(_, f)| **f >= 1.0) + .map(|(i, _)| i) + .collect(); + + // While $small$ and $large$ are not empty: ($large$ might be emptied first) + // remove the first element from $small$ and call it $l$. + // remove the first element from $large$ and call it $g$. + // set $prob[l] = p_l$ + // set $alias[l] = g$ + // set $p_g = (p_g+p_l) - 1$ (This is a more numerically stable option) + // if $p_g < 1$ add $g$ to $small$. + // otherwise add $g$ to $large$ as %p_g >= 1$ + while !small.is_empty() && !large.is_empty() { + let l = small.remove(0); + let g = large.remove(0); + + prob[l] = scaled[l]; + alias[l] = g; + + scaled[g] = scaled[g] + scaled[l] - 1.0; + if scaled[g] < 1.0 { + small.push(g); + } else { + large.push(g); + } + } + + // while $large$ is not empty, remove the first element ($g$) and + // set $prob[g] = 1$. + while !large.is_empty() { + prob[large.remove(0)] = 1.0; + } + + // while $small$ is not empty, remove the first element ($l$) and + // set $prob[l] = 1$. + while !small.is_empty() { + prob[small.remove(0)] = 1.0; + } + + self.prob = prob; + self.alias = alias; + } +} + +impl fmt::Display for WeightedDist { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let dist = self.0.lock().unwrap(); + write!(f, "{dist}") + } +} + +impl fmt::Display for InnerWeightedDist { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let mut buf: String = "[ ".into(); + + for (i, v) in self.values.iter().enumerate() { + let p = self.weights[i]; + if p > 0.01 { + buf.push_str(&format!("{v}: {p}, ")); + } + } + write!(f, "]") + } +} + +#[cfg(test)] +mod test { + use super::*; + use crate::test_utils::init_subscriber; + use crate::Result; + + use ptrs::trace; + use tracing::{span_enabled, Level}; + + #[test] + fn weighted_dist_uniformity() -> Result<()> { + init_subscriber(); + let seed = drbg::Seed::new()?; + + let n_trials = 1_000_000; + let mut hist = [0_usize; 1000]; + + let w = WeightedDist::new(seed, 0, 999, true); + + if span_enabled!(Level::TRACE) { + trace!("Table:"); + trace!("{w}"); + let wi = w.0.lock().unwrap(); + let sum: f64 = wi.weights.iter().sum(); + let min_value = wi.min_value; + let values = &wi.values; + + for (i, weight) in wi.weights.iter().enumerate() { + let p = weight / sum; + if p > 0.000001 { + // filter out tiny values + trace!(" [{}]: {p}", min_value + values[i]); + } + } + } + + for _ in 0..n_trials { + let idx: usize = w.sample().try_into().unwrap(); + hist[idx] += 1; + } + + if span_enabled!(Level::TRACE) { + trace!("Generated:"); + for (val, count) in hist.iter().enumerate() { + if *count != 0 { + trace!(" {val}: {:} ({count})", *count as f64 / n_trials as f64); + } + } + } + + Ok(()) + } +} diff --git a/crates/o5/src/common/replay_filter.rs b/crates/o5/src/common/replay_filter.rs new file mode 100644 index 0000000..400484f --- /dev/null +++ b/crates/o5/src/common/replay_filter.rs @@ -0,0 +1,255 @@ +use ptrs::trace; +/// The replayfilter module implements a generic replay detection filter with a +/// caller specifiable time-to-live. It only detects if a given byte sequence +/// has been seen before based on the SipHash-2-4 digest of the sequence. +/// Collisions are treated as positive matches, though the probability of this +/// happening is negligible. +use siphasher::{prelude::*, sip::SipHasher24}; + +use std::collections::{HashMap, VecDeque}; +use std::sync::{Arc, Mutex}; +use std::time::{Duration, Instant}; + +// maxFilterSize is the maximum capacity of a replay filter. This value is +// more as a safeguard to prevent runaway filter growth, and is sized to be +// serveral orders of magnitude greater than the number of connections a busy +// bridge sees in one day, so in practice should never be reached. +const MAX_FILTER_SIZE: usize = 100 * 1024; + +#[derive(Clone, PartialEq)] +struct Entry { + digest: u64, + first_seen: Instant, +} + +// ReplayFilter is a simple filter designed only to detect if a given byte +// sequence has been seen in the recent history. +pub struct ReplayFilter(Arc>); + +impl ReplayFilter { + pub fn new(ttl: Duration) -> Self { + Self(Arc::new(Mutex::new(InnerReplayFilter::new( + ttl, + MAX_FILTER_SIZE, + )))) + } + + // Queries the filter for a given byte sequence, inserts the + // sequence, and returns if it was present before the insertion operation. + pub fn test_and_set(&self, now: Instant, buf: impl AsRef<[u8]>) -> bool { + let mut inner = self.0.lock().unwrap(); + inner.test_and_set(now, buf) + } +} + +struct InnerReplayFilter { + filter: HashMap, + fifo: VecDeque, + + key: [u8; 16], + ttl_limit: Duration, + max_cap: usize, +} + +impl InnerReplayFilter { + fn new(ttl_limit: Duration, max_cap: usize) -> Self { + let mut key = [0_u8; 16]; + getrandom::getrandom(&mut key).unwrap(); + + Self { + filter: HashMap::new(), + fifo: VecDeque::new(), + key, + ttl_limit, + max_cap, + } + } + + fn test_and_set(&mut self, now: Instant, buf: impl AsRef<[u8]>) -> bool { + self.garbage_collect(now); + + let mut hash = SipHasher24::new_with_key(&self.key); + let digest: u64 = { + hash.write(buf.as_ref()); + hash.finish().to_be() + }; + + trace!("checking inner"); + if self.filter.contains_key(&digest) { + return true; + } + + trace!("not found: {digest}... inserting"); + let e = Entry { + digest, + first_seen: now, + }; + + self.fifo.push_front(e.clone()); + self.filter.insert(digest, e); + + trace!("inserted: {}", self.filter.len()); + false + } + + fn garbage_collect(&mut self, now: Instant) { + if self.fifo.is_empty() { + return; + } + + while !self.fifo.is_empty() { + let e = match self.fifo.back() { + Some(e) => e, + None => return, + }; + + trace!( + "{}/{}[/{}] - {:?}", + self.fifo.len(), + self.filter.len(), + self.max_cap, + self.ttl_limit + ); + // If the filter is not full, only purge entries that have exceedded + // the TTL, otherwise purge one entry and test to see if we are + // still over max length. This should not (typically) be possible as + // we garbage collect on insert. + if self.fifo.len() < self.max_cap && self.ttl_limit > Duration::from_millis(0) { + let delta_t = now - e.first_seen; + trace!("{:?} > {:?}", now, e.first_seen); + if now < e.first_seen { + trace!("Invalid time"); + // Aeeeeeee, the system time jumped backwards, potentially by + // a lot. This will eventually self-correct, but "eventually" + // could be a long time. As much as this sucks, jettison the + // entire filter. + self.reset(); + return; + } else if delta_t < self.ttl_limit { + return; + } + } + + trace!("removing entry"); + // remove the entry + _ = self.filter.remove(&e.digest); + _ = self.fifo.pop_back(); + } + } + + fn reset(&mut self) { + trace!("RESETING"); + self.filter = HashMap::new(); + self.fifo = VecDeque::new(); + } +} + +#[cfg(test)] +mod test { + use super::*; + use crate::test_utils::init_subscriber; + use crate::Result; + + #[test] + fn replay_filter_ops() -> Result<()> { + init_subscriber(); + let ttl = Duration::from_secs(10); + + let f = &mut ReplayFilter::new(ttl); + + let buf = b"For a moment, nothing happened. Then, after a second or so, nothing continued to happen."; + let mut now = Instant::now(); + + // test_and_set into empty filter, returns false (not present). + assert!( + !f.test_and_set(now, buf), + "test_and_set (mutex) empty filter returned true" + ); + + // test_and_set into filter containing entry, should return true(present). + assert!( + f.test_and_set(now, buf), + "test_and_set (mutex) populated filter (replayed) returned false" + ); + + let f = &mut InnerReplayFilter::new(ttl, 2); + + // test_and_set into empty filter, returns false (not present). + assert!( + !f.test_and_set(now, buf), + "test_and_set empty filter returned true" + ); + + // test_and_set into filter containing entry, should return true(present). + assert!( + f.test_and_set(now, buf), + "test_and_set populated filter (replayed) returned false" + ); + + // test_and_set with time advanced. + let buf2 = b"We demand rigidly defined areas of doubt and uncertainty!"; + now += ttl; + assert!( + !f.test_and_set(now, buf2), + "test_and_set populated filter, 2nd entry returned true" + ); + assert!( + f.test_and_set(now, buf2), + "test_and_set populated filter, 2nd entry (replayed) returned false" + ); + + // Ensure that the first entry has been removed by compact. + assert!( + !f.test_and_set(now, buf), + "test_and_set populated filter, compact check returned true" + ); + + // Ensure that the filter gets reaped if the clock jumps backwards. + now = Instant::now(); + assert!( + !f.test_and_set(now, buf), + "test_and_set populated filter, backward time jump returned true" + ); + assert_eq!( + f.fifo.len(), + 1, + "filter fifo has a unexpected number of entries: {}", + f.fifo.len() + ); + assert_eq!( + f.filter.len(), + 1, + "filter map has a unexpected number of entries: {}", + f.filter.len() + ); + + // Ensure that the entry is properly added after reaping. + assert!( + f.test_and_set(now, buf), + "test_and_set populated filter, post-backward clock jump (replayed) returned false" + ); + + // Ensure that when the capacity limit is hit entries are evicted + f.test_and_set(now, "message2"); + for i in 0..10 { + assert_eq!( + f.fifo.len(), + 2, + "filter fifo has a unexpected number of entries: {}", + f.fifo.len() + ); + assert_eq!( + f.filter.len(), + 2, + "filter map has a unexpected number of entries: {}", + f.filter.len() + ); + assert!( + !f.test_and_set(now, &format!("message-1{i}")), + "unique message failed insert (returned true)" + ); + } + + Ok(()) + } +} diff --git a/crates/o5/src/common/skip.rs b/crates/o5/src/common/skip.rs new file mode 100644 index 0000000..a2538ea --- /dev/null +++ b/crates/o5/src/common/skip.rs @@ -0,0 +1,64 @@ +use crate::Result; + +use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt}; + +// use std::pin::Pin; +// use std::task::{Context, Poll}; +use std::time::Duration; + +/// copies all data from the reader to a sink. If the reader closes before +/// the timeout due to na error or an EoF that result will be returned. +/// Otherwise if the timeout is reached, the stream will be shutdown +/// and the result of that shutdown will be returned. +/// +/// TODO: determine if it is possible to empty / flush write buffer before +/// shutdown to ensure consistent RST / FIN behavior on shutdown. +pub async fn discard(stream: S, d: Duration) -> Result<()> +where + S: AsyncRead + AsyncWrite + Unpin, +{ + let (mut r, mut w) = tokio::io::split(stream); + let result = tokio::time::timeout(d, async move { + tokio::io::copy(&mut r, &mut tokio::io::sink()).await + }) + .await; + if let Ok(r) = result { + // Error Occurred in coppy or connection hit EoF which means the + // connection should already be closed. + r.map(|_| ()).map_err(|e| e.into()) + } else { + // stream out -- connection may not be closed -- close manually. + w.shutdown().await.map_err(|e| e.into()) + } +} + +#[cfg(test)] +mod test { + use tokio::time::Instant; + + use super::*; + + #[tokio::test] + async fn discard_and_close_after_delay() { + let (mut c, s) = tokio::io::duplex(1024); + let start = Instant::now(); + let d = Duration::from_secs(3); + let expected_end = start + d; + let discard_fut = discard(s, d); + + tokio::spawn(async move { + const MSG: &str = "abcdefghijklmnopqrstuvwxyz"; + loop { + if let Err(e) = c.write(MSG.as_bytes()).await { + assert!(Instant::now() > expected_end); + println!("closed with error {e}"); + break; + } + } + }); + + discard_fut.await.unwrap(); + + assert!(Instant::now() > expected_end); + } +} diff --git a/crates/o5/src/constants.rs b/crates/o5/src/constants.rs new file mode 100644 index 0000000..db8a870 --- /dev/null +++ b/crates/o5/src/constants.rs @@ -0,0 +1,79 @@ +#![allow(unused)] + +use tor_llcrypto::pk::rsa::RSA_ID_LEN; + +use crate::{ + common::{curve25519::REPRESENTATIVE_LENGTH, drbg}, + framing, + handshake::AUTHCODE_LENGTH, +}; + +use std::time::Duration; + +//=========================[Framing/Msgs]=====================================// + +/// Maximum handshake size including padding +pub const MAX_HANDSHAKE_LENGTH: usize = 8192; + +pub const SHA256_SIZE: usize = 32; +pub const MARK_LENGTH: usize = SHA256_SIZE / 2; +pub const MAC_LENGTH: usize = SHA256_SIZE / 2; + +/// Minimum padding allowed in a client handshake message +pub const CLIENT_MIN_PAD_LENGTH: usize = + (SERVER_MIN_HANDSHAKE_LENGTH + INLINE_SEED_FRAME_LENGTH) - CLIENT_MIN_HANDSHAKE_LENGTH; +pub const CLIENT_MAX_PAD_LENGTH: usize = MAX_HANDSHAKE_LENGTH - CLIENT_MIN_HANDSHAKE_LENGTH; +pub const CLIENT_MIN_HANDSHAKE_LENGTH: usize = REPRESENTATIVE_LENGTH + MARK_LENGTH + MAC_LENGTH; + +pub const SERVER_MIN_PAD_LENGTH: usize = 0; +pub const SERVER_MAX_PAD_LENGTH: usize = + MAX_HANDSHAKE_LENGTH - (SERVER_MIN_HANDSHAKE_LENGTH + INLINE_SEED_FRAME_LENGTH); +pub const SERVER_MIN_HANDSHAKE_LENGTH: usize = + REPRESENTATIVE_LENGTH + AUTHCODE_LENGTH + MARK_LENGTH + MAC_LENGTH; + +pub const INLINE_SEED_FRAME_LENGTH: usize = + framing::FRAME_OVERHEAD + MESSAGE_OVERHEAD + SEED_MESSAGE_PAYLOAD_LENGTH; + +pub const MESSAGE_OVERHEAD: usize = 2 + 1; +pub const MAX_MESSAGE_PAYLOAD_LENGTH: usize = framing::MAX_FRAME_PAYLOAD_LENGTH - MESSAGE_OVERHEAD; +pub const MAX_MESSAGE_PADDING_LENGTH: usize = MAX_MESSAGE_PAYLOAD_LENGTH; +pub const SEED_MESSAGE_PAYLOAD_LENGTH: usize = drbg::SEED_LENGTH; +pub const SEED_MESSAGE_LENGTH: usize = + framing::LENGTH_LENGTH + MESSAGE_OVERHEAD + drbg::SEED_LENGTH + MAC_LENGTH; + +pub const CONSUME_READ_SIZE: usize = framing::MAX_SEGMENT_LENGTH * 16; + +//===============================[Proto]======================================// + +pub const TRANSPORT_NAME: &str = "obfs4"; + +pub const NODE_ID_ARG: &str = "node-id"; +pub const PUBLIC_KEY_ARG: &str = "public-key"; +pub const PRIVATE_KEY_ARG: &str = "private-key"; +pub const SEED_ARG: &str = "drbg-seed"; +pub const IAT_ARG: &str = "iat-mode"; +pub const CERT_ARG: &str = "cert"; + +pub const BIAS_CMD_ARG: &str = "obfs4-distBias"; + +pub const REPLAY_TTL: Duration = Duration::from_secs(60); +#[cfg(test)] +pub const CLIENT_HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(5); +#[cfg(test)] +pub const SERVER_HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(5); +#[cfg(not(test))] +pub const CLIENT_HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(60); +#[cfg(not(test))] +pub const SERVER_HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(60); + +pub const MAX_IAT_DELAY: usize = 100; +pub const MAX_CLOSE_DELAY: usize = 60; +pub const MAX_CLOSE_DELAY_BYTES: usize = MAX_HANDSHAKE_LENGTH; + +pub const SEED_LENGTH: usize = drbg::SEED_LENGTH; +pub const HEADER_LENGTH: usize = framing::FRAME_OVERHEAD + framing::MESSAGE_OVERHEAD; + +pub const SESSION_ID_LEN: usize = 8; + +pub const NODE_ID_LENGTH: usize = RSA_ID_LEN; +pub const NODE_PUBKEY_LENGTH: usize = 32; diff --git a/crates/o5/src/error.rs b/crates/o5/src/error.rs new file mode 100644 index 0000000..0f50b3d --- /dev/null +++ b/crates/o5/src/error.rs @@ -0,0 +1,245 @@ +use crate::framing::FrameError; + +use std::array::TryFromSliceError; +use std::string::FromUtf8Error; +use std::{fmt::Display, str::FromStr}; + +use hex::FromHexError; +use sha2::digest::InvalidLength; + +use crate::common::ntor_arti::RelayHandshakeError; + +/// Result type returning [`Error`] or `T` +pub type Result = std::result::Result; + +/// Errors that can occur when using the transports, including wrapped from dependencies. +impl std::error::Error for Error {} +#[derive(Debug)] +pub enum Error { + Bug(tor_error::Bug), + + Other(Box), + IOError(std::io::Error), + EncodeError(Box), + Utf8Error(FromUtf8Error), + RngSourceErr(getrandom::Error), + Crypto(String), + NullTransport, + NotImplemented, + NotSupported, + Cancelled, + HandshakeTimeout, + BadCircHandshakeAuth, + InvalidKDFOutputLength, + + // TODO: do we need to keep this? + CellDecodeErr { + /// What we were trying to parse. + object: &'static str, + /// The error that occurred while parsing it. + err: tor_cell::Error, + }, + HandshakeErr(RelayHandshakeError), + + O5Framing(FrameError), +} + +impl Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match &self { + Error::Bug(_) => write!(f, "Internal error occured (bug)"), + Error::Cancelled => write!(f, "cancelled"), + Error::Other(e) => write!(f, "{}", e), + Error::IOError(e) => write!(f, "{}", e), + Error::EncodeError(e) => write!(f, "{}", e), + Error::Utf8Error(e) => write!(f, "{}", e), + Error::RngSourceErr(e) => write!(f, "{}", e), + Error::Crypto(e) => write!(f, "cryptographic err: {}", e), + Error::NotImplemented => write!(f, "NotImplemented"), + Error::NotSupported => write!(f, "NotSupported"), + Error::NullTransport => write!(f, "NullTransport"), + Error::HandshakeTimeout => write!(f, "handshake timed out"), + Error::BadCircHandshakeAuth => write!(f, "failed authentication for circuit handshake"), + Error::InvalidKDFOutputLength => { + write!(f, "Tried to extract too many bytes from a KDF") + } + Error::CellDecodeErr { object, err } => { + write!(f, "Unable to decode cell {object}: {err}") + } + Error::HandshakeErr(err) => write!(f, "handshake failed or unable to complete: {err}"), + + Error::O5Framing(e) => write!(f, "obfs4 framing error: {e}"), + } + } +} + +unsafe impl Send for Error {} + +impl Error { + pub fn new>>(e: T) -> Self { + Error::Other(e.into()) + } +} + +impl From for std::io::Error { + fn from(e: Error) -> Self { + match e { + Error::IOError(io_err) => io_err, + e => std::io::Error::new(std::io::ErrorKind::Other, format!("{e}")), + } + } +} + +impl FromStr for Error { + type Err = Error; + + fn from_str(s: &str) -> std::result::Result { + Ok(Error::new(s)) + } +} + +impl From for Error { + fn from(e: std::io::Error) -> Self { + Error::IOError(e) + } +} + +impl From> for Error { + fn from(e: Box) -> Self { + Error::IOError(*e) + } +} + +impl From for Error { + fn from(e: FromHexError) -> Self { + Error::EncodeError(Box::new(e)) + } +} + +impl From> for Error { + fn from(e: Box) -> Self { + Error::Other(e) + } +} + +impl From for Error { + fn from(e: String) -> Self { + Error::Other(e.into()) + } +} + +impl From<&str> for Error { + fn from(e: &str) -> Self { + Error::Other(e.into()) + } +} + +impl From for Error { + fn from(e: FromUtf8Error) -> Self { + Error::Utf8Error(e) + } +} + +impl From for Error { + fn from(e: getrandom::Error) -> Self { + Error::RngSourceErr(e) + } +} + +impl From for Error { + fn from(e: TryFromSliceError) -> Self { + Error::Other(Box::new(e)) + } +} + +impl From for Error { + fn from(e: InvalidLength) -> Self { + Error::Other(Box::new(e)) + } +} + +impl From for Error { + fn from(e: FrameError) -> Self { + Error::O5Framing(e) + } +} + +impl From for Error { + fn from(value: RelayHandshakeError) -> Self { + Error::HandshakeErr(value) + } +} + +impl From for Error { + fn from(value: tor_error::Bug) -> Self { + Error::Bug(value) + } +} + +impl From for Error { + fn from(value: tor_cell::Error) -> Self { + Error::CellDecodeErr { + object: "", + err: value, + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_display_other_error() { + let err = Error::new("some other error"); + assert_eq!(format!("{}", err), "some other error"); + } + + #[test] + fn test_display_io_error() { + let err = Error::IOError(std::io::Error::new( + std::io::ErrorKind::Other, + "some io error", + )); + assert_eq!(format!("{}", err), "some io error"); + } + + #[test] + fn test_display_encode_error() { + let err = Error::EncodeError(Box::new(FromHexError::InvalidHexCharacter { + c: 'z', + index: 0, + })); + assert_eq!(format!("{}", err), "Invalid character 'z' at position 0"); + } + + #[test] + fn test_display_null_transport_error() { + let err = Error::NullTransport; + assert_eq!(format!("{}", err), "NullTransport"); + } + + #[test] + fn test_from_io_error() { + let io_err = std::io::Error::new(std::io::ErrorKind::Other, "some io error"); + let err = Error::from(io_err); + assert_eq!(format!("{}", err), "some io error"); + } + + #[test] + fn test_from_encode_error() { + let hex_err = FromHexError::InvalidHexCharacter { c: 'z', index: 0 }; + let err = Error::from(hex_err); + assert_eq!(format!("{}", err), "Invalid character 'z' at position 0"); + } + + #[test] + fn test_from_other_error() { + let other_err = Box::new(std::io::Error::new( + std::io::ErrorKind::Other, + "some other error", + )); + let err = Error::from(other_err); + assert_eq!(format!("{}", err), "some other error"); + } +} diff --git a/crates/o5/src/framing/codecs.rs b/crates/o5/src/framing/codecs.rs new file mode 100644 index 0000000..f37e9c5 --- /dev/null +++ b/crates/o5/src/framing/codecs.rs @@ -0,0 +1,371 @@ +use crate::{ + common::drbg::{self, Drbg, Seed}, + constants::MESSAGE_OVERHEAD, + framing::{FrameError, Messages}, +}; + +use bytes::{Buf, BufMut, BytesMut}; +use crypto_secretbox::{ + aead::{generic_array::GenericArray, Aead, KeyInit}, + XSalsa20Poly1305, +}; +use ptrs::{debug, error, trace}; +use rand::prelude::*; +use tokio_util::codec::{Decoder, Encoder}; + +/// MaximumSegmentLength is the length of the largest possible segment +/// including overhead. +pub(crate) const MAX_SEGMENT_LENGTH: usize = 1500 - (40 + 12); + +/// secret box overhead is fixed length prefix and counter +const SECRET_BOX_OVERHEAD: usize = TAG_SIZE; + +/// FrameOverhead is the length of the framing overhead. +pub(crate) const FRAME_OVERHEAD: usize = LENGTH_LENGTH + SECRET_BOX_OVERHEAD; + +/// MaximumFramePayloadLength is the length of the maximum allowed payload +/// per frame. +pub(crate) const MAX_FRAME_PAYLOAD_LENGTH: usize = MAX_SEGMENT_LENGTH - FRAME_OVERHEAD; + +pub(crate) const MAX_FRAME_LENGTH: usize = MAX_SEGMENT_LENGTH - LENGTH_LENGTH; +pub(crate) const MIN_FRAME_LENGTH: usize = FRAME_OVERHEAD - LENGTH_LENGTH; + +pub(crate) const NONCE_PREFIX_LENGTH: usize = 16; +pub(crate) const NONCE_COUNTER_LENGTH: usize = 8; +pub(crate) const NONCE_LENGTH: usize = NONCE_PREFIX_LENGTH + NONCE_COUNTER_LENGTH; + +pub(crate) const LENGTH_LENGTH: usize = 2; + +/// KEY_LENGTH is the length of the Encoder/Decoder secret key. +pub(crate) const KEY_LENGTH: usize = 32; + +pub(crate) const TAG_SIZE: usize = 16; + +pub(crate) const KEY_MATERIAL_LENGTH: usize = KEY_LENGTH + NONCE_PREFIX_LENGTH + drbg::SEED_LENGTH; + +// TODO: make this (Codec) threadsafe +pub struct EncryptingCodec { + // key: [u8; KEY_LENGTH], + encoder: EncryptingEncoder, + decoder: EncryptingDecoder, + + pub(crate) handshake_complete: bool, +} + +impl EncryptingCodec { + pub fn new( + encoder_key_material: [u8; KEY_MATERIAL_LENGTH], + decoder_key_material: [u8; KEY_MATERIAL_LENGTH], + ) -> Self { + // let mut key: [u8; KEY_LENGTH] = key_material[..KEY_LENGTH].try_into().unwrap(); + Self { + // key, + encoder: EncryptingEncoder::new(encoder_key_material), + decoder: EncryptingDecoder::new(decoder_key_material), + handshake_complete: false, + } + } + + pub(crate) fn handshake_complete(&mut self) { + self.handshake_complete = true; + } +} + +///Decoder is a frame decoder instance. +struct EncryptingDecoder { + key: [u8; KEY_LENGTH], + nonce: NonceBox, + drbg: Drbg, + + next_nonce: [u8; NONCE_LENGTH], + next_length: u16, + next_length_invalid: bool, +} + +impl EncryptingDecoder { + // Creates a new Decoder instance. It must be supplied a slice + // containing exactly KeyLength bytes of keying material. + fn new(key_material: [u8; KEY_MATERIAL_LENGTH]) -> Self { + trace!("new decoder key_material: {}", hex::encode(key_material)); + let key: [u8; KEY_LENGTH] = key_material[..KEY_LENGTH].try_into().unwrap(); + let nonce = NonceBox::new(&key_material[KEY_LENGTH..(KEY_LENGTH + NONCE_PREFIX_LENGTH)]); + let seed = Seed::try_from(&key_material[(KEY_LENGTH + NONCE_PREFIX_LENGTH)..]).unwrap(); + let d = Drbg::new(Some(seed)).unwrap(); + + Self { + key, + drbg: d, + nonce, + + next_nonce: [0_u8; NONCE_LENGTH], + next_length: 0, + next_length_invalid: false, + } + } +} + +impl Decoder for EncryptingCodec { + type Item = Messages; + type Error = FrameError; + + // Decode decodes a stream of data and returns the length if any. ErrAgain is + // a temporary failure, all other errors MUST be treated as fatal and the + // session aborted. + fn decode( + &mut self, + src: &mut BytesMut, + ) -> std::result::Result, Self::Error> { + trace!( + "decoding src:{}B {} {}", + src.remaining(), + self.decoder.next_length, + self.decoder.next_length_invalid + ); + // A length of 0 indicates that we do not know the expected size of + // the next frame. we use this to store the length of a packet when we + // receive the length at the beginning, but not the whole packet, since + // future reads may not have the who packet (including length) available + if self.decoder.next_length == 0 { + // Attempt to pull out the next frame length + if LENGTH_LENGTH > src.remaining() { + return Ok(None); + } + + // derive the nonce that the peer would have used + self.decoder.next_nonce = self.decoder.nonce.next()?; + + // Remove the field length from the buffer + // let mut len_buf: [u8; LENGTH_LENGTH] = src[..LENGTH_LENGTH].try_into().unwrap(); + let mut length = src.get_u16(); + + // De-obfuscate the length field + let length_mask = self.decoder.drbg.length_mask(); + trace!( + "decoding {length:04x}^{length_mask:04x} {:04x}B", + length ^ length_mask + ); + length ^= length_mask; + if MAX_FRAME_LENGTH < length as usize || MIN_FRAME_LENGTH > length as usize { + // Per "Plaintext Recovery Attacks Against SSH" by + // Martin R. Albrecht, Kenneth G. Paterson and Gaven J. Watson, + // there are a class of attacks againt protocols that use similar + // sorts of framing schemes. + // + // While obfs4 should not allow plaintext recovery (CBC mode is + // not used), attempt to mitigate out of bound frame length errors + // by pretending that the length was a random valid range as pe + // the countermeasure suggested by Denis Bider in section 6 of the + // paper. + + let invalid_length = length; + self.decoder.next_length_invalid = true; + + length = rand::thread_rng().gen::() + % (MAX_FRAME_LENGTH - MIN_FRAME_LENGTH) as u16 + + MIN_FRAME_LENGTH as u16; + error!( + "invalid length {invalid_length} {length} {}", + self.decoder.next_length_invalid + ); + } + + self.decoder.next_length = length; + } + + let next_len = self.decoder.next_length as usize; + + if next_len > src.len() { + // The full string has not yet arrived. + // + // We reserve more space in the buffer. This is not strictly + // necessary, but is a good idea performance-wise. + if !self.decoder.next_length_invalid { + src.reserve(next_len - src.len()); + } + + trace!( + "next_len > src.len --> reading more {} {}", + self.decoder.next_length, + self.decoder.next_length_invalid + ); + + // We inform the Framed that we need more bytes to form the next + // frame. + return Ok(None); + } + + // Use advance to modify src such that it no longer contains this frame. + let data = src.get(..next_len).unwrap().to_vec(); + + // Unseal the frame + let key = GenericArray::from_slice(&self.decoder.key); + let cipher = XSalsa20Poly1305::new(key); + let nonce = GenericArray::from_slice(&self.decoder.next_nonce); // unique per message + + let res = cipher.decrypt(nonce, data.as_ref()); + if res.is_err() { + let e = res.unwrap_err(); + trace!("failed to decrypt result: {e}"); + return Err(e.into()); + } + let plaintext = res?; + if plaintext.len() < MESSAGE_OVERHEAD { + return Err(FrameError::InvalidMessage); + } + + // Clean up and prepare for the next frame + // + // we read a whole frame, we no longer know the size of the next pkt + self.decoder.next_length = 0; + src.advance(next_len); + + debug!("decoding {next_len}B src:{}B", src.remaining()); + match Messages::try_parse(&mut BytesMut::from(plaintext.as_slice())) { + Ok(Messages::Padding(_)) => Ok(None), + Ok(m) => Ok(Some(m)), + Err(FrameError::UnknownMessageType(_)) => Ok(None), + Err(e) => Err(e), + } + } +} + +/// Encoder is a frame encoder instance. +struct EncryptingEncoder { + key: [u8; KEY_LENGTH], + nonce: NonceBox, + drbg: Drbg, +} + +impl EncryptingEncoder { + /// Creates a new Encoder instance. It must be supplied a slice + /// containing exactly KeyLength bytes of keying material + fn new(key_material: [u8; KEY_MATERIAL_LENGTH]) -> Self { + trace!("new encoder key_material: {}", hex::encode(key_material)); + let key: [u8; KEY_LENGTH] = key_material[..KEY_LENGTH].try_into().unwrap(); + let nonce = NonceBox::new(&key_material[KEY_LENGTH..(KEY_LENGTH + NONCE_PREFIX_LENGTH)]); + let seed = Seed::try_from(&key_material[(KEY_LENGTH + NONCE_PREFIX_LENGTH)..]).unwrap(); + let d = Drbg::new(Some(seed)).unwrap(); + + Self { + key, + nonce, + drbg: d, + } + } +} + +impl Encoder for EncryptingCodec { + type Error = FrameError; + + /// Encode encodes a single frame worth of payload and returns. Plaintext + /// should either be a handshake message OR a buffer containing one or more + /// [`Message`]s already properly marshalled. The proided plaintext can + /// be no longer than [`MAX_FRAME_PAYLOAD_LENGTH`]. + /// + /// [`InvalidPayloadLength`] is recoverable, all other errors MUST be + /// treated as fatal and the session aborted. + fn encode(&mut self, plaintext: T, dst: &mut BytesMut) -> std::result::Result<(), Self::Error> { + trace!( + "encoding {}/{MAX_FRAME_PAYLOAD_LENGTH}", + plaintext.remaining() + ); + + // Don't send a frame if it is longer than the other end will accept. + if plaintext.remaining() > MAX_FRAME_PAYLOAD_LENGTH { + return Err(FrameError::InvalidPayloadLength(plaintext.remaining())); + } + + let mut plaintext_frame = BytesMut::new(); + + plaintext_frame.put(plaintext); + + // Generate a new nonce + let nonce_bytes = self.encoder.nonce.next()?; + + // Encrypt and MAC payload + let key = GenericArray::from_slice(&self.encoder.key); + let cipher = XSalsa20Poly1305::new(key); + let nonce = GenericArray::from_slice(&nonce_bytes); // unique per message + + let ciphertext = cipher.encrypt(nonce, plaintext_frame.as_ref())?; + + // Obfuscate the length + let mut length = ciphertext.len() as u16; + let length_mask: u16 = self.encoder.drbg.length_mask(); + debug!( + "encoding➡️ {length}B, {length:04x}^{length_mask:04x} {:04x}", + length ^ length_mask + ); + length ^= length_mask; + + trace!( + "prng_ciphertext: {}{}", + hex::encode(length.to_be_bytes()), + hex::encode(&ciphertext) + ); + + // Write the length and payload to the buffer. + dst.extend_from_slice(&length.to_be_bytes()[..]); + dst.extend_from_slice(&ciphertext); + Ok(()) + } +} + +/// internal nonce management for NaCl secret boxes +pub(crate) struct NonceBox { + prefix: [u8; NONCE_PREFIX_LENGTH], + counter: u64, +} + +impl NonceBox { + pub fn new(prefix: impl AsRef<[u8]>) -> Self { + assert!( + prefix.as_ref().len() >= NONCE_PREFIX_LENGTH, + "prefix too short: {} < {NONCE_PREFIX_LENGTH}", + prefix.as_ref().len() + ); + Self { + prefix: prefix.as_ref()[..NONCE_PREFIX_LENGTH].try_into().unwrap(), + counter: 1, + } + } + + pub fn next(&mut self) -> std::result::Result<[u8; NONCE_LENGTH], FrameError> { + // The security guarantee of Poly1305 is broken if a nonce is ever reused + // for a given key. Detect this by checking for counter wraparound since + // we start each counter at 1. If it ever happens that more than 2^64 - 1 + // frames are transmitted over a given connection, support for rekeying + // will be neccecary, but that's unlikely to happen. + + if self.counter == u64::MAX { + return Err(FrameError::NonceCounterWrapped); + } + let mut nonce = self.prefix.clone().to_vec(); + nonce.append(&mut self.counter.to_be_bytes().to_vec()); + + let nonce_l: [u8; NONCE_LENGTH] = nonce[..].try_into().unwrap(); + + trace!("fresh nonce: {}", hex::encode(nonce_l)); + self.inc(); + Ok(nonce_l) + } + + fn inc(&mut self) { + self.counter += 1; + } +} + +#[cfg(test)] +mod testing { + use super::*; + use crate::Result; + + #[test] + fn nonce_wrap() -> Result<()> { + let mut nb = NonceBox::new([0_u8; NONCE_PREFIX_LENGTH]); + nb.counter = u64::MAX; + + assert_eq!(nb.next().unwrap_err(), FrameError::NonceCounterWrapped); + Ok(()) + } +} diff --git a/crates/o5/src/framing/generic_test.rs b/crates/o5/src/framing/generic_test.rs new file mode 100644 index 0000000..2471715 --- /dev/null +++ b/crates/o5/src/framing/generic_test.rs @@ -0,0 +1,143 @@ +/// testing out tokio_util::codec for building transports. +/// +/// useful links: +/// - https://dev.to/jtenner/creating-a-tokio-codec-1f0l +/// - example telnet implementation using codecs +/// - https://github.com/jtenner/telnet_codec +/// +/// - https://docs.rs/tokio-util/latest/tokio_util/codec/index.html +/// - tokio_util codec docs +/// +use crate::Result; + +use bytes::{Buf, BytesMut}; +use futures::{SinkExt, StreamExt}; + +use tokio_util::codec::{Decoder, Encoder}; + +const MAX: usize = 8 * 1024 * 1024; + +struct O5Codec {} + +impl O5Codec { + fn new() -> Self { + Self {} + } +} + +impl Decoder for O5Codec { + type Item = String; + type Error = std::io::Error; + + fn decode( + &mut self, + src: &mut BytesMut, + ) -> std::result::Result, Self::Error> { + if src.len() < 4 { + // Not enough data to read length marker. + return Ok(None); + } + + // Read length marker. + let mut length_bytes = [0u8; 4]; + length_bytes.copy_from_slice(&src[..4]); + let length = u32::from_le_bytes(length_bytes) as usize; + + // Check that the length is not too large to avoid a denial of + // service attack where the server runs out of memory. + if length > MAX { + return Err(std::io::Error::new( + std::io::ErrorKind::InvalidData, + format!("Frame of length {} is too large.", length), + )); + } + + if src.len() < 4 + length { + // The full string has not yet arrived. + // + // We reserve more space in the buffer. This is not strictly + // necessary, but is a good idea performance-wise. + src.reserve(4 + length - src.len()); + + // We inform the Framed that we need more bytes to form the next + // frame. + return Ok(None); + } + + // Use advance to modify src such that it no longer contains + // this frame. + let data = src[4..4 + length].to_vec(); + src.advance(4 + length); + + // Convert the data to a string, or fail if it is not valid utf-8. + match String::from_utf8(data) { + Ok(string) => Ok(Some(string)), + Err(utf8_error) => Err(std::io::Error::new( + std::io::ErrorKind::InvalidData, + utf8_error.utf8_error(), + )), + } + } +} + +impl Encoder for O5Codec { + type Error = std::io::Error; + + fn encode(&mut self, item: String, dst: &mut BytesMut) -> std::result::Result<(), Self::Error> { + // Don't send a string if it is longer than the other end will + // accept. + if item.len() > MAX { + return Err(std::io::Error::new( + std::io::ErrorKind::InvalidData, + format!("Frame of length {} is too large.", item.len()), + )); + } + + // Convert the length into a byte array. + // The cast to u32 cannot overflow due to the length check above. + let len_slice = u32::to_le_bytes(item.len() as u32); + + // Reserve space in the buffer. + dst.reserve(4 + item.len()); + + // Write the length and string to the buffer. + dst.extend_from_slice(&len_slice); + dst.extend_from_slice(item.as_bytes()); + Ok(()) + } +} + +#[tokio::test] +async fn framing_flow() -> Result<()> { + let (c, s) = tokio::io::duplex(16 * 1024); + + tokio::spawn(async move { + let codec = O5Codec::new(); + + let (mut sink, mut input) = codec.framed(s).split(); + + while let Some(Ok(event)) = input.next().await { + // println!("Event {:?}", event); + sink.send(event).await.expect("server response failed"); + } + }); + + let message = "Hello there"; + let client_codec = O5Codec::new(); + let (mut c_sink, mut c_stream) = client_codec.framed(c).split(); + + c_sink + .send(message.into()) + .await + .expect("client send failed"); + + let m: String = c_stream + .next() + .await + .expect("you were supposed to call me back!") + .expect("an error occured when you called back"); + + assert_eq!(m, message); + + Ok(()) +} diff --git a/crates/o5/src/framing/handshake.rs b/crates/o5/src/framing/handshake.rs new file mode 100644 index 0000000..fdab8fd --- /dev/null +++ b/crates/o5/src/framing/handshake.rs @@ -0,0 +1,176 @@ +use crate::{ + common::{ + curve25519::{PublicKey, PublicRepresentative}, + HmacSha256, + }, + constants::*, + handshake::{get_epoch_hour, make_hs_pad, Authcode, AUTHCODE_LENGTH}, + Result, +}; + +use bytes::BufMut; +use hmac::Mac; +use ptrs::trace; +use rand::Rng; + +// -----------------------------[ Server ]----------------------------- + +pub struct ServerHandshakeMessage { + server_auth: [u8; AUTHCODE_LENGTH], + pad_len: usize, + repres: PublicRepresentative, + pubkey: Option, + epoch_hour: String, +} + +impl ServerHandshakeMessage { + pub fn new( + repres: PublicRepresentative, + server_auth: [u8; AUTHCODE_LENGTH], + epoch_hr: String, + ) -> Self { + Self { + server_auth, + pad_len: rand::thread_rng().gen_range(SERVER_MIN_PAD_LENGTH..SERVER_MAX_PAD_LENGTH), + repres, + pubkey: None, + epoch_hour: epoch_hr, + } + } + + pub fn server_pubkey(&mut self) -> PublicKey { + match self.pubkey { + Some(pk) => pk, + None => { + let pk = PublicKey::from(&self.repres); + self.pubkey = Some(pk); + pk + } + } + } + + pub fn server_auth(self) -> Authcode { + self.server_auth + } + + pub fn marshall(&mut self, buf: &mut impl BufMut, mut h: HmacSha256) -> Result<()> { + trace!("serializing server handshake"); + + h.reset(); + h.update(self.repres.as_bytes().as_ref()); + let mark: &[u8] = &h.finalize_reset().into_bytes()[..MARK_LENGTH]; + + // The server handshake is Y | AUTH | P_S | M_S | MAC(Y | AUTH | P_S | M_S | E) where: + // * Y is the server's ephemeral Curve25519 public key representative. + // * AUTH is the ntor handshake AUTH value. + // * P_S is [serverMinPadLength,serverMaxPadLength] bytes of random padding. + // * M_S is HMAC-SHA256-128(serverIdentity | NodeID, Y) + // * MAC is HMAC-SHA256-128(serverIdentity | NodeID, Y .... E) + // * E is the string representation of the number of hours since the UNIX + // epoch. + + // Generate the padding + let pad: &[u8] = &make_hs_pad(self.pad_len)?; + + // Write Y, AUTH, P_S, M_S. + let mut params = vec![]; + params.extend_from_slice(self.repres.as_bytes()); + params.extend_from_slice(&self.server_auth); + params.extend_from_slice(pad); + params.extend_from_slice(mark); + buf.put(params.as_slice()); + + // Calculate and write MAC + h.update(¶ms); + h.update(self.epoch_hour.as_bytes()); + buf.put(&h.finalize_reset().into_bytes()[..MAC_LENGTH]); + + Ok(()) + } +} + +// -----------------------------[ Client ]----------------------------- + +/// Preliminary message sent in an obfs4 handshake attempting to open a +/// connection from a client to a potential server. +pub struct ClientHandshakeMessage { + pub(crate) pad_len: usize, + pub(crate) repres: PublicRepresentative, + pub(crate) pubkey: Option, + + // only used when parsing (i.e. on the server side) + pub(crate) epoch_hour: String, +} + +impl ClientHandshakeMessage { + pub fn new(repres: PublicRepresentative, pad_len: usize, epoch_hour: String) -> Self { + Self { + pad_len, + repres, + pubkey: None, + + // only used when parsing (i.e. on the server side) + epoch_hour, + } + } + + pub fn get_public(&mut self) -> PublicKey { + trace!("repr: {}", hex::encode(self.repres)); + match self.pubkey { + Some(pk) => pk, + None => { + let pk = PublicKey::from(&self.repres); + self.pubkey = Some(pk); + pk + } + } + } + + #[allow(unused)] + /// Return the elligator2 representative of the public key value. + pub fn get_representative(&self) -> PublicRepresentative { + self.repres + } + + /// return the epoch hour used in the ntor handshake. + pub fn get_epoch_hr(&self) -> String { + self.epoch_hour.clone() + } + + pub fn marshall(&mut self, buf: &mut impl BufMut, mut h: HmacSha256) -> Result<()> { + trace!("serializing client handshake"); + + h.reset(); // disambiguate reset() implementations Mac v digest + h.update(self.repres.as_bytes().as_ref()); + let mark: &[u8] = &h.finalize_reset().into_bytes()[..MARK_LENGTH]; + + // The client handshake is X | P_C | M_C | MAC(X | P_C | M_C | E) where: + // * X is the client's ephemeral Curve25519 public key representative. + // * P_C is [clientMinPadLength,clientMaxPadLength] bytes of random padding. + // * M_C is HMAC-SHA256-128(serverIdentity | NodeID, X) + // * MAC is HMAC-SHA256-128(serverIdentity | NodeID, X .... E) + // * E is the string representation of the number of hours since the UNIX + // epoch. + + // Generate the padding + let pad = make_hs_pad(self.pad_len)?; + + // Write X, P_C, M_C + let mut params = vec![]; + params.extend_from_slice(self.repres.as_bytes()); + params.extend_from_slice(&pad); + params.extend_from_slice(mark); + buf.put(params.as_slice()); + + // Calculate and write MAC + h.update(¶ms); + self.epoch_hour = format!("{}", get_epoch_hour()); + h.update(self.epoch_hour.as_bytes()); + let mac = &h.finalize_reset().into_bytes()[..MARK_LENGTH]; + buf.put(mac); + + trace!("mark: {}, mac: {}", hex::encode(mark), hex::encode(mac)); + + Ok(()) + } +} diff --git a/crates/o5/src/framing/messages_base.rs b/crates/o5/src/framing/messages_base.rs new file mode 100644 index 0000000..2a8eed6 --- /dev/null +++ b/crates/o5/src/framing/messages_base.rs @@ -0,0 +1,75 @@ +use crate::framing::{self, FrameError}; + +// TODO: drbg for size sampling +//common::drbg, +// +// use futures::sink::{Sink, SinkExt}; + +use tokio_util::bytes::{Buf, BufMut}; + +use ptrs::trace; + +pub(crate) const MESSAGE_OVERHEAD: usize = 2 + 1; +pub(crate) const MAX_MESSAGE_PAYLOAD_LENGTH: usize = + framing::MAX_FRAME_PAYLOAD_LENGTH - MESSAGE_OVERHEAD; +// pub(crate) const MAX_MESSAGE_PADDING_LENGTH: usize = MAX_MESSAGE_PAYLOAD_LENGTH; + +pub type MessageType = u8; +pub trait Message { + type Output; + fn as_pt(&self) -> MessageType; + + fn marshall(&self, dst: &mut T) -> Result<(), FrameError>; + + fn try_parse(buf: &mut T) -> Result; +} + +/// Frames are: +/// ```txt +/// +----- +/// | type u8; // Message Type +/// M1 | length u16 // Message Length (Big Endian). +/// | payload [u8; length]; // Message Data +/// +----- +/// ... // (optional) more messages M2, M3 ... +/// +----- +/// | type \x00 // minimum padding is 3 bytes (type=\x00 + u16 pad_len=\x00\x00) +/// PAD| pad_len u16 +/// | padding [0u8; pad_len]; +/// +----- +/// ``` +/// +/// Frames must always be composed of COMPLETE mesages, i.e. a message should +/// never be split across multiple frames. +pub fn build_and_marshall( + dst: &mut T, + pt: MessageType, + data: impl AsRef<[u8]>, + pad_len: usize, +) -> Result<(), FrameError> { + // is the provided pad_len too long? + if pad_len > u16::MAX as usize { + Err(FrameError::InvalidPayloadLength(pad_len))? + } + + // is the provided data a reasonable size? + let buf = data.as_ref(); + let total_size = buf.len() + pad_len; + trace!( + "building: total size = {}+{}={} / {MAX_MESSAGE_PAYLOAD_LENGTH}", + buf.len(), + pad_len, + total_size, + ); + if total_size >= MAX_MESSAGE_PAYLOAD_LENGTH { + Err(FrameError::InvalidPayloadLength(total_size))? + } + + dst.put_u8(pt); + dst.put_u16(buf.len() as u16); + dst.put(buf); + if pad_len != 0 { + dst.put_bytes(0_u8, pad_len); + } + Ok(()) +} diff --git a/crates/o5/src/framing/messages_v1/crypto.rs b/crates/o5/src/framing/messages_v1/crypto.rs new file mode 100644 index 0000000..4f2e8f3 --- /dev/null +++ b/crates/o5/src/framing/messages_v1/crypto.rs @@ -0,0 +1,152 @@ +use super::MessageTypes; +use crate::framing::{FrameError, Message, MessageType}; + +#[derive(PartialEq, Debug)] +pub enum CryptoExtension { + Kyber, +} + +#[allow(unused)] +impl CryptoExtension { + pub(crate) fn get_offer() -> impl Message { + KyberOfferMessage {} + } + + pub(crate) fn create_accept() -> impl Message { + KyberAcceptMessage {} + } +} + +#[derive(PartialEq, Debug)] +struct KyberOfferMessage {} + +impl Message for KyberOfferMessage { + type Output = (); + fn as_pt(&self) -> MessageType { + MessageTypes::CryptoOffer.into() + } + + fn marshall(&self, _dst: &mut T) -> Result<(), FrameError> { + Ok(()) + } + + fn try_parse(_buf: &mut T) -> Result { + Ok(()) + } +} + +#[derive(PartialEq, Debug)] +struct KyberAcceptMessage {} + +impl Message for KyberAcceptMessage { + type Output = (); + fn as_pt(&self) -> MessageType { + MessageTypes::CryptoAccept.into() + } + + fn marshall(&self, _dst: &mut T) -> Result<(), FrameError> { + Ok(()) + } + + fn try_parse(_buf: &mut T) -> Result { + Ok(()) + } +} + +#[cfg(test)] +#[allow(unused)] +mod tests { + use pqc_kyber::*; + + use crate::common::curve25519::{PublicKey, Representable}; + use crate::handshake::O5NtorSecretKey; + + type Result = std::result::Result; + + #[derive(Debug)] + enum Error { + PQCError(pqc_kyber::KyberError), + Other(Box), + } + + impl From for Error { + fn from(e: pqc_kyber::KyberError) -> Self { + Error::PQCError(e) + } + } + + struct Kyber1024XPublicKey { + pub kyber1024: pqc_kyber::PublicKey, + pub x25519: PublicKey, + } + + impl From<&Kyber1024XIdentityKeys> for Kyber1024XPublicKey { + fn from(value: &Kyber1024XIdentityKeys) -> Self { + Kyber1024XPublicKey { + x25519: value.x25519.pk.pk, + kyber1024: value.kyber1024.public, + } + } + } + + struct Kyber1024XIdentityKeys { + pub kyber1024: pqc_kyber::Keypair, + pub x25519: O5NtorSecretKey, + } + + impl Kyber1024XIdentityKeys { + fn new() -> Self { + let mut rng = rand::thread_rng(); + + Kyber1024XIdentityKeys { + x25519: O5NtorSecretKey::getrandom(), + kyber1024: pqc_kyber::keypair(&mut rng).expect("kyber1024 key generation failed"), + } + } + + fn from_random(rng: &mut R) -> Self { + Kyber1024XIdentityKeys { + x25519: O5NtorSecretKey::getrandom(), + kyber1024: pqc_kyber::keypair(rng).expect("kyber1024 key generation failed"), + } + } + + fn from_x25519(keys: O5NtorSecretKey, rng: &mut R) -> Self { + Kyber1024XIdentityKeys { + x25519: keys, + kyber1024: pqc_kyber::keypair(rng).expect("kyber1024 key generation failed"), + } + } + } + + #[test] + fn kyber_handshake() -> Result<()> { + let mut rng = rand::thread_rng(); + + // Generate Keypair + let alice_secret = Representable::ephemeral_from_rng(&mut rng); + let alice_public = PublicKey::from(&alice_secret); + let keys_alice = keypair(&mut rng)?; + // alice -> bob public keys + let mut kyber1024x_pubkey = alice_public.as_bytes().to_vec(); + kyber1024x_pubkey.extend_from_slice(&keys_alice.public); + + assert_eq!(kyber1024x_pubkey.len(), 1600); + + let bob_secret = Representable::ephemeral_from_rng(&mut rng); + let bob_public = PublicKey::from(&bob_secret); + + // Bob encapsulates a shared secret using Alice's public key + let (ciphertext, shared_secret_bob) = encapsulate(&keys_alice.public, &mut rng)?; + let bob_shared_secret = bob_secret.diffie_hellman(&alice_public); + + // // Alice decapsulates a shared secret using the ciphertext sent by Bob + let shared_secret_alice = decapsulate(&ciphertext, &keys_alice.secret)?; + let alice_shared_secret = alice_secret.diffie_hellman(&bob_public); + + assert_eq!(alice_shared_secret.as_bytes(), bob_shared_secret.as_bytes()); + assert_eq!(shared_secret_bob, shared_secret_alice); + + Ok(()) + } +} diff --git a/crates/o5/src/framing/messages_v1/mod.rs b/crates/o5/src/framing/messages_v1/mod.rs new file mode 100644 index 0000000..729dd53 --- /dev/null +++ b/crates/o5/src/framing/messages_v1/mod.rs @@ -0,0 +1,283 @@ +//! Version 1 of the Protocol Messagess to be included in constructed frames. +//! +//! ## Compatability concerns: +//! +//! Server - when operating as a server we may want to support clients using v0 +//! as well as clients using v1. In order to accomplish this the server can +//! look for the presence of the [`ClientParams`] message. If it is included as +//! a part of the clients handshake we can affirmatively assign protocol message +//! set v1 to the clients session. If we complete the handshake without +//! receiving a [`ClientParams`] messsage then we default to v0 (if the server +//! enables support). +//! +//! Client - When operating as a client we want to support the option to connect +//! with either v0 or v1 servers. when running as a v1 client the server will +//! ignore the unknown frames including [`ClientParams`] and [`CryptoOffer`]. +//! This means that the `SevrerHandshake` will not include [`ServerParams`] or +//! [`CryptoAccept`] frames which indicates to a v1 client that it is speaking +//! with a server unwilling or incapable of speaking v1. This should allow +//! cross compatibility. + +mod crypto; +use crypto::CryptoExtension; + +use crate::{ + constants::*, + framing::{FrameError, MESSAGE_OVERHEAD}, +}; + +use tokio_util::bytes::{Buf, BufMut}; +use tracing::trace; + +#[derive(Debug, PartialEq)] +pub enum MessageTypes { + Payload, + PrngSeed, + Padding, + HeartbeatPing, + HeartbeatPong, + + ClientParams, + ServerParams, + CryptoOffer, + CryptoAccept, + + HandshakeEnd, +} + +impl MessageTypes { + // Steady state message types (and required backwards compatibility messages) + const PAYLOAD: u8 = 0x00; + const PRNG_SEED: u8 = 0x01; + const PADDING: u8 = 0x02; + const HEARTBEAT_PING: u8 = 0x03; + const HEARTBEAT_PONG: u8 = 0x04; + + // Handshake messages + const CLIENT_PARAMS: u8 = 0x10; + const SERVER_PARAMS: u8 = 0x11; + const CRYPTO_OFFER: u8 = 0x12; + const CRYPTO_ACCEPT: u8 = 0x13; + //... + const HANDSHAKE_END: u8 = 0x1f; +} + +impl From for u8 { + fn from(value: MessageTypes) -> Self { + match value { + MessageTypes::Payload => MessageTypes::PAYLOAD, + MessageTypes::PrngSeed => MessageTypes::PRNG_SEED, + MessageTypes::Padding => MessageTypes::PADDING, + MessageTypes::HeartbeatPing => MessageTypes::HEARTBEAT_PING, + MessageTypes::HeartbeatPong => MessageTypes::HEARTBEAT_PONG, + MessageTypes::ClientParams => MessageTypes::CLIENT_PARAMS, + MessageTypes::ServerParams => MessageTypes::SERVER_PARAMS, + MessageTypes::CryptoOffer => MessageTypes::CRYPTO_OFFER, + MessageTypes::CryptoAccept => MessageTypes::CRYPTO_ACCEPT, + MessageTypes::HandshakeEnd => MessageTypes::HANDSHAKE_END, + } + } +} + +impl TryFrom for MessageTypes { + type Error = FrameError; + fn try_from(value: u8) -> Result { + match value { + MessageTypes::PAYLOAD => Ok(MessageTypes::Payload), + MessageTypes::PRNG_SEED => Ok(MessageTypes::PrngSeed), + _ => Err(FrameError::UnknownMessageType(value)), + } + } +} + +#[derive(Debug, PartialEq)] +pub enum Messages { + Payload(Vec), + PrngSeed([u8; SEED_LENGTH]), + Padding(u16), + HeartbeatPing, + HeartbeatPong, + + ClientParams, + ServerParams, + CryptoOffer(CryptoExtension), + CryptoAccept(CryptoExtension), + + HandshakeEnd, +} + +impl Messages { + pub(crate) fn as_pt(&self) -> MessageTypes { + match self { + Messages::Payload(_) => MessageTypes::Payload, + Messages::PrngSeed(_) => MessageTypes::PrngSeed, + Messages::Padding(_) => MessageTypes::Padding, + Messages::HeartbeatPing => MessageTypes::HeartbeatPing, + Messages::HeartbeatPong => MessageTypes::HeartbeatPong, + Messages::ClientParams => MessageTypes::ClientParams, + Messages::ServerParams => MessageTypes::ServerParams, + Messages::CryptoOffer(_) => MessageTypes::CryptoOffer, + Messages::CryptoAccept(_) => MessageTypes::CryptoAccept, + Messages::HandshakeEnd => MessageTypes::HandshakeEnd, + } + } + + pub(crate) fn marshall(&self, dst: &mut T) -> Result<(), FrameError> { + dst.put_u8(self.as_pt().into()); + match self { + Messages::Payload(buf) => { + dst.put_u16(buf.len() as u16); + dst.put(&buf[..]); + } + Messages::PrngSeed(buf) => { + dst.put_u16(buf.len() as u16); + dst.put(&buf[..]); + } + Messages::Padding(pad_len) => { + dst.put_u16(*pad_len); + if *pad_len > 0 { + let buf = vec![0_u8; *pad_len as usize]; + dst.put(&buf[..]); + } + } + + _ => { + dst.put_u16(0_u16); + } + } + Ok(()) + } + + pub(crate) fn try_parse(buf: &mut T) -> Result { + if buf.remaining() < MESSAGE_OVERHEAD { + Err(FrameError::InvalidMessage)? + } + let pt: MessageTypes = buf.get_u8().try_into()?; + let length = buf.get_u16() as usize; + + match pt { + MessageTypes::Payload => { + let mut dst = vec![]; + dst.put(buf.take(length)); + trace!("{}B remainng", buf.remaining()); + assert_eq!(buf.remaining(), Self::drain_padding(buf)); + Ok(Messages::Payload(dst)) + } + + MessageTypes::PrngSeed => { + let mut seed = [0_u8; 24]; + buf.copy_to_slice(&mut seed[..]); + assert_eq!(buf.remaining(), Self::drain_padding(buf)); + Ok(Messages::PrngSeed(seed)) + } + + MessageTypes::Padding => Ok(Messages::Padding(length as u16)), + + MessageTypes::HeartbeatPing => Ok(Messages::HeartbeatPing), + + MessageTypes::HeartbeatPong => Ok(Messages::HeartbeatPong), + + MessageTypes::ClientParams => Ok(Messages::ClientParams), + + MessageTypes::ServerParams => Ok(Messages::ServerParams), + + MessageTypes::CryptoOffer => Ok(Messages::CryptoOffer(CryptoExtension::Kyber)), + + MessageTypes::CryptoAccept => Ok(Messages::CryptoAccept(CryptoExtension::Kyber)), + + MessageTypes::HandshakeEnd => Ok(Messages::HandshakeEnd), + } + } + + fn drain_padding(b: &mut T) -> usize { + if !b.has_remaining() { + return 0; + } + + let length = b.remaining(); + let mut count = length; + // make a shallow copy that we can work with so that we can continually + // check first byte without actually removing it (advancing the pointer + // in the Bytes object). + let mut buf = b.copy_to_bytes(b.remaining()); + for i in 0..length { + if buf[0] != 0 { + count = i; + break; + } + _ = buf.get_u8(); + } + + b.put(buf); + trace!("drained {count}B, {}B remaining", b.remaining(),); + count + } +} + +#[cfg(test)] +mod test { + use super::*; + use crate::framing::*; + use crate::test_utils::init_subscriber; + + use rand::prelude::*; + use tokio_util::bytes::BytesMut; + + #[test] + fn drain_padding() { + init_subscriber(); + let test_cases = [ + ("", 0, 0), + ("00", 1, 0), + ("0000", 2, 0), + ("0000000000000000", 8, 0), + ("000000000000000001", 8, 1), + ("0000010000000000", 2, 6), + ("0102030000000000", 0, 8), + ]; + + for case in test_cases { + let buf = hex::decode(case.0).expect("failed to decode hex"); + let mut b = BytesMut::from(&buf as &[u8]); + let cnt = Messages::drain_padding(&mut b); + assert_eq!(cnt, case.1); + assert_eq!(b.remaining(), case.2); + } + } + + #[test] + fn prngseed() -> Result<(), FrameError> { + init_subscriber(); + + let mut buf = BytesMut::new(); + let mut rng = rand::thread_rng(); + let pad_len = rng.gen_range(0..100); + let mut seed = [0_u8; SEED_LENGTH]; + rng.fill_bytes(&mut seed); + + build_and_marshall(&mut buf, MessageTypes::PrngSeed.into(), seed, pad_len)?; + + let pkt = Messages::try_parse(&mut buf)?; + assert_eq!(Messages::PrngSeed(seed), pkt); + + Ok(()) + } + + #[test] + fn payload() -> Result<(), FrameError> { + init_subscriber(); + + let mut buf = BytesMut::new(); + let mut rng = rand::thread_rng(); + let pad_len = rng.gen_range(0..100); + let mut payload = [0_u8; 1000]; + rng.fill_bytes(&mut payload); + + build_and_marshall(&mut buf, MessageTypes::Payload.into(), payload, pad_len)?; + + let pkt = Messages::try_parse(&mut buf)?; + assert_eq!(Messages::Payload(payload.to_vec()), pkt); + + Ok(()) + } +} diff --git a/crates/o5/src/framing/mod.rs b/crates/o5/src/framing/mod.rs index c1fbecf..7cdccbc 100644 --- a/crates/o5/src/framing/mod.rs +++ b/crates/o5/src/framing/mod.rs @@ -1 +1,189 @@ -mod packet; +/// Package framing implements the obfs4 link framing and cryptography. +/// +/// The Encoder/Decoder shared secret format is: +/// +/// ```txt +/// NaCl_secretbox_key [u8; 32]; +/// NaCl_Nonce_prefix [u8; 16]; +/// SipHash_24_key [u8; 16]; // (used to obfsucate length) +/// SipHash_24_IV [u8; 8]; +/// ``` +/// +/// The frame format is: +/// +/// ```txt +/// length u16; // (obfsucated, big endian) +/// // NaCl secretbox (Poly1305/XSalsa20) containing: +/// tag [u8; 16]; // (Part of the secretbox construct) +/// payload [u8]; +/// ``` +/// +/// The length field is length of the NaCl secretbox XORed with the truncated +/// SipHash-2-4 digest ran in OFB mode. +/// +/// ```txt +/// // Initialize K, IV[0] with values from the shared secret. +/// // On each packet, IV[n] = H(K, IV[n - 1]) +/// // mask_n = IV[n][0:2] +/// // obfs_len = length ^ mask[n] +/// ``` +/// +/// The NaCl secretbox (Poly1305/XSalsa20) nonce format is: +/// +/// ```txt +/// prefix [u8; 24]; //(Fixed) +/// counter u64; // (Big endian) +/// ``` +/// +/// The counter is initialized to 1, and is incremented on each frame. Since +/// the protocol is designed to be used over a reliable medium, the nonce is not +/// transmitted over the wire as both sides of the conversation know the prefix +/// and the initial counter value. It is imperative that the counter does not +/// wrap, and sessions MUST terminate before 2^64 frames are sent. +use crate::common::drbg; +use bytes::{Buf, BufMut}; + +mod messages_base; +pub use messages_base::*; + +mod messages_v1; +pub use messages_v1::{MessageTypes, Messages}; + +mod codecs; +pub use codecs::EncryptingCodec as O5Codec; + +pub(crate) mod handshake; +pub use handshake::*; + +/// MaximumSegmentLength is the length of the largest possible segment +/// including overhead. +pub(crate) const MAX_SEGMENT_LENGTH: usize = 1500 - (40 + 12); + +/// secret box overhead is fixed length prefix and counter +const SECRET_BOX_OVERHEAD: usize = TAG_SIZE; + +/// FrameOverhead is the length of the framing overhead. +pub(crate) const FRAME_OVERHEAD: usize = LENGTH_LENGTH + SECRET_BOX_OVERHEAD; + +/// MaximumFramePayloadLength is the length of the maximum allowed payload +/// per frame. +pub(crate) const MAX_FRAME_PAYLOAD_LENGTH: usize = MAX_SEGMENT_LENGTH - FRAME_OVERHEAD; + +// pub(crate) const MAX_FRAME_LENGTH: usize = MAX_SEGMENT_LENGTH - LENGTH_LENGTH; +// pub(crate) const MIN_FRAME_LENGTH: usize = FRAME_OVERHEAD - LENGTH_LENGTH; + +pub(crate) const NONCE_PREFIX_LENGTH: usize = 16; +// pub(crate) const NONCE_COUNTER_LENGTH: usize = 8; +// pub(crate) const NONCE_LENGTH: usize = NONCE_PREFIX_LENGTH + NONCE_COUNTER_LENGTH; + +/// length in bytes of the `Length` field at the front of a Frame. Converted to +/// big-endian u16 when decoding. +pub(crate) const LENGTH_LENGTH: usize = 2; + +/// KEY_LENGTH is the length of the Encoder/Decoder secret key. +pub(crate) const KEY_LENGTH: usize = 32; + +/// Size of the HMAC tag used for the frame security. +pub(crate) const TAG_SIZE: usize = 16; + +/// This is the expected length of the Key material that is used to seed the +/// encrypting / decryptong codec, i.e. in framing/codec and handshake/ +pub(crate) const KEY_MATERIAL_LENGTH: usize = KEY_LENGTH + NONCE_PREFIX_LENGTH + drbg::SEED_LENGTH; + +pub trait Marshall { + fn marshall(&mut self, buf: &mut impl BufMut) -> Result<(), FrameError>; +} + +pub trait TryParse { + type Output; + fn try_parse(&mut self, buf: &mut impl Buf) -> Result + where + Self: Sized; +} + +impl std::error::Error for FrameError {} + +#[derive(Debug, PartialEq, Eq)] +pub enum FrameError { + /// is the error returned when [`encode`] rejects the payload length. + InvalidPayloadLength(usize), + + /// A cryptographic error occured. + Crypto(crypto_secretbox::Error), + + /// An error occured with the I/O processing + IO(String), + + /// Returned when [`decode`] requires more data to continue. + EAgain, + + /// Returned when [`decode`] failes to authenticate a frame. + TagMismatch, + + /// Returned when the NaCl secretbox nonce's counter wraps (FATAL). + NonceCounterWrapped, + + /// Returned when the buffer provided for writing a frame is too small. + ShortBuffer, + + /// Error indicating that a message decoded, or a message provided for + /// encoding is of an innapropriate type for the context. + InvalidMessage, + + /// Failed while trying to parse a handshake message + InvalidHandshake, + + /// Received either a REALLY unfortunate random, or a replayed handshake message + ReplayedHandshake, + + /// An unknown packet type was received in a non-handshake packet frame. + UnknownMessageType(u8), +} + +impl std::fmt::Display for FrameError { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + match self { + FrameError::InvalidPayloadLength(s) => { + write!(f, "framing: Invalid payload length: {s}") + } + FrameError::Crypto(e) => write!(f, "framing: Secretbox encrypt/decrypt error: {e}"), + FrameError::IO(e) => { + write!(f, "framing: i/o error occured while processing frame: {e}") + } + FrameError::EAgain => write!(f, "framing: more data needed to decode"), + FrameError::TagMismatch => write!(f, "framing: Poly1305 tag mismatch"), + FrameError::NonceCounterWrapped => write!(f, "framing: Nonce counter wrapped"), + FrameError::ShortBuffer => write!( + f, + "framing: provided bytes buffer was too short for payload" + ), + FrameError::InvalidMessage => write!(f, "framing: incorrect message for context"), + FrameError::InvalidHandshake => write!(f, "framing: failed to parse handshake message"), + FrameError::ReplayedHandshake => write!(f, "framing: handshake replayed within TTL"), + FrameError::UnknownMessageType(pt) => write!(f, "framing: unknown packet type ({pt})"), + } + } +} + +impl From for FrameError { + fn from(value: crypto_secretbox::Error) -> Self { + FrameError::Crypto(value) + } +} + +impl From for FrameError { + fn from(value: std::io::Error) -> Self { + FrameError::IO(value.to_string()) + } +} + +impl From for std::io::Error { + fn from(value: FrameError) -> Self { + std::io::Error::new(std::io::ErrorKind::Other, format!("{}", value)) + } +} + +#[cfg(test)] +mod generic_test; +#[cfg(test)] +mod testing; diff --git a/crates/o5/src/framing/testing.rs b/crates/o5/src/framing/testing.rs new file mode 100644 index 0000000..3fe2dd0 --- /dev/null +++ b/crates/o5/src/framing/testing.rs @@ -0,0 +1,211 @@ +/// testing out tokio_util::codec for building transports. +/// +/// useful links: +/// - https://dev.to/jtenner/creating-a-tokio-codec-1f0l +/// - example telnet implementation using codecs +/// - https://github.com/jtenner/telnet_codec +/// +/// - https://docs.rs/tokio-util/latest/tokio_util/codec/index.html +/// - tokio_util codec docs +/// +use super::*; +use crate::test_utils::init_subscriber; +use crate::Result; + +use bytes::{Bytes, BytesMut}; +use futures::{SinkExt, StreamExt}; +use rand::prelude::*; +use tokio_util::codec::{Decoder, Encoder}; +use tracing::{debug, trace}; + +fn random_key_material() -> [u8; KEY_MATERIAL_LENGTH] { + let mut r = [0_u8; KEY_MATERIAL_LENGTH]; + getrandom::getrandom(&mut r).unwrap(); + r +} + +#[test] +fn encode_decode() -> Result<()> { + init_subscriber(); + let message = b"Hello there".to_vec(); + let mut key_material = [0_u8; KEY_MATERIAL_LENGTH]; + rand::thread_rng().fill(&mut key_material[..]); + + let mut codec = O5Codec::new(key_material, key_material); + + let mut b = bytes::BytesMut::with_capacity(LENGTH_LENGTH + MESSAGE_OVERHEAD + message.len()); + let mut input = BytesMut::new(); + build_and_marshall(&mut input, MessageTypes::Payload.into(), message.clone(), 0)?; + codec.encode(&mut input, &mut b)?; + + let Messages::Payload(plaintext) = codec.decode(&mut b)?.expect("failed to decode") else { + panic!("f") + }; + assert_eq!(plaintext, message); + + Ok(()) +} + +#[tokio::test] +async fn basic_flow() -> Result<()> { + init_subscriber(); + let message = b"Hello there"; + let key_material = [0_u8; KEY_MATERIAL_LENGTH]; + + try_flow(key_material, message.to_vec()).await +} + +#[tokio::test] +async fn oversized_flow() -> Result<()> { + init_subscriber(); + let frame_len = MAX_FRAME_PAYLOAD_LENGTH + 1; + let oversized_messsage = vec![65_u8; frame_len]; + let key_material = [0_u8; KEY_MATERIAL_LENGTH]; + + let mut b = bytes::BytesMut::with_capacity(2_usize.pow(13)); + let mut codec = O5Codec::new(key_material, key_material); + let mut src = Bytes::from(oversized_messsage); + let res = codec.encode(&mut src, &mut b); + + assert_eq!( + res.unwrap_err(), + FrameError::InvalidPayloadLength(frame_len) + ); + Ok(()) +} + +#[tokio::test] +async fn many_sizes_flow() -> Result<()> { + init_subscriber(); + for l in MAX_FRAME_PAYLOAD_LENGTH - 6..(MAX_FRAME_PAYLOAD_LENGTH - MESSAGE_OVERHEAD) { + let key_material = random_key_material(); + let message = vec![65_u8; l]; + debug!("\n\n{l}, {}", message.len()); + tokio::select! { + res = try_flow(key_material, message) => { + res?; + }, + _ = tokio::time::sleep(tokio::time::Duration::from_secs(3)) => { + panic!("timed out for {l}"); + }, + } + } + Ok(()) +} + +async fn try_flow(key_material: [u8; KEY_MATERIAL_LENGTH], msg: Vec) -> Result<()> { + let (c, s) = tokio::io::duplex(16 * 1024); + + let msg_s = msg.clone(); + + tokio::spawn(async move { + let codec = O5Codec::new(key_material, key_material); + let message = &msg_s; + + let (mut sink, mut input) = codec.framed(s).split(); + + while let Some(Ok(event)) = input.next().await { + if let Messages::Payload(m) = event { + assert_eq!(&m, &message.clone()); + trace!("Event {:?}", String::from_utf8(m.clone()).unwrap()); + + let mut b = BytesMut::new(); + build_and_marshall(&mut b, MessageTypes::Payload.into(), &m, 0).unwrap(); + sink.send(b).await.expect("server response failed"); + } else { + panic!("failed while reading from codec"); + } + } + }); + + let mut message = BytesMut::new(); + build_and_marshall(&mut message, MessageTypes::Payload.into(), &msg, 0)?; + + let client_codec = O5Codec::new(key_material, key_material); + let (mut c_sink, mut c_stream) = client_codec.framed(c).split(); + + c_sink.send(&mut message).await.expect("client send failed"); + trace!("client write success"); + + if let Messages::Payload(m) = c_stream + .next() + .await + .unwrap_or_else(|| { + panic!( + "you were supposed to call me back!, {} (max={})", + message.len(), + MAX_FRAME_PAYLOAD_LENGTH + ) + }) + .expect("an error occured when you called back") + { + // skip over length field in the Payload message + assert_eq!(&m, &msg); + trace!("client read success"); + } else { + panic!("failed while reading from codec"); + } + + Ok(()) +} + +#[tokio::test] +async fn double_encode_decode() -> Result<()> { + // println!(); + init_subscriber(); + let (c, s) = tokio::io::duplex(16 * 1024); + let msg = b"j dkja ;ae ;awena woea;wfel rfawe"; + let plain_msg = Messages::Payload(msg.to_vec()); + let mut pkt1 = BytesMut::new(); + plain_msg.marshall(&mut pkt1)?; + let mut pkt2 = pkt1.clone(); + + let key_material = random_key_material(); + let client_codec = O5Codec::new(key_material, key_material); + let (mut c_sink, mut c_stream) = client_codec.framed(c).split(); + let server_codec = O5Codec::new(key_material, key_material); + let (mut s_sink, mut s_stream) = server_codec.framed(s).split::(); + + c_sink.send(&mut pkt1).await.expect("client send failed"); + c_sink.send(&mut pkt2).await.expect("client send failed"); + + for i in 0..2 { + let Some(Ok(event)) = s_stream.next().await else { + panic!("read none!!!") + }; + if let Messages::Payload(m) = event { + assert_eq!(&m, &msg.clone()); + trace!("Event-{i} {:?}", String::from_utf8(m.clone()).unwrap()); + + let mut msg = BytesMut::new(); + Messages::Payload(m).marshall(&mut msg)?; + + s_sink.send(msg.freeze()).await?; + } else { + panic!("failed while reading from codec"); + } + } + + for i in 0..2 { + if let Messages::Payload(m) = c_stream + .next() + .await + .unwrap_or_else(|| { + panic!( + "you were supposed to call me back!, {} (max={})", + msg.len(), + MAX_FRAME_PAYLOAD_LENGTH + ) + }) + .expect("an error occured when you called back") + { + // skip over length field in the Payload message + assert_eq!(&m, &msg); + trace!("client read {i} success"); + } else { + panic!("failed while reading from codec"); + } + } + + Ok(()) +} diff --git a/crates/o5/src/handshake/README.md b/crates/o5/src/handshake/README.md new file mode 100644 index 0000000..7dda9c2 --- /dev/null +++ b/crates/o5/src/handshake/README.md @@ -0,0 +1,129 @@ + +# Obfs4 Ntor Handshake + +While exchanging messages during the handshake the client and +server use (a modified version of) the Ntor handshake to +compute a shared seed as well as an authentication value. + +The original implementation of the Obfs4 Ntor Handshake has some +small variation from the actual Ntor V1 handshake and as such +requires an alternative implementation to be compatible with +the existing [golang implementation](https://gitlab.com/yawning/obfs4) + + +## Difference from Ntor V1 + +* message value used for key seed is different: obfs4 uses a different order and +accidentally writes the server's identity public key bytes twice. + - Ntor V1 - uses `message = (secret_input) | ID | b | x | y | PROTOID` + - Obfs4 - uses `message = (secret_input) | b | b | x | y | PROTOID | ID` + +* seed for key generator + * Ntor V1 - uses raw bytes from `message` + * Obfs4 - uses `HMAC_SHA256(message, T_KEY)` where `T_KEY = "ntor-curve25519-sha256-1:key_extract"` + +* The constant string for `T_VERIFY` + * Ntor V1 - `T_VERIFY = b"ntor-curve25519-sha256-1:verify";` + * Obfs4 - `T_VERIFY = b"ntor-curve25519-sha256-1:key_verify";` + +* message value used for auth is different -- these hash over the same fields, +but result in different hash values. Obfs4 reuses part of the `message` value +so the duplicated server identity public key is included. + * Ntor V1 - uses input `verify | ID | b | y | x | PROTOID | "Server"` + * Obfs4 - uses input `verify | b | b | y | x | PROTOID | ID | "Server"` + +The rust implementation of the Obfs4 Ntor derivation with diff markup. + +```diff + +pub(crate) const PROTO_ID: &[u8; 24] = b"ntor-curve25519-sha256-1"; +pub(crate) const T_MAC: &[u8; 28] = b"ntor-curve25519-sha256-1:mac"; +-pub(crate) const T_VERIFY: &[u8; 31] = b"ntor-curve25519-sha256-1:verify"; ++pub(crate) const T_VERIFY: &[u8; 35] = b"ntor-curve25519-sha256-1:key_verify"; +pub(crate) const T_KEY: &[u8; 36] = b"ntor-curve25519-sha256-1:key_extract"; +pub(crate) const T_EXPAND: &[u8; 35] = b"ntor-curve25519-sha256-1:key_expand"; + + +/// helper: compute a key generator and an authentication code from a set +/// of ntor parameters. +/// +/// These parameter names are as described in tor-spec.txt +fn ntor_derive( + xy: &SharedSecret, + xb: &SharedSecret, + server_pk: &O5NtorPublicKey, + x: &PublicKey, + y: &PublicKey, +) -> EncodeResult<(NtorHkdfKeyGenerator, Authcode)> { + let server_string = &b"Server"[..]; + + // shared_secret_input = EXP(X,y) | EXP(X,b) OR = EXP(Y,x) | EXP(B,x) +- // message = (shared_secret_input) | ID | X | Y | PROTOID +- let mut message = SecretBuf::new(); +- message.write(xy.as_bytes())?; // EXP(X,y) +- message.write(xb.as_bytes())?; // EXP(X,b) +- message.write(&server_pk.id)?; // ID +- message.write(&server_pk.pk.as_bytes())?; // b +- message.write(x.as_bytes())?; // x +- message.write(y.as_bytes())?; // y +- message.write(PROTO_ID)?; // PROTOID ++ // obfs4 uses a different order than Ntor V1 and accidentally writes the ++ // server's identity public key bytes twice. ++ let mut suffix = SecretBuf::new(); ++ suffix.write(&server_pk.pk.as_bytes())?; // b ++ suffix.write(&server_pk.pk.as_bytes())?; // b ++ suffix.write(x.as_bytes())?; // x ++ suffix.write(y.as_bytes())?; // y ++ suffix.write(PROTO_ID)?; // PROTOID ++ suffix.write(&server_pk.id)?; // ID ++ ++ // message = (secret_input) | b | b | x | y | PROTOID | ID ++ let mut message = SecretBuf::new(); ++ message.write(xy.as_bytes())?; // EXP(X,y) ++ message.write(xb.as_bytes())?; // EXP(X,b) ++ message.write(&suffix[..])?; // b | b | x | y | PROTOID | ID + + // verify = HMAC_SHA256(message, T_VERIFY) + let verify = { + let mut m = + Hmac::::new_from_slice(T_VERIFY).expect("Hmac allows keys of any size"); + m.update(&message[..]); + m.finalize() + }; + +- // auth_input = verify | ID | b | y | x | PROTOID | "Server" ++ // auth_input = verify | (suffix) | "Server" ++ // auth_input = verify | b | b | y | x | PROTOID | ID | "Server" + let mut auth_input = Vec::new(); + auth_input.write_and_consume(verify)?; // verify +- auth_input.write(&server_pk.id)?; // ID +- auth_input.write(&server_pk.pk.as_bytes())?; // B +- auth_input.write(y.as_bytes())?; // Y +- auth_input.write(x.as_bytes())?; // X +- auth_input.write(PROTO_ID)?; // PROTOID ++ auth_input.write(&suffix[..])?; // b | b | x | y | PROTOID | ID + auth_input.write(server_string)?; // "Server" + + // auth = HMAC_SHA256(auth_input, T_MAC) + let auth_mac = { + let mut m = + Hmac::::new_from_slice(T_MAC).expect("Hmac allows keys of any size"); + m.update(&auth_input[..]); + m.finalize() + }; + ++ let key_seed_bytes = { ++ let mut m = ++ Hmac::::new_from_slice(T_KEY).expect("Hmac allows keys of any size"); ++ m.update(&message[..]); ++ m.finalize() ++ }; ++ let mut key_seed = SecretBuf::new(); ++ key_seed.write_and_consume(key_seed_bytes)?; ++ ++ let keygen = NtorHkdfKeyGenerator::new(key_seed); +- let keygen = NtorHkdfKeyGenerator::new(message); + Ok((keygen, auth_mac)) +} + +``` diff --git a/crates/o5/src/handshake/handshake_client.rs b/crates/o5/src/handshake/handshake_client.rs new file mode 100644 index 0000000..316bef6 --- /dev/null +++ b/crates/o5/src/handshake/handshake_client.rs @@ -0,0 +1,335 @@ +use super::*; +use crate::{ + common::{ + curve25519::{PublicKey, PublicRepresentative, REPRESENTATIVE_LENGTH}, + HmacSha256, + }, + framing::handshake::{ClientHandshakeMessage, ServerHandshakeMessage}, +}; + +use ptrs::trace; +use rand::Rng; + +/// materials required to initiate a handshake from the client role. +#[derive(Debug, Clone, PartialEq)] +pub(crate) struct HandshakeMaterials { + pub(crate) node_pubkey: O5NtorPublicKey, + pub(crate) pad_len: usize, + pub(crate) session_id: String, +} + +impl HandshakeMaterials { + pub(crate) fn new(node_pubkey: O5NtorPublicKey, session_id: String) -> Self { + HandshakeMaterials { + node_pubkey, + session_id, + pad_len: rand::thread_rng().gen_range(CLIENT_MIN_PAD_LENGTH..CLIENT_MAX_PAD_LENGTH), + } + } +} + + +/// Client state for the o5 (ntor v3) handshake. +/// +/// The client needs to hold this state between when it sends its part +/// of the handshake and when it receives the relay's reply. +#[derive(Clone)] +pub(crate) struct O5NtorHandshakeState { + /// The temporary curve25519 secret (x) that we've generated for + /// this handshake. + // We'd like to EphemeralSecret here, but we can't since we need + // to use it twice. + my_sk: curve25519::StaticSecret, + + /// handshake materials + materials: HandshakeMaterials, + + /// the computed hour at which the initial portion of the handshake was sent. + epoch_hr: String, + + /// The shared secret generated as Bx or Xb. + shared_secret: curve25519::SharedSecret, // Bx + + /// The MAC of our original encrypted message. + msg_mac: MacVal, // msg_mac +} + +/// Client-side Ntor version 3 handshake, part one. +/// +/// Given a secure `rng`, a relay's public key, a secret message to send, +/// and a shared verification string, generate a new handshake state +/// and a message to send to the relay. +pub(super) fn client_handshake_o5( + materials: &HandshakeMaterials, +) -> Result<(O5NtorHandshakeState, Vec)> { + let rng = rand::thread_rng(); + let my_sk = Representable::static_from_rng(rng); + client_handshake_o5_no_keygen(my_sk, materials.clone()) +} +// fn client_handshake_o5( +// relay_public: &NtorV3PublicKey, +// client_msg: &[u8], +// verification: &[u8], +// ) -> EncodeResult<(NtorV3HandshakeState, Vec)> { +// let mut rng = rand::thread_rng(); +// let my_sk = curve25519::StaticSecret::random_from_rng(rng); +// client_handshake_ntor_v3_no_keygen(relay_public, client_msg, verification, my_sk) +// } + +/// As `client_handshake_ntor_v3`, but don't generate an ephemeral DH +/// key: instead take that key an arguments `my_sk`. +// fn client_handshake_ntor_o5_keygen( +// relay_public: &NtorV3PublicKey, +// client_msg: &[u8], +// verification: &[u8], +// my_sk: curve25519::StaticSecret, +// ) -> EncodeResult<(NtorV3HandshakeState, Vec)> { +pub(super) fn client_handshake_o5_no_keygen( + my_sk: curve25519::StaticSecret, + materials: HandshakeMaterials, +) -> Result<(O5NtorHandshakeState, Vec)> { + let my_public = curve25519::PublicKey::from(&my_sk); + let bx = my_sk.diffie_hellman(&materials.node_pubkey.pk); + + let (enc_key, mut mac) = kdf_msgkdf(&bx, materials.node_pubkey, &my_public, verification)?; + + //encrypted_msg = ENC(ENC_K1, CM) + // msg_mac = MAC_msgmac(MAC_K1, ID | B | X | encrypted_msg) + let encrypted_msg = encrypt(&enc_key, client_msg); + let msg_mac: DigestVal = { + use digest::Digest; + mac.write(&encrypted_msg)?; + mac.take().finalize().into() + }; + + let mut message = Vec::new(); + message.write(&relay_public.id)?; + message.write(&relay_public.pk)?; + message.write(&my_public)?; + message.write(&encrypted_msg)?; + message.write(&msg_mac)?; + + let state = O5NtorHandshakeState { + relay_public: relay_public.clone(), + my_sk, + my_public, + shared_secret: bx, + msg_mac, + }; + + Ok((state, message)) +} + +/// Helper: client handshake _without_ generating new keys. +pub(crate) fn client_handshake_obfs4_no_keygen( + ephem: StaticSecret, + materials: HandshakeMaterials, +) -> Result<(O5NtorHandshakeState, Vec)> { + let repres: Option = (&ephem).into(); + + // build client handshake message + let mut ch_msg = ClientHandshakeMessage::new( + repres.unwrap(), + materials.pad_len, + materials.session_id.clone(), + ); + + let mut buf = BytesMut::with_capacity(MAX_HANDSHAKE_LENGTH); + let mut key = materials.node_pubkey.pk.as_bytes().to_vec(); + key.append(&mut materials.node_pubkey.id.as_bytes().to_vec()); + let h = HmacSha256::new_from_slice(&key[..]).unwrap(); + ch_msg.marshall(&mut buf, h)?; + + let state = O5NtorHandshakeState { + my_sk: ephem, + materials, + epoch_hr: ch_msg.epoch_hour, + }; + + Ok((state, buf.to_vec())) +} + +/// Complete a client handshake, returning a key generator on success. +/// +/// Called after we've received a message from the relay: try to +/// complete the handshake and verify its correctness. +/// +/// On success, return the server's reply to our original encrypted message, +/// and an `XofReader` to use in generating circuit keys. +// fn client_handshake_ntor_v3_part2( +// state: &NtorV3HandshakeState, +// relay_handshake: &[u8], +// verification: &[u8], +// ) -> Result<(Vec, NtorV3XofReader)> { +pub(super) fn client_handshake_o5_part2( + msg: T, + state: &O5NtorHandshakeState, +) -> Result<(O5NtorKeyGenerator, Vec)> +where + T: AsRef<[u8]>, +{ + let mut reader = Reader::from_slice(relay_handshake); + let y_pk: curve25519::PublicKey = reader + .extract() + .map_err(|e| Error::from_bytes_err(e, "v3 ntor handshake"))?; + let auth: DigestVal = reader + .extract() + .map_err(|e| Error::from_bytes_err(e, "v3 ntor handshake"))?; + let encrypted_msg = reader.into_rest(); + + // TODO: Some of this code is duplicated from the server handshake code! It + // would be better to factor it out. + let yx = state.my_sk.diffie_hellman(&y_pk); + let secret_input = { + let mut si = SecretBuf::new(); + si.write(&yx) + .and_then(|_| si.write(&state.shared_secret)) + .and_then(|_| si.write(&state.relay_public.id)) + .and_then(|_| si.write(&state.relay_public.pk)) + .and_then(|_| si.write(&state.my_public)) + .and_then(|_| si.write(&y_pk)) + .and_then(|_| si.write(PROTOID)) + .and_then(|_| si.write(&Encap(verification))) + .map_err(into_internal!("error encoding ntor3 secret_input"))?; + si + }; + let ntor_key_seed = h_key_seed(&secret_input); + let verify = h_verify(&secret_input); + + let computed_auth: DigestVal = { + use digest::Digest; + let mut auth = DigestWriter(Sha3_256::default()); + auth.write(&T_AUTH) + .and_then(|_| auth.write(&verify)) + .and_then(|_| auth.write(&state.relay_public.id)) + .and_then(|_| auth.write(&state.relay_public.pk)) + .and_then(|_| auth.write(&y_pk)) + .and_then(|_| auth.write(&state.my_public)) + .and_then(|_| auth.write(&state.msg_mac)) + .and_then(|_| auth.write(&Encap(encrypted_msg))) + .and_then(|_| auth.write(PROTOID)) + .and_then(|_| auth.write(&b"Server"[..])) + .map_err(into_internal!("error encoding ntor3 authentication input"))?; + auth.take().finalize().into() + }; + + let okay = computed_auth.ct_eq(&auth) + & ct::bool_to_choice(yx.was_contributory()) + & ct::bool_to_choice(state.shared_secret.was_contributory()); + + let (enc_key, keystream) = { + use digest::{ExtendableOutput, XofReader}; + let mut xof = DigestWriter(Shake256::default()); + xof.write(&T_FINAL) + .and_then(|_| xof.write(&ntor_key_seed)) + .map_err(into_internal!("error encoding ntor3 xof input"))?; + let mut r = xof.take().finalize_xof(); + let mut enc_key = Zeroizing::new([0_u8; ENC_KEY_LEN]); + r.read(&mut enc_key[..]); + (enc_key, r) + }; + let server_reply = decrypt(&enc_key, encrypted_msg); + + if okay.into() { + Ok((server_reply, NtorV3XofReader(keystream))) + } else { + Err(Error::BadCircHandshakeAuth) + } +} + +#[cfg(test)] +pub(crate) fn client_handshake2_no_auth_check_obfs4( + msg: T, + state: &O5NtorHandshakeState, +) -> Result<(O5NtorKeyGenerator, Authcode)> +where + T: AsRef<[u8]>, +{ + // try to parse the message as an incoming server handshake. + let (mut shs_msg, _) = try_parse(&msg, state)?; + + let their_pk = shs_msg.server_pubkey(); + // let auth: Authcode = shs_msg.server_auth(); + + let node_pubkey = &state.materials.node_pubkey; + let my_public: PublicKey = (&state.my_sk).into(); + + let xy = state.my_sk.diffie_hellman(&their_pk); + let xb = state.my_sk.diffie_hellman(&node_pubkey.pk); + + let (key_seed, authcode) = ntor_derive(&xy, &xb, node_pubkey, &my_public, &their_pk) + .map_err(into_internal!("Error deriving keys"))?; + + let keygen = O5NtorKeyGenerator::new(key_seed, true); + + Ok((keygen, authcode)) +} + +fn try_parse( + buf: impl AsRef<[u8]>, + state: &O5NtorHandshakeState, +) -> Result<(ServerHandshakeMessage, usize)> { + let buf = buf.as_ref(); + trace!( + "{} parsing server handshake {}", + state.materials.session_id, + buf.len() + ); + + if buf.len() < SERVER_MIN_HANDSHAKE_LENGTH { + Err(RelayHandshakeError::EAgain)? + } + + // derive the server mark + let mut key = state.materials.node_pubkey.pk.as_bytes().to_vec(); + key.append(&mut state.materials.node_pubkey.id.as_bytes().to_vec()); + let mut h = HmacSha256::new_from_slice(&key[..]).unwrap(); + h.reset(); // disambiguate reset() implementations Mac v digest + + let mut r_bytes: [u8; 32] = buf[0..REPRESENTATIVE_LENGTH].try_into().unwrap(); + h.update(&r_bytes); + + // clear the inconsistent elligator2 bits of the representative after + // using the wire format for deriving the mark + r_bytes[31] &= 0x3f; + let server_repres = PublicRepresentative::from(r_bytes); + let server_auth: [u8; AUTHCODE_LENGTH] = + buf[REPRESENTATIVE_LENGTH..REPRESENTATIVE_LENGTH + AUTHCODE_LENGTH].try_into()?; + + let server_mark = h.finalize_reset().into_bytes()[..MARK_LENGTH].try_into()?; + + //attempt to find the mark + MAC + let start_pos = REPRESENTATIVE_LENGTH + AUTHCODE_LENGTH + SERVER_MIN_PAD_LENGTH; + let pos = match find_mac_mark(server_mark, buf, start_pos, MAX_HANDSHAKE_LENGTH, false) { + Some(p) => p, + None => { + if buf.len() > MAX_HANDSHAKE_LENGTH { + Err(RelayHandshakeError::BadServerHandshake)? + } + Err(RelayHandshakeError::EAgain)? + } + }; + + // validate the MAC + h.reset(); // disambiguate `reset()` implementations Mac v digest + h.update(&buf[..pos + MARK_LENGTH]); + h.update(state.epoch_hr.as_bytes()); + let mac_calculated = &h.finalize_reset().into_bytes()[..MAC_LENGTH]; + let mac_received = &buf[pos + MARK_LENGTH..pos + MARK_LENGTH + MAC_LENGTH]; + trace!( + "client mac check {}-{}", + hex::encode(mac_calculated), + hex::encode(mac_received) + ); + if mac_calculated.ct_eq(mac_received).into() { + let mut r_bytes = server_repres.to_bytes(); + r_bytes[31] &= 0x3f; + return Ok(( + ServerHandshakeMessage::new(server_repres, server_auth, state.epoch_hr.clone()), + pos + MARK_LENGTH + MAC_LENGTH, + )); + } + + // received the incorrect mac + Err(RelayHandshakeError::BadServerHandshake.into()) +} diff --git a/crates/o5/src/handshake/handshake_server.rs b/crates/o5/src/handshake/handshake_server.rs new file mode 100644 index 0000000..3cdfb06 --- /dev/null +++ b/crates/o5/src/handshake/handshake_server.rs @@ -0,0 +1,284 @@ +use super::*; +use crate::{ + common::{ + curve25519::{PublicRepresentative, REPRESENTATIVE_LENGTH}, + HmacSha256, + }, + framing::{build_and_marshall, ClientHandshakeMessage, MessageTypes, ServerHandshakeMessage}, +}; + +use ptrs::{debug, trace}; +use rand::thread_rng; +use tokio_util::codec::Encoder; + +use std::time::Instant; + +#[derive(Clone)] +pub(crate) struct HandshakeMaterials { + pub(crate) identity_keys: O5NtorSecretKey, + pub(crate) session_id: String, + pub(crate) len_seed: [u8; SEED_LENGTH], +} + +impl<'a> HandshakeMaterials { + pub fn get_hmac(&self) -> HmacSha256 { + let mut key = self.identity_keys.pk.pk.as_bytes().to_vec(); + key.append(&mut self.identity_keys.pk.id.as_bytes().to_vec()); + HmacSha256::new_from_slice(&key[..]).unwrap() + } + + pub fn new<'b>( + identity_keys: &'b O5NtorSecretKey, + session_id: String, + len_seed: [u8; SEED_LENGTH], + ) -> Self + where + 'b: 'a, + { + HandshakeMaterials { + identity_keys: identity_keys.clone(), + session_id, + len_seed, + } + } +} + +impl Server { + /// Perform a server-side ntor handshake. + /// + /// On success returns a key generator and a server onionskin. + pub(super) fn server_handshake_obfs4( + &self, + msg: T, + materials: HandshakeMaterials, + ) -> RelayHandshakeResult<(NtorHkdfKeyGenerator, Vec)> + where + T: AsRef<[u8]>, + { + let rng = thread_rng(); + let session_sk = Representable::ephemeral_from_rng(rng); + + self.server_handshake_obfs4_no_keygen(session_sk, msg, materials) + } + + /// Helper: perform a server handshake without generating any new keys. + pub(crate) fn server_handshake_obfs4_no_keygen( + &self, + session_sk: EphemeralSecret, + msg: T, + mut materials: HandshakeMaterials, + ) -> RelayHandshakeResult<(NtorHkdfKeyGenerator, Vec)> + where + T: AsRef<[u8]>, + { + if CLIENT_MIN_HANDSHAKE_LENGTH > msg.as_ref().len() { + Err(RelayHandshakeError::EAgain)?; + } + + let mut client_hs = match self.try_parse_client_handshake(msg, &mut materials) { + Ok(chs) => chs, + Err(Error::HandshakeErr(RelayHandshakeError::EAgain)) => { + return Err(RelayHandshakeError::EAgain); + } + Err(_e) => { + debug!( + "{} failed to parse client handshake: {_e}", + materials.session_id + ); + return Err(RelayHandshakeError::BadClientHandshake); + } + }; + + debug!( + "{} successfully parsed client handshake", + materials.session_id + ); + let their_pk = client_hs.get_public(); + let ephem_pub = PublicKey::from(&session_sk); + let session_repres: Option = (&session_sk).into(); + + let xy = session_sk.diffie_hellman(&their_pk); + let xb = materials.identity_keys.sk.diffie_hellman(&their_pk); + + // Ensure that none of the keys are broken (i.e. equal to zero). + let okay = + ct::bool_to_choice(xy.was_contributory()) & ct::bool_to_choice(xb.was_contributory()); + trace!("x {} y {}", hex::encode(their_pk), hex::encode(ephem_pub)); + + let (key_seed, authcode) = + ntor_derive(&xy, &xb, &materials.identity_keys.pk, &their_pk, &ephem_pub) + .map_err(into_internal!("Error deriving keys"))?; + trace!( + "seed: {} auth: {}", + hex::encode(key_seed.as_slice()), + hex::encode(authcode) + ); + + let mut keygen = NtorHkdfKeyGenerator::new(key_seed, false); + + let reply = self.complete_server_hs( + &client_hs, + materials, + session_repres.unwrap(), + &mut keygen, + authcode, + )?; + + if okay.into() { + Ok((keygen, reply)) + } else { + Err(RelayHandshakeError::BadClientHandshake) + } + } + + pub(crate) fn complete_server_hs( + &self, + client_hs: &ClientHandshakeMessage, + materials: HandshakeMaterials, + session_repres: PublicRepresentative, + keygen: &mut NtorHkdfKeyGenerator, + authcode: Authcode, + ) -> RelayHandshakeResult> { + let epoch_hr = client_hs.get_epoch_hr(); + + // Since the current and only implementation always sends a PRNG seed for + // the length obfuscation, this makes the amount of data received from the + // server inconsistent with the length sent from the client. + // + // Re-balance this by tweaking the client minimum padding/server maximum + // padding, and sending the PRNG seed unpadded (As in, treat the PRNG seed + // as part of the server response). See inlineSeedFrameLength in + // handshake_ntor.go. + + // Generate/send the response. + let mut sh_msg = ServerHandshakeMessage::new(session_repres, authcode, epoch_hr); + + let h = materials.get_hmac(); + let mut buf = BytesMut::with_capacity(MAX_HANDSHAKE_LENGTH); + sh_msg + .marshall(&mut buf, h) + .map_err(|e| RelayHandshakeError::FrameError(format!("{e}")))?; + trace!("adding encoded prng seed"); + + // Send the PRNG seed as part of the first packet. + let mut prng_pkt_buf = BytesMut::new(); + build_and_marshall( + &mut prng_pkt_buf, + MessageTypes::PrngSeed.into(), + materials.len_seed, + 0, + ) + .map_err(|e| RelayHandshakeError::FrameError(format!("{e}")))?; + + let codec = &mut keygen.codec; + codec + .encode(prng_pkt_buf.clone(), &mut buf) + .map_err(|e| RelayHandshakeError::FrameError(format!("{e}")))?; + + debug!( + "{} writing server handshake {}B ...{}", + materials.session_id, + buf.len(), + hex::encode(&buf[buf.len() - 10..]), + ); + + Ok(buf.to_vec()) + } + + fn try_parse_client_handshake( + &self, + buf: impl AsRef<[u8]>, + materials: &mut HandshakeMaterials, + ) -> Result { + let buf = buf.as_ref(); + let mut h = materials.get_hmac(); + + if CLIENT_MIN_HANDSHAKE_LENGTH > buf.len() { + Err(Error::HandshakeErr(RelayHandshakeError::EAgain))?; + } + + let mut r_bytes: [u8; 32] = buf[0..REPRESENTATIVE_LENGTH].try_into().unwrap(); + + // derive the mark based on the literal bytes on the wire + h.update(&r_bytes[..]); + + // clear the bits that are unreliable (and randomized) for elligator2 + r_bytes[31] &= 0x3f; + let repres = PublicRepresentative::from(&r_bytes); + + let m = h.finalize_reset().into_bytes(); + let mark: [u8; MARK_LENGTH] = m[..MARK_LENGTH].try_into()?; + + trace!("{} mark?:{}", materials.session_id, hex::encode(mark)); + + // find mark + mac position + let pos = match find_mac_mark( + mark, + buf, + REPRESENTATIVE_LENGTH + CLIENT_MIN_PAD_LENGTH, + MAX_HANDSHAKE_LENGTH, + true, + ) { + Some(p) => p, + None => { + trace!("{} didn't find mark", materials.session_id); + if buf.len() > MAX_HANDSHAKE_LENGTH { + Err(Error::HandshakeErr(RelayHandshakeError::BadClientHandshake))? + } + Err(Error::HandshakeErr(RelayHandshakeError::EAgain))? + } + }; + + // validate he MAC + let mut mac_found = false; + let mut epoch_hr = String::new(); + for offset in [0_i64, -1, 1] { + // Allow the epoch to be off by up to one hour in either direction + trace!("server trying offset: {offset}"); + let eh = format!("{}", offset + get_epoch_hour() as i64); + + h.reset(); + h.update(&buf[..pos + MARK_LENGTH]); + h.update(eh.as_bytes()); + let mac_calculated = &h.finalize_reset().into_bytes()[..MAC_LENGTH]; + let mac_received = &buf[pos + MARK_LENGTH..pos + MARK_LENGTH + MAC_LENGTH]; + trace!( + "server {}-{}", + hex::encode(mac_calculated), + hex::encode(mac_received) + ); + if mac_calculated.ct_eq(mac_received).into() { + trace!("correct mac"); + // Ensure that this handshake has not been seen previously. + if self + .replay_filter + .test_and_set(Instant::now(), mac_received) + { + // The client either happened to generate exactly the same + // session key and padding, or someone is replaying a previous + // handshake. In either case, fuck them. + Err(Error::HandshakeErr(RelayHandshakeError::ReplayedHandshake))? + } + + epoch_hr = eh; + mac_found = true; + // we could break here, but in the name of reducing timing + // variance, we just evaluate all three MACs. + } + } + if !mac_found { + // This could be a [`RelayHandshakeError::TagMismatch`] :shrug: + Err(Error::HandshakeErr(RelayHandshakeError::BadClientHandshake))? + } + + // client should never send any appended padding at the end. + if buf.len() != pos + MARK_LENGTH + MAC_LENGTH { + Err(Error::HandshakeErr(RelayHandshakeError::BadClientHandshake))? + } + + Ok(ClientHandshakeMessage::new( + repres, 0, // pad_len doesn't matter when we are reading client handshake msg + epoch_hr, + )) + } +} diff --git a/crates/o5/src/handshake/integration.rs b/crates/o5/src/handshake/integration.rs index 18bf109..6605eac 100644 --- a/crates/o5/src/handshake/integration.rs +++ b/crates/o5/src/handshake/integration.rs @@ -15,175 +15,248 @@ //! use super::*; -use crate::common::ntor_arti::{ClientHandshake, ServerHandshake}; +use crate::{ + common::{colorize, curve25519}, + test_utils::{init_subscriber, FakePRNG}, +}; use hex_literal::hex; use tor_basic_utils::test_rng::testing_rng; -use digest::XofReader; - +fn make_fake_ephem_key(bytes: &[u8]) -> curve25519::EphemeralSecret { + assert_eq!(bytes.len(), 32); + let rng = FakePRNG::new(bytes); + curve25519::EphemeralSecret::random_from_rng(rng) +} #[test] -fn test_obfs4_roundtrip() { +fn test_o5_roundtrip() -> Result<()> { let mut rng = rand::thread_rng(); - let relay_private = Obfs4NtorSecretKey::generate_for_test(&mut testing_rng()); - let verification = &b"shared secret"[..]; - let client_message = &b"Hello. I am a client. Let's be friends!"[..]; - let relay_message = &b"Greetings, client. I am a robot. Beep boop."[..]; + let relay_private = O5NtorSecretKey::generate_for_test(&mut rng); + let x = O5NtorSecretKey::generate_for_test(&mut rng); + let y = O5NtorSecretKey::generate_for_test(&mut rng); - let (c_state, c_handshake) = - client_handshake_obfs4(&mut rng, &relay_private.pk, client_message, verification) - .unwrap(); + let mut sid = [0u8; SESSION_ID_LEN]; + rand::thread_rng().fill_bytes(&mut sid); - struct Rep(Vec, Vec); - impl MsgReply for Rep { - fn reply(&mut self, msg: &[u8]) -> Option> { - self.0 = msg.to_vec(); - Some(self.1.clone()) - } - } - let mut rep = Rep(Vec::new(), relay_message.to_vec()); - - let (s_handshake, mut s_keygen) = server_handshake_obfs4( - &mut rng, - &mut rep, - &c_handshake, - &[relay_private], - verification, - ) - .unwrap(); + let chs_materials = CHSMaterials::new(relay_private.pk, colorize(sid)); + + let server = Server::new_from_key(relay_private); + + let shs_materials = SHSMaterials { + identity_keys: server.identity_keys.clone(), + len_seed: [0u8; SEED_LENGTH], + session_id: "s-yyy".into(), + }; + + let (state, create_msg) = client_handshake_o5_no_keygen(x.sk, chs_materials).unwrap(); + + let ephem = make_fake_ephem_key(&y.sk.as_bytes()[..]); + let (s_keygen, created_msg) = server + .server_handshake_o5_no_keygen(ephem, &create_msg[..], shs_materials) + .unwrap(); - let (s_msg, mut c_keygen) = - client_handshake_obfs4_part2(&c_state, &s_handshake, verification).unwrap(); + let (c_keygen, _) = client_handshake2_o5(created_msg, &state)?; - assert_eq!(rep.0[..], client_message[..]); - assert_eq!(s_msg[..], relay_message[..]); - let mut s_keys = [0_u8; 100]; - let mut c_keys = [0_u8; 1000]; - s_keygen.read(&mut s_keys); - c_keygen.read(&mut c_keys); - assert_eq!(s_keys[..], c_keys[..100]); + let c_keys = c_keygen.expand(72)?; + let s_keys = s_keygen.expand(72)?; + assert_eq!(c_keys, s_keys); + + Ok(()) } // Same as previous test, but use the higher-level APIs instead. #[test] -fn test_obfs4_roundtrip_highlevel() { - let mut rng = rand::thread_rng(); - let relay_private = Obfs4NtorSecretKey::generate_for_test(&mut testing_rng()); +fn test_o5_roundtrip_highlevel() -> Result<()> { + let rng = testing_rng(); + let relay_secret = StaticSecret::random_from_rng(rng); + let relay_public = PublicKey::from(&relay_secret); + let relay_identity = RsaIdentity::from_bytes(&[12; 20]).unwrap(); + let relay_ntpk = O5NtorPublicKey { + id: relay_identity, + pk: relay_public, + }; + let hs_materials = CHSMaterials::new(relay_ntpk, "c-xxx".into()); + let (state, cmsg) = O5NtorHandshake::client1(&hs_materials, &())?; - let (c_state, c_handshake) = - Obfs4NtorClient::client1(&mut rng, &relay_private.pk, &[]).unwrap(); + let relay_ntsk = O5NtorSecretKey { + pk: relay_ntpk, + sk: relay_secret, + }; + let server = Server::new_from_key(relay_ntsk.clone()); + let shs_materials = [SHSMaterials::new( + &relay_ntsk, + "s-yyy".into(), + [0u8; SEED_LENGTH], + )]; - let mut rep = |_: &[NtorV3Extension]| Some(vec![]); + let (skeygen, smsg) = server + .server(&mut |_: &()| Some(()), &shs_materials, &cmsg) + .unwrap(); - let (s_keygen, s_handshake) = - Obfs4NtorServer::server(&mut rng, &mut rep, &[relay_private], &c_handshake).unwrap(); + let (_extensions, ckeygen) = O5NtorHandshake::client2(state, smsg)?; - let (extensions, keygen) = Obfs4NtorClient::client2(c_state, s_handshake).unwrap(); + let skeys = skeygen.expand(55)?; + let ckeys = ckeygen.expand(55)?; - assert!(extensions.is_empty()); - let c_keys = keygen.expand(1000).unwrap(); - let s_keys = s_keygen.expand(100).unwrap(); - assert_eq!(s_keys[..], c_keys[..100]); + assert_eq!(skeys, ckeys); + + Ok(()) } -// Same as previous test, but encode some congestion control extensions. #[test] -fn test_obfs4_roundtrip_highlevel_cc() { - let mut rng = rand::thread_rng(); - let relay_private = Obfs4NtorSecretKey::generate_for_test(&mut testing_rng()); +fn test_o5_testvec_compat() -> Result<()> { + init_subscriber(); + let b_sk = hex!("a83fdd04eb9ed77a2b38d86092a09a1cecfb93a7bdec0da35e542775b2e7af6e"); + let x_sk = hex!("308ff4f3a0ebe8c1a93bcd40d67e3eec6b856aa5c07ef6d5a3d3cedf13dcf150"); + let y_sk = hex!("881f9ad60e0833a627f0c47f5aafbdcb0b5471800eaeaa1e678291b947e4295c"); + let id = hex!("000102030405060708090a0b0c0d0e0f10111213"); + let expected_seed = "05b858d18df21a01566c74d39a5b091b4415f103c05851e77e79b274132dc5b5"; + let expected_auth = "dc71f8ded2e56f829f1b944c1e94357fa8b7987f10211a017e2d1f2455092917"; + + let sk: StaticSecret = b_sk.into(); + let pk = O5NtorPublicKey { + id: RsaIdentity::from_bytes(&id).unwrap(), + pk: (&sk).into(), + }; + let relay_sk = O5NtorSecretKey { pk, sk }; + let server = Server::new_from_key(relay_sk.clone()); - let client_exts = vec![NtorV3Extension::RequestCongestionControl]; - let reply_exts = vec![NtorV3Extension::AckCongestionControl { sendme_inc: 42 }]; + let x: StaticSecret = x_sk.into(); - let (c_state, c_handshake) = Obfs4NtorClient::client1( - &mut rng, - &relay_private.pk, - &[NtorV3Extension::RequestCongestionControl], - ) - .unwrap(); + let chs_materials = CHSMaterials::new(pk, "c-xxx".into()); - let mut rep = |msg: &[NtorV3Extension]| -> Option> { - assert_eq!(msg, client_exts); - Some(reply_exts.clone()) - }; + let shs_materials = + SHSMaterials::new(&server.identity_keys, "s-yyy".into(), [0u8; SEED_LENGTH]); + + let (state, create_msg) = client_handshake_o5_no_keygen(x, chs_materials).unwrap(); - let (s_keygen, s_handshake) = - Obfs4NtorServer::server(&mut rng, &mut rep, &[relay_private], &c_handshake).unwrap(); + let (s_keygen, created_msg) = server + .server_handshake_o5_no_keygen( + make_fake_ephem_key(&y_sk[..]), // convert the StaticSecret to an EphemeralSecret for api to allow from hex + &create_msg[..], + shs_materials, + ) + .unwrap(); - let (extensions, keygen) = Obfs4NtorClient::client2(c_state, s_handshake).unwrap(); + let (c_keygen, auth) = client_handshake2_no_auth_check_o5(created_msg, &state)?; + let seed = c_keygen.seed.clone(); - assert_eq!(extensions, reply_exts); - let c_keys = keygen.expand(1000).unwrap(); - let s_keys = s_keygen.expand(100).unwrap(); - assert_eq!(s_keys[..], c_keys[..100]); + let c_keys = c_keygen.expand(72)?; + let s_keys = s_keygen.expand(72)?; + + assert_eq!(&s_keys[..], &c_keys[..]); + assert_eq!(hex::encode(auth), expected_auth); + assert_eq!(hex::encode(&seed[..]), expected_seed); + + Ok(()) } +#[cfg(target_feature = "disabled")] #[test] -fn test_obfs4_testvec() { - let id = hex!("9fad2af287ef942632833d21f946c6260c33fae6172b60006e86e4a6911753a2"); - let b = hex!("a8649010896d3c05ab0e2ab75e3e9368695c8f72652e8aa73016756007054e59"); // identity key - let x = hex!("f886d140047a115b228a8f7f63cbc5a3ad74e9c970ad3cb4a7f7fd8067f0dd68"); // client session key - let y = hex!("403ec0927a8852bdff12129244fdb03cb3c94b8b8d15c863462fcda52b510d73"); // server session key - let b: curve25519::StaticSecret = b.into(); - let B: curve25519::PublicKey = (&b).into(); - let id: Ed25519Identity = id.into(); - let x: curve25519::StaticSecret = x.into(); - let y: curve25519::StaticSecret = y.into(); - - let client_message = hex!("68656c6c6f20776f726c64"); - let verification = hex!("78797a7a79"); - let server_message = hex!("486f6c61204d756e646f"); - - let identity_public = Obfs4NtorPublicKey { pk: B, id, rp: None }; - let identity_private = Obfs4NtorSecretKey { - sk: b, - pk: identity_public.clone(), +fn test_ntor_v1_testvec() -> Result<()> { + let b_sk = hex!("4820544f4c4420594f5520444f474954204b454550532048415050454e494e47"); + let x_sk = hex!("706f6461792069207075742e2e2e2e2e2e2e2e4a454c4c59206f6e2074686973"); + let y_sk = hex!("70686520737175697272656c2e2e2e2e2e2e2e2e686173206869732067616d65"); + let id = hex!("69546f6c64596f7541626f75745374616972732e"); + let client_handshake = hex!("69546f6c64596f7541626f75745374616972732eccbc8541904d18af08753eae967874749e6149f873de937f57f8fd903a21c471e65dfdbef8b2635837fe2cebc086a8096eae3213e6830dc407516083d412b078"); + let server_handshake = hex!("390480a14362761d6aec1fea840f6e9e928fb2adb7b25c670be1045e35133a371cbdf68b89923e1f85e8e18ee6e805ea333fe4849c790ffd2670bd80fec95cc8"); + let keys = hex!("0c62dee7f48893370d0ef896758d35729867beef1a5121df80e00f79ed349af39b51cae125719182f19d932a667dae1afbf2e336e6910e7822223e763afad0a13342157969dc6b79"); + + let sk: StaticSecret = b_sk.into(); + let pk = O5NtorPublicKey { + id: RsaIdentity::from_bytes(&id).unwrap(), + pk: (&sk).into(), + rp: (&sk).into(), }; + let relay_sk = O5NtorSecretKey { pk, sk }; - let (state, client_handshake) = - client_handshake_obfs4_no_keygen(&identity_public, &client_message, &verification, x) - .unwrap(); + let x: StaticSecret = x_sk.into(); + let y: StaticSecret = y_sk.into(); - // assert_eq!(client_handshake[..], hex!("9fad2af287ef942632833d21f946c6260c33fae6172b60006e86e4a6911753a2f8307a2bc1870b00b828bb74dbb8fd88e632a6375ab3bcd1ae706aaa8b6cdd1d252fe9ae91264c91d4ecb8501f79d0387e34ad8ca0f7c995184f7d11d5da4f463bebd9151fd3b47c180abc9e044d53565f04d82bbb3bebed3d06cea65db8be9c72b68cd461942088502f67")[..]); + let (state, create_msg) = + client_handshake_o5_no_keygen((&x).into(), x, &relay_sk.pk).unwrap(); + assert_eq!(&create_msg[..], &client_handshake[..]); - struct Replier(Vec, Vec, bool); - impl MsgReply for Replier { - fn reply(&mut self, msg: &[u8]) -> Option> { - assert_eq!(msg, &self.0); - self.2 = true; - Some(self.1.clone()) - } - } - let mut rep = Replier(client_message.to_vec(), server_message.to_vec(), false); - - let (server_handshake, mut server_keygen) = server_handshake_obfs4_no_keygen( - &mut rep, - &y, - &client_handshake, - &[identity_private], - &verification, + let (s_keygen, created_msg) = server_handshake_o5_no_keygen( + (&y).into(), + make_fake_ephem_key(&y_sk[..]), // convert the StaticSecret to an EphemeralSecret for api to allow from hex + &create_msg[..], + &[relay_sk], ) .unwrap(); - assert!(rep.2); - // assert_eq!(server_handshake[..], hex!("4bf4814326fdab45ad5184f5518bd7fae25dc59374062698201a50a22954246d2fc5f8773ca824542bc6cf6f57c7c29bbf4e5476461ab130c5b18ab0a91276651202c3e1e87c0d32054c")[..]); + assert_eq!(&created_msg[..], &server_handshake[..]); + + let c_keygen = client_handshake2_o5(created_msg, &state)?; + + let c_keys = c_keygen.expand(keys.len())?; + let s_keys = s_keygen.expand(keys.len())?; + assert_eq!(&c_keys[..], &keys[..]); + assert_eq!(&s_keys[..], &keys[..]); + + Ok(()) +} - let (server_msg_received, mut client_keygen) = - client_handshake_obfs4_part2(&state, &server_handshake, &verification).unwrap(); - assert_eq!(&server_msg_received, &server_message); +#[test] +fn failing_handshakes() { + let mut rng = testing_rng(); + + // Set up keys. + let relay_secret = StaticSecret::random_from_rng(&mut rng); + let relay_public = PublicKey::from(&relay_secret); + let wrong_public = PublicKey::from([16_u8; 32]); + let relay_identity = RsaIdentity::from_bytes(&[12; 20]).unwrap(); + let wrong_identity = RsaIdentity::from_bytes(&[13; 20]).unwrap(); + let relay_ntpk = O5NtorPublicKey { + id: relay_identity, + pk: relay_public, + }; + let relay_ntsk = O5NtorSecretKey { + pk: relay_ntpk.clone(), + sk: relay_secret, + }; - let (c_keys, s_keys) = { - let mut c = [0_u8; 256]; - let mut s = [0_u8; 256]; - client_keygen.read(&mut c); - server_keygen.read(&mut s); - (c, s) + let wrong_ntpk1 = O5NtorPublicKey { + id: wrong_identity, + pk: relay_public, }; - assert_eq!(c_keys, s_keys); - assert_eq!(c_keys[..], hex!("05b858d18df21a01566c74d39a5b091b4415f103c05851e77e79b274132dc5b5")[..]); - // assert_eq!(c_keys[..], hex!("9c19b631fd94ed86a817e01f6c80b0743a43f5faebd39cfaa8b00fa8bcc65c3bfeaa403d91acbd68a821bf6ee8504602b094a254392a07737d5662768c7a9fb1b2814bb34780eaee6e867c773e28c212ead563e98a1cd5d5b4576f5ee61c59bde025ff2851bb19b721421694f263818e3531e43a9e4e3e2c661e2ad547d8984caa28ebecd3e4525452299be26b9185a20a90ce1eac20a91f2832d731b54502b09749b5a2a2949292f8cfcbeffb790c7790ed935a9d251e7e336148ea83b063a5618fcff674a44581585fd22077ca0e52c59a24347a38d1a1ceebddbf238541f226b8f88d0fb9c07a1bcd2ea764bbbb5dacdaf5312a14c0b9e4f06309b0333b4a")[..]); + let wrong_ntpk2 = O5NtorPublicKey { + id: relay_identity, + pk: wrong_public, + }; + + let resources = &Server::new_from_random(&mut rng); + + // If the client uses the wrong keys, the relay should reject the + // handshake. + let mut hs_materials = CHSMaterials::new(wrong_ntpk1.clone(), "c-xxx".into()); + let (_, handshake1) = O5NtorHandshake::client1(&hs_materials, &()).unwrap(); + hs_materials.node_pubkey = wrong_ntpk2; + let (_, handshake2) = O5NtorHandshake::client1(&hs_materials, &()).unwrap(); + hs_materials.node_pubkey = relay_ntpk; + let (st3, handshake3) = O5NtorHandshake::client1(&hs_materials, &()).unwrap(); + + let shs_materials = [SHSMaterials::new( + &relay_ntsk, + "s-yyy".into(), + [0u8; SEED_LENGTH], + )]; + let ans1 = resources.server(&mut |_: &()| Some(()), &shs_materials, &handshake1); + let ans2 = resources.server(&mut |_: &()| Some(()), &shs_materials, &handshake2); + + assert!(ans1.is_err()); + assert!(ans2.is_err()); + + // If the relay's message is tampered with, the client will + // reject the handshake. + let (_, mut smsg) = resources + .server(&mut |_: &()| Some(()), &shs_materials, &handshake3) + .unwrap(); + smsg[60] ^= 7; + let ans3 = O5NtorHandshake::client2(st3, smsg); + assert!(ans3.is_err()); } #[test] @@ -194,9 +267,8 @@ fn about_half() -> Result<()> { let mut not_found = 0; let mut not_match = 0; for _ in 0..1_000 { - let sk = curve25519::StaticSecret::random_from_rng(&mut rng); - let rp: Option= (&sk).into(); + let rp: Option = (&sk).into(); let repres = match rp { Some(r) => r, None => { @@ -207,7 +279,6 @@ fn about_half() -> Result<()> { let pk = curve25519::PublicKey::from(&sk); - let decoded_pk = curve25519::PublicKey::from(&repres); if hex::encode(pk) != hex::encode(decoded_pk) { not_match += 1; @@ -229,10 +300,10 @@ fn about_half() -> Result<()> { fn keypair() -> Result<()> { let mut rng = rand::thread_rng(); for _ in 0..1_000 { - let kp = Obfs4NtorSecretKey::generate_for_test(&mut rng); + let kp = O5NtorSecretKey::generate_for_test(&mut rng); let pk = kp.pk.pk.to_bytes(); - let repres = kp.pk.rp; + let repres: Option = (&kp.sk).into(); let pubkey = curve25519::PublicKey::from(&repres.unwrap()); assert_eq!(hex::encode(pk), hex::encode(pubkey.to_bytes())); @@ -240,7 +311,6 @@ fn keypair() -> Result<()> { Ok(()) } - /* // Benchmark Client/Server handshake. The actual time taken that will be // observed on either the Client or Server is half the reported time per diff --git a/crates/o5/src/handshake/kyber.rs b/crates/o5/src/handshake/kyber.rs new file mode 100644 index 0000000..080dfbd --- /dev/null +++ b/crates/o5/src/handshake/kyber.rs @@ -0,0 +1,355 @@ +//! ## KyberX25519 Ntor Handshake +//! +//! ### As Described in draft-tls-westerbaan-xyber768d00-03 +//! +//! ``` +//! 3. Construction +//! +//! We instantiate draft-ietf-tls-hybrid-design-06 with X25519 [rfc7748] +//! and Kyber768Draft00 [kyber]. The latter is Kyber as submitted to +//! round 3 of the NIST PQC process [KyberV302]. +//! +//! For the client's share, the key_exchange value contains the +//! concatenation of the client's X25519 ephemeral share (32 bytes) and +//! the client's Kyber768Draft00 public key (1184 bytes). The resulting +//! key_exchange value is 1216 bytes in length. +//! +//! For the server's share, the key_exchange value contains the +//! concatenation of the server's X25519 ephemeral share (32 bytes) and +//! the Kyber768Draft00 ciphertext (1088 bytes) returned from +//! encapsulation for the client's public key. The resulting +//! key_exchange value is 1120 bytes in length. +//! +//! The shared secret is calculated as the concatenation of the X25519 +//! shared secret (32 bytes) and the Kyber768Draft00 shared secret (32 +//! bytes). The resulting shared secret value is 64 bytes in length. +//! +//! 4. Security Considerations +//! +//! For TLS 1.3, this concatenation approach provides a secure key +//! exchange if either component key exchange methods (X25519 or +//! Kyber768Draft00) are secure [hybrid]. +//! ``` + +use crate::{ + common::ntor::{ + derive_ntor_shared, Auth, HandshakeResult, IdentityKeyPair, KeySeed, NtorError, PublicKey, + SessionKeyPair, ID, + }, + Error, Result, +}; + +use bytes::BytesMut; +use pqc_kyber::*; +use subtle::{Choice, ConstantTimeEq, CtOption}; + +use super::{AUTH_LENGTH, KEY_SEED_LENGTH}; + +const _ZERO_EXP: [u8; 32] = [0_u8; 32]; +const X25519_PUBKEY_LEN: usize = 32; +pub const KYBERX_PUBKEY_LEN: usize = KYBER_PUBLICKEYBYTES + X25519_PUBKEY_LEN; + +pub struct KyberXPublicKey { + pub kyber: pqc_kyber::PublicKey, + pub x25519: PublicKey, + contiguous: [u8; KYBERX_PUBKEY_LEN], +} + +impl KyberXPublicKey { + pub fn from_parts(x25519: PublicKey, kyber: pqc_kyber::PublicKey) -> Self { + let mut contiguous = [0_u8; KYBERX_PUBKEY_LEN]; + contiguous[..X25519_PUBKEY_LEN].copy_from_slice(&x25519.to_bytes()); + contiguous[X25519_PUBKEY_LEN..].copy_from_slice(&kyber); + + KyberXPublicKey { + kyber, + x25519, + contiguous, + } + } + + pub fn from_bytes(bytes: impl AsRef<[u8]>) -> std::result::Result { + let value = bytes.as_ref(); + if value.len() != KYBERX_PUBKEY_LEN { + return Err(NtorError::ParseError(String::from( + "failed to parse kyberx25519 public key, incorrect length", + ))); + } + + let mut x25519 = [0_u8; X25519_PUBKEY_LEN]; + x25519[..].copy_from_slice(&value[..X25519_PUBKEY_LEN]); + + let mut kyber = [0_u8; KYBER_PUBLICKEYBYTES]; + kyber[..].copy_from_slice(&value[X25519_PUBKEY_LEN..]); + + let mut contiguous = [0_u8; KYBERX_PUBKEY_LEN]; + contiguous[..].copy_from_slice(&value); + + Ok(KyberXPublicKey { + x25519: PublicKey::from(x25519), + kyber, + contiguous, + }) + } +} + +impl From<&KyberXSessionKeys> for KyberXPublicKey { + fn from(value: &KyberXSessionKeys) -> Self { + value.get_public() + } +} + +impl From<&KyberXIdentityKeys> for KyberXPublicKey { + fn from(value: &KyberXIdentityKeys) -> Self { + value.get_public() + } +} + +impl AsRef<[u8]> for KyberXPublicKey { + fn as_ref(&self) -> &[u8] { + &self.contiguous + } +} + +pub struct KyberXSessionKeys { + pub kyber: pqc_kyber::Keypair, + pub x25519: SessionKeyPair, +} + +impl KyberXSessionKeys { + fn new() -> Self { + let mut rng = rand::thread_rng(); + + KyberXSessionKeys { + x25519: SessionKeyPair::new(true), + kyber: pqc_kyber::keypair(&mut rng).expect("kyber key generation failed"), + } + } + + pub fn from_random(rng: &mut R) -> Self { + KyberXSessionKeys { + x25519: SessionKeyPair::new(true), + kyber: pqc_kyber::keypair(rng).expect("kyber key generation failed"), + } + } + + /// Allow downgrade of key pair to x25519 only. + pub fn to_x25519(self) -> SessionKeyPair { + self.x25519 + } + + pub fn get_public(&self) -> KyberXPublicKey { + let mut contiguous = [0_u8; KYBERX_PUBKEY_LEN]; + contiguous[..X25519_PUBKEY_LEN].copy_from_slice(&self.x25519.public.to_bytes()); + contiguous[X25519_PUBKEY_LEN..].copy_from_slice(&self.kyber.public); + + KyberXPublicKey { + kyber: self.kyber.public, + x25519: self.x25519.public, + contiguous, + } + } +} + +pub struct KyberXIdentityKeys { + pub kyber: pqc_kyber::Keypair, + pub x25519: IdentityKeyPair, +} + +impl KyberXIdentityKeys { + fn new() -> Self { + let mut rng = rand::thread_rng(); + + KyberXIdentityKeys { + x25519: IdentityKeyPair::new(), + kyber: pqc_kyber::keypair(&mut rng).expect("kyber key generation failed"), + } + } + + fn from_random(rng: &mut R) -> Self { + KyberXIdentityKeys { + x25519: IdentityKeyPair::new(), + kyber: pqc_kyber::keypair(rng).expect("kyber key generation failed"), + } + } + + /// Allow downgrade of key pair to x25519 only. + pub fn to_x25519(self) -> IdentityKeyPair { + self.x25519 + } + + pub fn get_public(&self) -> KyberXPublicKey { + let mut contiguous = [0_u8; KYBERX_PUBKEY_LEN]; + contiguous[..X25519_PUBKEY_LEN].copy_from_slice(&self.x25519.public.to_bytes()); + contiguous[X25519_PUBKEY_LEN..].copy_from_slice(&self.kyber.public); + + KyberXPublicKey { + kyber: self.kyber.public, + x25519: self.x25519.public, + contiguous, + } + } +} + +/// The client side uses the ntor derived shared secret based on the secret +/// input created by appending the shared secret derived between the client's +/// session keys and the server's sessions keys with the shared secret derived +/// between the clients session keys and the server's identity keys. +/// +/// secret input = X25519(Y, x) | Kyber(Y, x) | X25519(B, x) | Kyber(B, x) +pub fn client_handshake( + client_keys: &KyberXSessionKeys, + server_public: &KyberXPublicKey, + id_public: &KyberXPublicKey, + id: &ID, +) -> subtle::CtOption { + let mut not_ok = 0; + let mut secret_input: Vec = vec![]; + + // EXP(Y,x) + let exp = client_keys + .x25519 + .private + .diffie_hellman(&server_public.x25519); + + not_ok |= _ZERO_EXP[..].ct_eq(exp.as_bytes()).unwrap_u8(); + secret_input.append(&mut exp.as_bytes().to_vec()); + + // EXP(B,x) + let exp = client_keys.x25519.private.diffie_hellman(&id_public.x25519); + not_ok |= _ZERO_EXP[..].ct_eq(exp.as_bytes()).unwrap_u8(); + secret_input.append(&mut exp.as_bytes().to_vec()); + + let (key_seed, auth) = derive_ntor_shared( + secret_input, + id, + id_public, + &client_keys.get_public(), + server_public, + ); + + // failed if not_ok != 0 + // if not_ok != 0 then scalar operations failed + subtle::CtOption::new(HandshakeResult { key_seed, auth }, not_ok.ct_eq(&0_u8)) +} + +/// The server side uses the ntor derived shared secret based on the secret +/// input created by appending the shared secret derived between the server's +/// session keys and the client's sessions keys with the shared secret derived +/// between the server's identity keys and the clients session keys. +/// +/// secret input = X25519(X, y) | Kyber(X, y) | X25519(X, b) | Kyber(X, b) +pub fn server_handshake( + server_keys: &KyberXSessionKeys, + client_public: &KyberXPublicKey, + id_keys: &KyberXIdentityKeys, + id: &ID, +) -> subtle::CtOption { + let mut not_ok = 0; + let mut secret_input: Vec = vec![]; + + // EXP(X,y) + let exp = server_keys + .x25519 + .private + .diffie_hellman(&client_public.x25519); + not_ok |= _ZERO_EXP[..].ct_eq(exp.as_bytes()).unwrap_u8(); + secret_input.append(&mut exp.as_bytes().to_vec()); + + // EXP(X,b) + let exp = id_keys.x25519.private.diffie_hellman(&client_public.x25519); + not_ok |= _ZERO_EXP[..].ct_eq(exp.as_bytes()).unwrap_u8(); + secret_input.append(&mut exp.as_bytes().to_vec()); + + let (key_seed, auth) = derive_ntor_shared( + secret_input, + id, + &id_keys.get_public(), + client_public, + &server_keys.get_public(), + ); + + // failed if not_ok != 0 + // if not_ok != 0 then scalar operations failed + subtle::CtOption::new(HandshakeResult { key_seed, auth }, not_ok.ct_eq(&0_u8)) +} + +#[cfg(test)] +#[allow(unused)] +mod tests { + use crate::common::ntor::compare_auth; + + use super::*; + use x25519_dalek::EphemeralSecret; + + #[test] + fn kyberx25519_handshake_flow() { + // long-term server id and keys + let server_id_keys = KyberXIdentityKeys::new(); + let server_id_pub = server_id_keys.get_public(); + let server_id = ID::new(); + + // client open session, generating the associated ephemeral keys + let client_session = KyberXSessionKeys::new(); + + // client sends kyber25519 session pubkey(s) + let cpk = client_session.get_public(); + + // server computes kyberx25519 combined shared secret + let server_session = KyberXSessionKeys::new(); + let server_hs_res = server_handshake(&server_session, &cpk, &server_id_keys, &server_id); + + // server sends kyberx25519 session pubkey(s) + let spk = client_session.get_public(); + + // client computes kyberx25519 combined shared secret + let client_hs_res = client_handshake(&client_session, &spk, &server_id_pub, &server_id); + + assert_ne!(client_hs_res.is_some().unwrap_u8(), 0); + assert_ne!(server_hs_res.is_some().unwrap_u8(), 0); + + let chsres = client_hs_res.unwrap(); + let shsres = server_hs_res.unwrap(); + assert_eq!(chsres.key_seed, shsres.key_seed); + assert_eq!(&chsres.auth, &shsres.auth); + } + + #[test] + fn kyber_handshake_supplement_flow() { + // long-term server id and keys + let server_id_keys = KyberXIdentityKeys::new(); + let server_id_pub = server_id_keys.get_public(); + let server_id = ID::new(); + + // client open session, generating the associated ephemeral keys + let client_session = KyberXSessionKeys::new(); + + // client sends ed25519 session pubkey elligator2 encoded and includes + // session Kyber1024Supplement CryptoOffer. + let c_ed_pk = client_session.x25519.public; + let c_ky_pk = client_session.kyber.public; + let cpk = KyberXPublicKey::from_parts(c_ed_pk, c_ky_pk); + + // server computes KyberX25519 combined shared secret + let server_session = KyberXSessionKeys::new(); + let server_hs_res = server_handshake(&server_session, &cpk, &server_id_keys, &server_id); + + // server sends ed25519 session pubkey elligator2 encoded and includes + // session Kyber1024Supplement CryptoAccept. + let s_ed_pk = client_session.x25519.public; + let s_ky_pk = client_session.kyber.public; + let spk = KyberXPublicKey::from_parts(c_ed_pk, c_ky_pk); + + // client computes KyberX25519 combined shared secret + let client_hs_res = client_handshake(&client_session, &spk, &server_id_pub, &server_id); + + assert_ne!(client_hs_res.is_some().unwrap_u8(), 0); + assert_ne!(server_hs_res.is_some().unwrap_u8(), 0); + + let chsres = client_hs_res.unwrap(); + let shsres = server_hs_res.unwrap(); + assert_eq!(chsres.key_seed, shsres.key_seed); + assert_eq!(&chsres.auth, &shsres.auth); + } +} + diff --git a/crates/o5/src/handshake/mod.rs b/crates/o5/src/handshake/mod.rs index 316b7b4..3eddb59 100644 --- a/crates/o5/src/handshake/mod.rs +++ b/crates/o5/src/handshake/mod.rs @@ -5,35 +5,57 @@ //! encrypt data (without forward secrecy) after it sends the first //! message. -// TODO: -// Remove the "allow" item for dead_code. -// Make terminology and variable names consistent with spec. +use crate::{ + common::{ + ct, + curve25519::{Representable, StaticSecret}, + ntor_arti::{ + AuxDataReply, ClientHandshake, KeyGenerator, RelayHandshakeError, RelayHandshakeResult, + ServerHandshake, + }, + }, + constants::*, + framing::{O5Codec, KEY_MATERIAL_LENGTH}, + Error, Result, Server, +}; -// This module is still unused: so allow some dead code for now. -#![allow(dead_code)] - -use std::borrow::Borrow; - -use crate::common::ntor_arti::{KeyGenerator, RelayHandshakeError, RelayHandshakeResult}; -use crate::common::ct; -use crate::common::curve25519; -use crate::{Error, Result}; use tor_bytes::{EncodeResult, Reader, SecretBuf, Writeable, Writer}; use tor_error::into_internal; -use tor_llcrypto::d::{Sha256, Shake256, Shake256Reader}; -use tor_llcrypto::pk::ed25519::Ed25519Identity; +use tor_llcrypto::d::{Sha3_256, Shake256, Shake256Reader}; +use tor_llcrypto::pk::{curve25519, ed25519::Ed25519Identity}; use tor_llcrypto::util::ct::ct_lookup; use cipher::{KeyIvInit, StreamCipher}; +#[cfg(test)] use rand_core::{CryptoRng, RngCore}; + use subtle::{Choice, ConstantTimeEq}; use tor_cell::relaycell::extend::NtorV3Extension; use tor_llcrypto::cipher::aes::Aes256Ctr; use zeroize::Zeroizing; +use std::borrow::Borrow; + +mod handshake_client; +// mod handshake_server; +mod utils; + +pub(crate) mod kyber; + +pub(crate) use utils::*; + +pub(crate) use handshake_client::HandshakeMaterials as CHSMaterials; +#[cfg(test)] +pub(crate) use handshake_client::{ + client_handshake2_no_auth_check_o5, client_handshake_o5_no_keygen, +}; + +use handshake_client::{client_handshake2_o5, client_handshake_o5, O5NtorHandshakeState}; +pub(crate) use handshake_server::HandshakeMaterials as SHSMaterials; + /// The verification string to be used for circuit extension. -const OBFS4_CIRC_VERIFICATION: &[u8] = b"circuit extend"; +const NTOR3_CIRC_VERIFICATION: &[u8] = b"circuit extend"; /// The size of an encryption key in bytes. const ENC_KEY_LEN: usize = 32; @@ -48,21 +70,25 @@ const MAC_LEN: usize = 32; /// The length of a node identity in bytes. const ID_LEN: usize = 32; +/// Alias for an HMAC output, used to validate correctness of a handshake. +pub(crate) type Authcode = [u8; 32]; +pub(crate) const AUTHCODE_LENGTH: usize = 32; + /// The output of the digest, as an array. type DigestVal = [u8; DIGEST_LEN]; /// The output of the MAC. type MacVal = [u8; MAC_LEN]; /// A key for symmetric encryption or decryption. // -// TODO (nickm): Any move operations applied to this key could subvert the zeroizing. +// TODO: Any move operations applied to this key could subvert the zeroizing. type EncKey = Zeroizing<[u8; ENC_KEY_LEN]>; /// A key for message authentication codes. type MacKey = [u8; MAC_KEY_LEN]; -/// Opaque wrapper type for Obfs4Ntor's hash reader. -struct Obfs4NtorXofReader(Shake256Reader); +/// Opaque wrapper type for NtorV3's hash reader. +struct NtorV3XofReader(Shake256Reader); -impl digest::XofReader for Obfs4NtorXofReader { +impl digest::XofReader for NtorV3XofReader { fn read(&mut self, buffer: &mut [u8]) { self.0.read(buffer); } @@ -88,7 +114,6 @@ impl<'a> Encap<'a> { } /// Return the underlying data fn data(&self) -> &'a [u8] { - self.0 } } @@ -110,16 +135,6 @@ macro_rules! define_tweaks { } define_tweaks! { - - pub(crate) const PROTO_ID: &[u8; 24] = b"ntor-curve25519-sha256-1"; - - pub(crate) const T_MAC: &[u8; 28] = b"ntor-curve25519-sha256-1:mac"; - - pub(crate) const T_VERIFY: &[u8; 35] = b"ntor-curve25519-sha256-1:key_verify"; - - pub(crate) const T_KEY: &[u8; 36] = b"ntor-curve25519-sha256-1:key_extract"; - - /// Protocol ID: concatenated with other things in the protocol to /// prevent hash confusion. PROTOID = "ntor3-curve25519-sha3_256-1"; @@ -145,7 +160,7 @@ define_tweaks! { /// Compute a tweaked hash. fn hash(t: &Encap<'_>, data: &[u8]) -> DigestVal { use digest::Digest; - let mut d = Sha256::new(); + let mut d = Sha3_256::new(); d.update((t.len() as u64).to_be_bytes()); d.update(t.data()); d.update(data); @@ -200,20 +215,20 @@ fn h_verify(d: &[u8]) -> DigestVal { /// the client's public key (B), and the shared verification string. fn kdf_msgkdf( xb: &curve25519::SharedSecret, - relay_public: &Obfs4NtorPublicKey, + relay_public: &O5NtorPublicKey, client_public: &curve25519::PublicKey, verification: &[u8], -) -> EncodeResult<(EncKey, DigestWriter)> { +) -> EncodeResult<(EncKey, DigestWriter)> { // secret_input_phase1 = Bx | ID | X | B | PROTOID | ENCAP(VER) // phase1_keys = KDF_msgkdf(secret_input_phase1) // (ENC_K1, MAC_K1) = PARTITION(phase1_keys, ENC_KEY_LEN, MAC_KEY_LEN use digest::{ExtendableOutput, XofReader}; let mut msg_kdf = DigestWriter(Shake256::default()); msg_kdf.write(&T_MSGKDF)?; - msg_kdf.write(xb.as_bytes())?; - msg_kdf.write(&relay_public.id)?; - msg_kdf.write(client_public.as_bytes())?; - msg_kdf.write(&relay_public.pk.as_bytes())?; + msg_kdf.write(xb)?; + msg_kdf.write(&materials.node_pubkey.id)?; + msg_kdf.write(client_public)?; + msg_kdf.write(&materials.node_pubkey.pk)?; msg_kdf.write(PROTOID)?; msg_kdf.write(&Encap(verification))?; let mut r = msg_kdf.take().finalize_xof(); @@ -222,25 +237,25 @@ fn kdf_msgkdf( r.read(&mut enc_key[..]); r.read(&mut mac_key[..]); - let mut mac = DigestWriter(Sha256::default()); + let mut mac = DigestWriter(Sha3_256::default()); { mac.write(&T_MSGMAC)?; mac.write(&Encap(&mac_key[..]))?; - mac.write(&relay_public.id)?; - mac.write(&relay_public.pk.as_bytes())?; - mac.write(client_public.as_bytes())?; + mac.write(&materials.node_pubkey.id)?; + mac.write(&materials.node_pubkey.pk)?; + mac.write(client_public)?; } Ok((enc_key, mac)) } /// Client side of the ntor v3 handshake. -pub(crate) struct Obfs4NtorClient; +pub(crate) struct O5Client; -impl crate::common::ntor_arti::ClientHandshake for Obfs4NtorClient { - type KeyType = Obfs4NtorPublicKey; - type StateType = Obfs4NtorHandshakeState; - type KeyGen = Obfs4NtorKeyGenerator; +impl ClientHandshake for O5Client { + type KeyType = O5NtorPublicKey; + type StateType = O5NtorHandshakeState; + type KeyGen = O5NtorKeyGenerator; type ClientAuxData = [NtorV3Extension]; type ServerAuxData = Vec; @@ -249,17 +264,17 @@ impl crate::common::ntor_arti::ClientHandshake for Obfs4NtorClient { /// /// On success, return a state object that will be used to complete the handshake, along /// with the message to send. - fn client1>( - rng: &mut R, - key: &Obfs4NtorPublicKey, - extensions: &M, + fn client1>( + key: &Self::KeyType, + client_aux_data: &M, ) -> Result<(Self::StateType, Vec)> { let mut message = Vec::new(); - NtorV3Extension::write_many_onto(extensions.borrow(), &mut message) - .map_err(|e| Error::from_bytes_enc(e, "ntor3 handshake extensions"))?; + // // TODO: Add extensions back in + // NtorV3Extension::write_many_onto(extensions.borrow(), &mut message) + // .map_err(|e| Error::from_bytes_enc(e, "ntor3 handshake extensions"))?; Ok( - client_handshake_obfs4(rng, key, &message, OBFS4_CIRC_VERIFICATION) - .map_err(into_internal!("Can't encode obfs4 client handshake."))?, + client_handshake_o5(key, &message, NTOR3_CIRC_VERIFICATION) + .map_err(into_internal!("Can't encode ntor3 client handshake."))?, ) } @@ -270,30 +285,30 @@ impl crate::common::ntor_arti::ClientHandshake for Obfs4NtorClient { fn client2>( state: Self::StateType, msg: T, - ) -> Result<(Vec, Self::KeyGen)> { + ) -> Result<(Self::ServerAuxData, Self::KeyGen)> { let (message, xofreader) = - client_handshake_obfs4_part2(&state, msg.as_ref(), OBFS4_CIRC_VERIFICATION)?; + client_handshake_o5_part2(&state, msg.as_ref(), NTOR3_CIRC_VERIFICATION)?; let extensions = NtorV3Extension::decode(&message).map_err(|err| Error::CellDecodeErr { object: "ntor v3 extensions", err, })?; - let keygen = Obfs4NtorKeyGenerator { reader: xofreader }; + let keygen = O5NtorKeyGenerator { reader: xofreader }; Ok((extensions, keygen)) } } /// Server side of the ntor v3 handshake. -pub(crate) struct Obfs4NtorServer; +pub(crate) struct O5Server; -impl crate::common::ntor_arti::ServerHandshake for Obfs4NtorServer { - type KeyType = Obfs4NtorSecretKey; - type KeyGen = Obfs4NtorKeyGenerator; +impl ServerHandshake for O5Server { + type KeyType = O5NtorSecretKey; + type KeyGen = O5NtorKeyGenerator; type ClientAuxData = [NtorV3Extension]; type ServerAuxData = Vec; - fn server, T: AsRef<[u8]>>( - rng: &mut R, + fn server, T: AsRef<[u8]>>( + &self, reply_fn: &mut REPLY, key: &[Self::KeyType], msg: T, @@ -306,14 +321,13 @@ impl crate::common::ntor_arti::ServerHandshake for Obfs4NtorServer { Some(out) }; - let (res, reader) = server_handshake_obfs4( - rng, + let (res, reader) = server_handshake_o5( &mut bytes_reply_fn, msg.as_ref(), key, - OBFS4_CIRC_VERIFICATION, + NTOR3_CIRC_VERIFICATION, )?; - Ok((Obfs4NtorKeyGenerator { reader }, res)) + Ok((O5NtorKeyGenerator { reader }, res)) } } @@ -322,67 +336,47 @@ impl crate::common::ntor_arti::ServerHandshake for Obfs4NtorServer { /// Contains a single curve25519 ntor onion key, and the relay's ed25519 /// identity. #[derive(Clone, Debug)] -pub(crate) struct Obfs4NtorPublicKey { +pub(crate) struct O5NtorPublicKey { /// The relay's identity. pub(crate) id: Ed25519Identity, - /// The Bridge's identity key. + /// The relay's onion key. pub(crate) pk: curve25519::PublicKey, - /// The Elligator2 representative for the public key - pub(crate) rp: Option, } /// Secret key information used by a relay for the ntor v3 handshake. -pub(crate) struct Obfs4NtorSecretKey { +pub(crate) struct O5NtorSecretKey { /// The relay's public key information - pk: Obfs4NtorPublicKey, + pk: O5NtorPublicKey, /// The secret onion key. sk: curve25519::StaticSecret, } -impl Obfs4NtorSecretKey { - /// Construct a new Obfs4NtorSecretKey from its components. +impl O5NtorSecretKey { + /// Construct a new O5NtorSecretKey from its components. #[allow(unused)] pub(crate) fn new( sk: curve25519::StaticSecret, pk: curve25519::PublicKey, - rp: Option, id: Ed25519Identity, ) -> Self { Self { - pk: Obfs4NtorPublicKey { id, pk, rp }, + pk: O5NtorPublicKey { id, pk }, sk, } } /// Generate a key using the given `rng`, suitable for testing. #[cfg(test)] - pub(crate) fn generate_for_test(mut rng: R) -> Self { + pub(crate) fn generate_for_test(rng: &mut R) -> Self { let mut id = [0_u8; 32]; // Random bytes will work for testing, but aren't necessarily actually a valid id. rng.fill_bytes(&mut id); - let mut sk: curve25519::StaticSecret = [0u8;32].into(); - let mut pk1: curve25519::PublicKey = [0u8;32].into(); - let mut rp: Option = None; + let sk = curve25519::StaticSecret::random_from_rng(rng); - for _ in 0..64 { // artificial ceil of 64 so this can't infinite loop - - // approx 50% of keys do not have valid representatives so we just - // iterate until we find a key where it is valid. This should take - // a low number of iteratations and always succeed eventually. - sk = curve25519::StaticSecret::random_from_rng(&mut rng); - rp = (&sk).into(); - if rp.is_none() { - continue - } - pk1 = (&sk).into(); - break - } - - let pk = Obfs4NtorPublicKey { - pk: pk1, + let pk = O5NtorPublicKey { + pk: (&sk).into(), id: id.into(), - rp, }; Self { pk, sk } } @@ -396,31 +390,14 @@ impl Obfs4NtorSecretKey { } } -/// Client state for the ntor v3 handshake. -/// -/// The client needs to hold this state between when it sends its part -/// of the handshake and when it receives the relay's reply. -pub(crate) struct Obfs4NtorHandshakeState { - /// The public key of the relay we're communicating with. - relay_public: Obfs4NtorPublicKey, // B, ID. - /// Our ephemeral secret key for this handshake. - my_sk: curve25519::StaticSecret, // x - /// Our ephemeral public key for this handshake. - my_public: curve25519::PublicKey, // X - - /// The shared secret generated as Bx or Xb. - shared_secret: curve25519::SharedSecret, // Bx - /// The MAC of our original encrypted message. - msg_mac: MacVal, // msg_mac -} - /// A key generator returned from an ntor v3 handshake. -pub(crate) struct Obfs4NtorKeyGenerator { +pub(crate) struct O5NtorKeyGenerator { /// The underlying `digest::XofReader`. - reader: Obfs4NtorXofReader, + reader: NtorV3XofReader, } -impl KeyGenerator for Obfs4NtorKeyGenerator { + +impl KeyGenerator for O5NtorKeyGenerator { fn expand(mut self, keylen: usize) -> Result { use digest::XofReader; let mut ret: SecretBuf = vec![0; keylen].into(); @@ -429,60 +406,6 @@ impl KeyGenerator for Obfs4NtorKeyGenerator { } } -/// Client-side Ntor version 3 handshake, part one. -/// -/// Given a secure `rng`, a relay's public key, a secret message to send, -/// and a shared verification string, generate a new handshake state -/// and a message to send to the relay. -fn client_handshake_obfs4( - rng: &mut R, - relay_public: &Obfs4NtorPublicKey, - client_msg: &[u8], - verification: &[u8], -) -> EncodeResult<(Obfs4NtorHandshakeState, Vec)> { - let my_sk = curve25519::StaticSecret::random_from_rng(rng); - client_handshake_obfs4_no_keygen(relay_public, client_msg, verification, my_sk) -} - -/// As `client_handshake_obfs4`, but don't generate an ephemeral DH -/// key: instead take that key an arguments `my_sk`. -fn client_handshake_obfs4_no_keygen( - relay_public: &Obfs4NtorPublicKey, - client_msg: &[u8], - verification: &[u8], - my_sk: curve25519::StaticSecret, -) -> EncodeResult<(Obfs4NtorHandshakeState, Vec)> { - let my_public = curve25519::PublicKey::from(&my_sk); - let bx = my_sk.diffie_hellman(&relay_public.pk); - - let (enc_key, mut mac) = kdf_msgkdf(&bx, relay_public, &my_public, verification)?; - - //encrypted_msg = ENC(ENC_K1, CM) - // msg_mac = MAC_msgmac(MAC_K1, ID | B | X | encrypted_msg) - let encrypted_msg = encrypt(&enc_key, client_msg); - let msg_mac: DigestVal = { - use digest::Digest; - mac.write(&encrypted_msg)?; - mac.take().finalize().into() - }; - - let mut message = Vec::new(); - message.write(&relay_public.id)?; - message.write(&relay_public.pk.as_bytes())?; - message.write(&my_public.as_bytes())?; - message.write(&encrypted_msg)?; - message.write(&msg_mac)?; - - let state = Obfs4NtorHandshakeState { - relay_public: relay_public.clone(), - my_sk, - my_public, - shared_secret: bx, - msg_mac, - }; - - Ok((state, message)) -} /// Trait for an object that handle and incoming client message and /// return a server's reply. @@ -515,33 +438,30 @@ where /// /// On success, return the server handshake message to send, and an XofReader /// to use in generating circuit keys. -fn server_handshake_obfs4( - rng: &mut RNG, +fn server_handshake_o5( reply_fn: &mut REPLY, message: &[u8], - keys: &[Obfs4NtorSecretKey], + keys: &[O5NtorSecretKey], verification: &[u8], -) -> RelayHandshakeResult<(Vec, Obfs4NtorXofReader)> { +) -> RelayHandshakeResult<(Vec, NtorV3XofReader)> { + let mut rng = rand::thread_rng(); let secret_key_y = curve25519::StaticSecret::random_from_rng(rng); - server_handshake_obfs4_no_keygen(reply_fn, &secret_key_y, message, keys, verification) + server_handshake_o5_no_keygen(reply_fn, &secret_key_y, message, keys, verification) } -/// As `server_handshake_obfs4`, but take a secret key instead of an RNG. -fn server_handshake_obfs4_no_keygen( +/// As `server_handshake_o5`, but take a secret key instead of an RNG. +fn server_handshake_o5_no_keygen( reply_fn: &mut REPLY, secret_key_y: &curve25519::StaticSecret, message: &[u8], - keys: &[Obfs4NtorSecretKey], + keys: &[O5NtorSecretKey], verification: &[u8], -) -> RelayHandshakeResult<(Vec, Obfs4NtorXofReader)> { +) -> RelayHandshakeResult<(Vec, NtorV3XofReader)> { // Decode the message. let mut r = Reader::from_slice(message); let id: Ed25519Identity = r.extract()?; - - let pk_buf: [u8;32] = r.extract()?; - let requested_pk = curve25519::PublicKey::from(pk_buf); - let pk_buf: [u8;32] = r.extract()?; - let client_pk = curve25519::PublicKey::from(pk_buf); + let requested_pk: curve25519::PublicKey = r.extract()?; + let client_pk: curve25519::PublicKey = r.extract()?; let client_msg = if let Some(msg_len) = r.remaining().checked_sub(MAC_LEN) { r.take(msg_len)? } else { @@ -559,7 +479,7 @@ fn server_handshake_obfs4_no_keygen( let xb = keypair.sk.diffie_hellman(&client_pk); let (enc_key, mut mac) = kdf_msgkdf(&xb, &keypair.pk, &client_pk, verification) - .map_err(into_internal!("Can't apply obfs4 kdf."))?; + .map_err(into_internal!("Can't apply ntor3 kdf."))?; // Verify the message we received. let computed_mac: DigestVal = { use digest::Digest; @@ -590,15 +510,15 @@ fn server_handshake_obfs4_no_keygen( let secret_input = { let mut si = SecretBuf::new(); - si.write(&xy.as_bytes()) - .and_then(|_| si.write(&xb.as_bytes())) + si.write(&xy) + .and_then(|_| si.write(&xb)) .and_then(|_| si.write(&keypair.pk.id)) - .and_then(|_| si.write(&keypair.pk.pk.as_bytes())) - .and_then(|_| si.write(&client_pk.as_bytes())) - .and_then(|_| si.write(&y_pk.as_bytes())) + .and_then(|_| si.write(&keypair.pk.pk)) + .and_then(|_| si.write(&client_pk)) + .and_then(|_| si.write(&y_pk)) .and_then(|_| si.write(PROTOID)) .and_then(|_| si.write(&Encap(verification))) - .map_err(into_internal!("can't derive obfs4 secret_input"))?; + .map_err(into_internal!("can't derive ntor3 secret_input"))?; si }; let ntor_key_seed = h_key_seed(&secret_input); @@ -609,7 +529,7 @@ fn server_handshake_obfs4_no_keygen( let mut xof = DigestWriter(Shake256::default()); xof.write(&T_FINAL) .and_then(|_| xof.write(&ntor_key_seed)) - .map_err(into_internal!("can't generate obfs4 xof."))?; + .map_err(into_internal!("can't generate ntor3 xof."))?; let mut r = xof.take().finalize_xof(); let mut enc_key = Zeroizing::new([0_u8; ENC_KEY_LEN]); r.read(&mut enc_key[..]); @@ -618,156 +538,219 @@ fn server_handshake_obfs4_no_keygen( let encrypted_reply = encrypt(&enc_key, &reply); let auth: DigestVal = { use digest::Digest; - let mut auth = DigestWriter(Sha256::default()); + let mut auth = DigestWriter(Sha3_256::default()); auth.write(&T_AUTH) .and_then(|_| auth.write(&verify)) .and_then(|_| auth.write(&keypair.pk.id)) - .and_then(|_| auth.write(&keypair.pk.pk.as_bytes())) - .and_then(|_| auth.write(&y_pk.as_bytes())) - .and_then(|_| auth.write(&client_pk.as_bytes())) + .and_then(|_| auth.write(&keypair.pk.pk)) + .and_then(|_| auth.write(&y_pk)) + .and_then(|_| auth.write(&client_pk)) .and_then(|_| auth.write(&msg_mac)) .and_then(|_| auth.write(&Encap(&encrypted_reply))) .and_then(|_| auth.write(PROTOID)) .and_then(|_| auth.write(&b"Server"[..])) - .map_err(into_internal!("can't derive obfs4 authentication"))?; + .map_err(into_internal!("can't derive ntor3 authentication"))?; auth.take().finalize().into() }; let reply = { let mut reply = Vec::new(); reply - .write(&y_pk.as_bytes()) + .write(&y_pk) .and_then(|_| reply.write(&auth)) .and_then(|_| reply.write(&encrypted_reply)) - .map_err(into_internal!("can't encode obfs4 reply."))?; + .map_err(into_internal!("can't encode ntor3 reply."))?; reply }; if okay.into() { - Ok((reply, Obfs4NtorXofReader(keystream))) + Ok((reply, NtorV3XofReader(keystream))) } else { Err(RelayHandshakeError::BadClientHandshake) } } -/// Finalize the handshake on the client side. -/// -/// Called after we've received a message from the relay: try to -/// complete the handshake and verify its correctness. -/// -/// On success, return the server's reply to our original encrypted message, -/// and an `XofReader` to use in generating circuit keys. -fn client_handshake_obfs4_part2( - state: &Obfs4NtorHandshakeState, - relay_handshake: &[u8], - verification: &[u8], -) -> Result<(Vec, Obfs4NtorXofReader)> { - let mut reader = Reader::from_slice(relay_handshake); - let pk_buf: [u8;32] = reader - .extract() - .map_err(|e| Error::from_bytes_err(e, "v3 ntor handshake"))?; - let y_pk = curve25519::PublicKey::from(pk_buf); - let auth: DigestVal = reader - .extract() - .map_err(|e| Error::from_bytes_err(e, "v3 ntor handshake"))?; - let encrypted_msg = reader.into_rest(); - - // TODO: Some of this code is duplicated from the server handshake code! It - // would be better to factor it out. - let yx = state.my_sk.diffie_hellman(&y_pk); - let secret_input = { - let mut si = SecretBuf::new(); - si.write(&yx.as_bytes()) - .and_then(|_| si.write(&state.shared_secret.as_bytes())) - .and_then(|_| si.write(&state.relay_public.id)) - .and_then(|_| si.write(&state.relay_public.pk.as_bytes())) - .and_then(|_| si.write(&state.my_public.as_bytes())) - .and_then(|_| si.write(&y_pk.as_bytes())) - .and_then(|_| si.write(PROTOID)) - .and_then(|_| si.write(&Encap(verification))) - .map_err(into_internal!("error encoding obfs4 secret_input"))?; - si - }; - let ntor_key_seed = h_key_seed(&secret_input); - let verify = h_verify(&secret_input); - let computed_auth: DigestVal = { - use digest::Digest; - let mut auth = DigestWriter(Sha256::default()); - auth.write(&T_AUTH) - .and_then(|_| auth.write(&verify)) - .and_then(|_| auth.write(&state.relay_public.id)) - .and_then(|_| auth.write(&state.relay_public.pk.as_bytes())) - .and_then(|_| auth.write(&y_pk.as_bytes())) - .and_then(|_| auth.write(&state.my_public.as_bytes())) - .and_then(|_| auth.write(&state.msg_mac)) - .and_then(|_| auth.write(&Encap(encrypted_msg))) - .and_then(|_| auth.write(PROTOID)) - .and_then(|_| auth.write(&b"Server"[..])) - .map_err(into_internal!("error encoding obfs4 authentication input"))?; - auth.take().finalize().into() - }; - let okay = computed_auth.ct_eq(&auth) - & ct::bool_to_choice(yx.was_contributory()) - & ct::bool_to_choice(state.shared_secret.was_contributory()); +#[cfg(test)] +#[allow(non_snake_case)] // to enable variable names matching the spec. +#[allow(clippy::many_single_char_names)] // ibid +mod test { + // @@ begin test lint list maintained by maint/add_warning @@ + #![allow(clippy::bool_assert_comparison)] + #![allow(clippy::clone_on_copy)] + #![allow(clippy::dbg_macro)] + #![allow(clippy::mixed_attributes_style)] + #![allow(clippy::print_stderr)] + #![allow(clippy::print_stdout)] + #![allow(clippy::single_char_pattern)] + #![allow(clippy::unwrap_used)] + #![allow(clippy::unchecked_duration_subtraction)] + #![allow(clippy::useless_vec)] + #![allow(clippy::needless_pass_by_value)] + //! + use super::*; + use hex_literal::hex; + use tor_basic_utils::test_rng::testing_rng; + + #[test] + fn test_ntor3_roundtrip() { + let mut rng = rand::thread_rng(); + let relay_private = O5NtorSecretKey::generate_for_test(&mut testing_rng()); + + let verification = &b"shared secret"[..]; + let client_message = &b"Hello. I am a client. Let's be friends!"[..]; + let relay_message = &b"Greetings, client. I am a robot. Beep boop."[..]; + + let (c_state, c_handshake) = + client_handshake_o5(&relay_private.pk, client_message, verification).unwrap(); + + struct Rep(Vec, Vec); + impl MsgReply for Rep { + fn reply(&mut self, msg: &[u8]) -> Option> { + self.0 = msg.to_vec(); + Some(self.1.clone()) + } + } + let mut rep = Rep(Vec::new(), relay_message.to_vec()); - let (enc_key, keystream) = { - use digest::{ExtendableOutput, XofReader}; - let mut xof = DigestWriter(Shake256::default()); - xof.write(&T_FINAL) - .and_then(|_| xof.write(&ntor_key_seed)) - .map_err(into_internal!("error encoding obfs4 xof input"))?; - let mut r = xof.take().finalize_xof(); - let mut enc_key = Zeroizing::new([0_u8; ENC_KEY_LEN]); - r.read(&mut enc_key[..]); - println!("{}", hex::encode(&enc_key)); - (enc_key, r) - }; - let server_reply = decrypt(&enc_key, encrypted_msg); + let (s_handshake, mut s_keygen) = + server_handshake_o5(&mut rep, &c_handshake, &[relay_private], verification) + .unwrap(); - if okay.into() { - Ok((server_reply, Obfs4NtorXofReader(keystream))) - } else { - Err(Error::BadCircHandshakeAuth) + let (s_msg, mut c_keygen) = + client_handshake_o5_part2(&c_state, &s_handshake, verification).unwrap(); + + assert_eq!(rep.0[..], client_message[..]); + assert_eq!(s_msg[..], relay_message[..]); + use digest::XofReader; + let mut s_keys = [0_u8; 100]; + let mut c_keys = [0_u8; 1000]; + s_keygen.read(&mut s_keys); + c_keygen.read(&mut c_keys); + assert_eq!(s_keys[..], c_keys[..100]); } -} -fn derive_ntor_shared( - secret_input: impl AsRef<[u8]>, - id: &ID, - b: &PublicKey, - x: &PublicKey, - y: &PublicKey, -) -> (KeySeed, Auth) { - let mut key_seed = KeySeed::default(); - let mut auth = Auth::default(); - - let mut message = secret_input.as_ref().to_vec(); - message.append(&mut b.to_bytes().to_vec()); - message.append(&mut x.to_bytes().to_vec()); - message.append(&mut y.to_bytes().to_vec()); - message.append(&mut PROTO_ID.to_vec()); - message.append(&mut id.to_bytes().to_vec()); - - let mut h = HmacSha256::new_from_slice(&T_KEY[..]).unwrap(); - h.update(message.as_ref()); - let tmp: &[u8] = &h.finalize().into_bytes()[..]; - key_seed.0 = tmp.try_into().expect("unable to write key_seed"); - - let mut h = HmacSha256::new_from_slice(&T_VERIFY[..]).unwrap(); - h.update(message.as_ref()); - let mut verify = h.finalize().into_bytes().to_vec(); - - // auth_input = verify | ID | B | Y | X | PROTOID | "Server" - verify.append(&mut message.to_vec()); - verify.append(&mut b"Server".to_vec()); - let mut h = HmacSha256::new_from_slice(&T_MAC[..]).unwrap(); - h.update(verify.as_ref()); - let mut tmp = &h.finalize().into_bytes()[..]; - auth.0 = tmp.try_into().expect("unable to write auth"); - - (key_seed, auth) + // Same as previous test, but use the higher-level APIs instead. + #[test] + fn test_ntor3_roundtrip_highlevel() { + let mut rng = rand::thread_rng(); + let relay_private = O5NtorSecretKey::generate_for_test(&mut testing_rng()); + + let (c_state, c_handshake) = O5Client::client1(&relay_private.pk, &[]).unwrap(); + + let mut rep = |_: &[NtorV3Extension]| Some(vec![]); + + let mut s = O5Server {}; + let (s_keygen, s_handshake) = s.server(&mut rep, &[relay_private], &c_handshake).unwrap(); + + let (extensions, keygen) = O5Client::client2(c_state, s_handshake).unwrap(); + + assert!(extensions.is_empty()); + let c_keys = keygen.expand(1000).unwrap(); + let s_keys = s_keygen.expand(100).unwrap(); + assert_eq!(s_keys[..], c_keys[..100]); + } + + // Same as previous test, but encode some congestion control extensions. + #[test] + fn test_ntor3_roundtrip_highlevel_cc() { + let mut rng = rand::thread_rng(); + let relay_private = O5NtorSecretKey::generate_for_test(&mut testing_rng()); + + let client_exts = vec![NtorV3Extension::RequestCongestionControl]; + let reply_exts = vec![NtorV3Extension::AckCongestionControl { sendme_inc: 42 }]; + + let (c_state, c_handshake) = O5Client::client1( + &relay_private.pk, + &[NtorV3Extension::RequestCongestionControl], + ) + .unwrap(); + + let mut rep = |msg: &[NtorV3Extension]| -> Option> { + assert_eq!(msg, client_exts); + Some(reply_exts.clone()) + }; + + let (s_keygen, s_handshake) = + O5Server::server(&mut rng, &mut rep, &[relay_private], &c_handshake).unwrap(); + + let (extensions, keygen) = O5Client::client2(c_state, s_handshake).unwrap(); + + assert_eq!(extensions, reply_exts); + let c_keys = keygen.expand(1000).unwrap(); + let s_keys = s_keygen.expand(100).unwrap(); + assert_eq!(s_keys[..], c_keys[..100]); + } + + #[test] + fn test_ntor3_testvec() { + let b = hex!("4051daa5921cfa2a1c27b08451324919538e79e788a81b38cbed097a5dff454a"); + let id = hex!("9fad2af287ef942632833d21f946c6260c33fae6172b60006e86e4a6911753a2"); + let x = hex!("b825a3719147bcbe5fb1d0b0fcb9c09e51948048e2e3283d2ab7b45b5ef38b49"); + let y = hex!("4865a5b7689dafd978f529291c7171bc159be076b92186405d13220b80e2a053"); + let b: curve25519::StaticSecret = b.into(); + let B: curve25519::PublicKey = (&b).into(); + let id: Ed25519Identity = id.into(); + let x: curve25519::StaticSecret = x.into(); + //let X = (&x).into(); + let y: curve25519::StaticSecret = y.into(); + + let client_message = hex!("68656c6c6f20776f726c64"); + let verification = hex!("78797a7a79"); + let server_message = hex!("486f6c61204d756e646f"); + + let materials = CHSMaterials{ + node_pubkey: O5NtorPublicKey { pk: B, id }, + }; + let relay_private = O5NtorSecretKey { + sk: b, + pk: materials.node_pubkey.clone(), + }; + + let (state, client_handshake) = + client_handshake_o5_no_keygen(&materials.node_pubkey, &client_message, &verification, x) + .unwrap(); + + assert_eq!(client_handshake[..], hex!("9fad2af287ef942632833d21f946c6260c33fae6172b60006e86e4a6911753a2f8307a2bc1870b00b828bb74dbb8fd88e632a6375ab3bcd1ae706aaa8b6cdd1d252fe9ae91264c91d4ecb8501f79d0387e34ad8ca0f7c995184f7d11d5da4f463bebd9151fd3b47c180abc9e044d53565f04d82bbb3bebed3d06cea65db8be9c72b68cd461942088502f67")[..]); + + struct Replier(Vec, Vec, bool); + impl MsgReply for Replier { + fn reply(&mut self, msg: &[u8]) -> Option> { + assert_eq!(msg, &self.0); + self.2 = true; + Some(self.1.clone()) + } + } + let mut rep = Replier(client_message.to_vec(), server_message.to_vec(), false); + + let (server_handshake, mut server_keygen) = server_handshake_o5_no_keygen( + &mut rep, + &y, + &client_handshake, + &[relay_private], + &verification, + ) + .unwrap(); + assert!(rep.2); + + assert_eq!(server_handshake[..], hex!("4bf4814326fdab45ad5184f5518bd7fae25dc59374062698201a50a22954246d2fc5f8773ca824542bc6cf6f57c7c29bbf4e5476461ab130c5b18ab0a91276651202c3e1e87c0d32054c")[..]); + + let (server_msg_received, mut client_keygen) = + client_handshake_o5_part2(&state, &server_handshake, &verification).unwrap(); + assert_eq!(&server_msg_received, &server_message); + + let (c_keys, s_keys) = { + use digest::XofReader; + let mut c = [0_u8; 256]; + let mut s = [0_u8; 256]; + client_keygen.read(&mut c); + server_keygen.read(&mut s); + (c, s) + }; + assert_eq!(c_keys, s_keys); + assert_eq!(c_keys[..], hex!("9c19b631fd94ed86a817e01f6c80b0743a43f5faebd39cfaa8b00fa8bcc65c3bfeaa403d91acbd68a821bf6ee8504602b094a254392a07737d5662768c7a9fb1b2814bb34780eaee6e867c773e28c212ead563e98a1cd5d5b4576f5ee61c59bde025ff2851bb19b721421694f263818e3531e43a9e4e3e2c661e2ad547d8984caa28ebecd3e4525452299be26b9185a20a90ce1eac20a91f2832d731b54502b09749b5a2a2949292f8cfcbeffb790c7790ed935a9d251e7e336148ea83b063a5618fcff674a44581585fd22077ca0e52c59a24347a38d1a1ceebddbf238541f226b8f88d0fb9c07a1bcd2ea764bbbb5dacdaf5312a14c0b9e4f06309b0333b4a")[..]); + } } #[cfg(test)] diff --git a/crates/o5/src/handshake/ntor_obfs4.rs b/crates/o5/src/handshake/ntor_obfs4.rs new file mode 100644 index 0000000..4feeb56 --- /dev/null +++ b/crates/o5/src/handshake/ntor_obfs4.rs @@ -0,0 +1,352 @@ +//! Implements the ntor handshake, as used in modern Tor. + +use crate::{ + common::{ + ct, + curve25519::{EphemeralSecret, PublicKey, Representable, SharedSecret, StaticSecret}, + kdf::{Kdf, Ntor1Kdf}, + ntor_arti::{ + AuxDataReply, ClientHandshake, KeyGenerator, RelayHandshakeError, RelayHandshakeResult, + ServerHandshake, + }, + }, + constants::*, + framing::{O5Codec, KEY_MATERIAL_LENGTH}, + Error, Result, Server, +}; + +use std::borrow::Borrow; + +use base64::{ + engine::general_purpose::{STANDARD, STANDARD_NO_PAD}, + Engine as _, +}; +use bytes::BytesMut; +use digest::Mac; +use hmac::Hmac; +use ptrs::warn; +use subtle::ConstantTimeEq; +use tor_bytes::{EncodeResult, SecretBuf, Writer}; +use tor_error::into_internal; +use tor_llcrypto::d::Sha256; +use tor_llcrypto::pk::rsa::RsaIdentity; + +#[cfg(test)] +use rand::{CryptoRng, RngCore}; + +mod handshake_client; +mod handshake_server; +mod utils; + +pub(crate) use utils::*; + +pub(crate) use handshake_client::HandshakeMaterials as CHSMaterials; +#[cfg(test)] +pub(crate) use handshake_client::{ + client_handshake2_no_auth_check_obfs4, client_handshake_obfs4_no_keygen, +}; +use handshake_client::{client_handshake2_obfs4, client_handshake_obfs4, NtorHandshakeState}; +pub(crate) use handshake_server::HandshakeMaterials as SHSMaterials; + +pub(crate) const PROTO_ID: &[u8; 24] = b"ntor-curve25519-sha256-1"; +pub(crate) const T_MAC: &[u8; 28] = b"ntor-curve25519-sha256-1:mac"; +pub(crate) const T_VERIFY: &[u8; 35] = b"ntor-curve25519-sha256-1:key_verify"; +pub(crate) const T_KEY: &[u8; 36] = b"ntor-curve25519-sha256-1:key_extract"; +pub(crate) const M_EXPAND: &[u8; 35] = b"ntor-curve25519-sha256-1:key_expand"; + +/// Struct containing associated function for the obfs4 Ntor handshake. +pub(crate) struct O5NtorHandshake; + +impl ClientHandshake for O5NtorHandshake { + type KeyType = CHSMaterials; + type StateType = NtorHandshakeState; + type KeyGen = NtorHkdfKeyGenerator; + type ClientAuxData = (); + type ServerAuxData = BytesMut; + + fn client1>( + key: &Self::KeyType, + _client_aux_data: &M, + ) -> Result<(Self::StateType, Vec)> { + client_handshake_obfs4(key) + } + + fn client2>( + state: Self::StateType, + msg: T, + ) -> Result<(Self::ServerAuxData, Self::KeyGen)> { + let (keygen, remainder) = client_handshake2_obfs4(msg, &state)?; + Ok((BytesMut::from(&remainder[..]), keygen)) + } +} + +impl ServerHandshake for Server { + type KeyType = SHSMaterials; + type KeyGen = NtorHkdfKeyGenerator; + type ClientAuxData = (); + type ServerAuxData = (); + + fn server, T: AsRef<[u8]>>( + &self, + reply_fn: &mut REPLY, + key: &[Self::KeyType], + msg: T, + ) -> RelayHandshakeResult<(Self::KeyGen, Vec)> { + reply_fn + .reply(&()) + .ok_or(RelayHandshakeError::BadClientHandshake)?; + + if key.is_empty() { + return Err(RelayHandshakeError::MissingKey); + } + + if key.len() > 1 { + warn!("Multiple keys provided, but only the first key will be used"); + } + + let shs_materials = key[0].clone(); + + self.server_handshake_obfs4(msg, shs_materials) + } +} + +/// Key information about a relay used for the ntor v3 handshake. +/// +/// Contains a single curve25519 ntor onion key, and the relay's ed25519 +/// identity. +#[derive(Clone, Debug, Copy, PartialEq, Eq, Hash)] +pub(crate) struct O5NtorPublicKey { + /// Public RSA identity fingerprint for the relay; used in authentication + /// calculation. + pub(crate) id: RsaIdentity, + /// The Bridge's identity key. + pub(crate) pk: PublicKey, +} + +impl O5NtorPublicKey { + const CERT_LENGTH: usize = NODE_ID_LENGTH + NODE_PUBKEY_LENGTH; + const CERT_SUFFIX: &'static str = "=="; + /// Construct a new O5NtorPublicKey from its components. + #[allow(unused)] + pub(crate) fn new(pk: [u8; NODE_PUBKEY_LENGTH], id: [u8; NODE_ID_LENGTH]) -> Self { + Self { + pk: pk.into(), + id: id.into(), + } + } +} + +impl std::str::FromStr for O5NtorPublicKey { + type Err = Error; + fn from_str(s: &str) -> std::prelude::v1::Result { + let mut cert = String::from(s); + cert.push_str(Self::CERT_SUFFIX); + let decoded = STANDARD + .decode(cert.as_bytes()) + .map_err(|e| format!("failed to decode cert: {e}"))?; + if decoded.len() != Self::CERT_LENGTH { + return Err(format!("cert length {} is invalid", decoded.len()).into()); + } + let id: [u8; NODE_ID_LENGTH] = decoded[..NODE_ID_LENGTH].try_into().unwrap(); + let pk: [u8; NODE_PUBKEY_LENGTH] = decoded[NODE_ID_LENGTH..].try_into().unwrap(); + Ok(O5NtorPublicKey::new(pk, id)) + } +} + +#[allow(clippy::to_string_trait_impl)] +impl std::string::ToString for O5NtorPublicKey { + fn to_string(&self) -> String { + let mut s = Vec::from(self.id.as_bytes()); + s.extend(self.pk.as_bytes()); + STANDARD_NO_PAD.encode(s) + } +} + +/// Secret key information used by a relay for the ntor v3 handshake. +#[derive(Clone)] +pub(crate) struct O5NtorSecretKey { + /// The relay's public key information + pub(crate) pk: O5NtorPublicKey, + /// The secret onion key. + pub(crate) sk: StaticSecret, +} + +impl O5NtorSecretKey { + /// Construct a new O5NtorSecretKey from its components. + #[allow(unused)] + pub(crate) fn new(sk: StaticSecret, id: RsaIdentity) -> Self { + let pk = PublicKey::from(&sk); + Self { + pk: O5NtorPublicKey { id, pk }, + sk, + } + } + + /// Construct a new ['O5NtorSecretKey'] from a CSPRNG. + pub(crate) fn getrandom() -> Self { + let sk = Representable::random_static(); + let mut id = [0_u8; NODE_ID_LENGTH]; + getrandom::getrandom(&mut id).expect("internal randomness error"); + Self::new(sk, RsaIdentity::from(id)) + } + + /// Generate a key using the given `rng`, suitable for testing. + #[cfg(test)] + pub(crate) fn generate_for_test(rng: &mut R) -> Self { + let mut id = [0_u8; 20]; + // Random bytes will work for testing, but aren't necessarily actually a valid id. + rng.fill_bytes(&mut id); + + let sk = Representable::static_from_rng(rng); + + let pk = O5NtorPublicKey { + pk: (&sk).into(), + id: id.into(), + }; + Self { pk, sk } + } +} + +/// KeyGenerator for use with ntor circuit handshake. +pub(crate) struct NtorHkdfKeyGenerator { + /// Secret key information derived from the handshake, used as input + /// to HKDF + seed: SecretBuf, + codec: O5Codec, + session_id: [u8; SESSION_ID_LEN], +} + +impl NtorHkdfKeyGenerator { + /// Create a new key generator to expand a given seed + pub(crate) fn new(seed: SecretBuf, is_client: bool) -> Self { + // use the seed value to bootstrap Read / Write crypto codec. + let okm = Self::kdf(&seed[..], KEY_MATERIAL_LENGTH * 2 + SESSION_ID_LEN) + .expect("bug: failed to derive key material from seed"); + + let ekm: [u8; KEY_MATERIAL_LENGTH] = okm[KEY_MATERIAL_LENGTH..KEY_MATERIAL_LENGTH * 2] + .try_into() + .unwrap(); + let dkm: [u8; KEY_MATERIAL_LENGTH] = okm[..KEY_MATERIAL_LENGTH].try_into().unwrap(); + + let session_id = okm[KEY_MATERIAL_LENGTH * 2..].try_into().unwrap(); + + // server ekm == client dkm and vice-versa + let codec = match is_client { + false => O5Codec::new(ekm, dkm), + true => O5Codec::new(dkm, ekm), + }; + + NtorHkdfKeyGenerator { + seed, + codec, + session_id, + } + } + + fn kdf(seed: impl AsRef<[u8]>, keylen: usize) -> Result { + Ntor1Kdf::new(&T_KEY[..], &M_EXPAND[..]).derive(seed.as_ref(), keylen) + } +} + +impl KeyGenerator for NtorHkdfKeyGenerator { + fn expand(self, keylen: usize) -> Result { + let ntor1_key = &T_KEY[..]; + let ntor1_expand = &M_EXPAND[..]; + Ntor1Kdf::new(ntor1_key, ntor1_expand).derive(&self.seed[..], keylen) + } +} + +/// Alias for an HMAC output, used to validate correctness of a handshake. +pub(crate) type Authcode = [u8; 32]; +pub(crate) const AUTHCODE_LENGTH: usize = 32; + +/// helper: compute a key generator and an authentication code from a set +/// of ntor parameters. +/// +/// These parameter names are as described in tor-spec.txt +fn ntor_derive( + xy: &SharedSecret, + xb: &SharedSecret, + server_pk: &O5NtorPublicKey, + x: &PublicKey, + y: &PublicKey, +) -> EncodeResult<(SecretBuf, Authcode)> { + // ) -> EncodeResult<(NtorHkdfKeyGenerator, Authcode)> { + let server_string = &b"Server"[..]; + + // obfs4 uses a different order than Ntor V1 and accidentally writes the + // server's identity public key bytes twice. + let mut suffix = SecretBuf::new(); + suffix.write(&server_pk.pk.as_bytes())?; // b + suffix.write(&server_pk.pk.as_bytes())?; // b + suffix.write(x.as_bytes())?; // x + suffix.write(y.as_bytes())?; // y + suffix.write(PROTO_ID)?; // PROTOID + suffix.write(&server_pk.id)?; // ID + + // secret_input = EXP(X,y) | EXP(X,b) OR = EXP(Y,x) | EXP(B,x) + // ^ these are the equivalent x25519 shared secrets concatenated + // + // message = (secret_input) | b | b | x | y | PROTOID | ID + let mut message = SecretBuf::new(); + message.write(xy.as_bytes())?; // EXP(X,y) + message.write(xb.as_bytes())?; // EXP(X,b) + message.write(&suffix[..])?; // b | b | x | y | PROTOID | ID + + // verify = HMAC_SHA256(msg, T_VERIFY) + let verify = { + let mut m = Hmac::::new_from_slice(T_VERIFY).expect("Hmac allows keys of any size"); + m.update(&message[..]); + m.finalize() + }; + + // auth_input = verify | (suffix) | "Server" + // auth_input = verify | b | b | y | x | PROTOID | ID | "Server" + // + // Again obfs4 uses all of the same fields (with the servers identity public + // key duplicated), but in a different order than Ntor V1. + let mut auth_input = Vec::new(); + auth_input.write_and_consume(verify)?; // verify + auth_input.write(&suffix[..])?; // b | b | x | y | PROTOID | ID + auth_input.write(server_string)?; // "Server" + + // auth = HMAC_SHA256(auth_input, T_MAC) + let auth_mac = { + let mut m = Hmac::::new_from_slice(T_MAC).expect("Hmac allows keys of any size"); + m.update(&auth_input[..]); + m.finalize() + }; + let auth: [u8; 32] = auth_mac.into_bytes()[..].try_into().unwrap(); + + // key_seed = HMAC_SHA256(message, T_KEY) + let key_seed_bytes = { + let mut m = Hmac::::new_from_slice(T_KEY).expect("Hmac allows keys of any size"); + m.update(&message[..]); + m.finalize() + }; + let mut key_seed = SecretBuf::new(); + key_seed.write_and_consume(key_seed_bytes)?; + + Ok((key_seed, auth)) +} + +/// O5 helper trait to ensure that a returned key generator can be used +/// to create a usable codec and retrieve a session id. +pub trait O5Keygen: KeyGenerator + Into { + fn session_id(&mut self) -> [u8; SESSION_ID_LEN]; +} + +impl O5Keygen for NtorHkdfKeyGenerator { + fn session_id(&mut self) -> [u8; SESSION_ID_LEN] { + self.session_id + } +} + +impl From for O5Codec { + fn from(keygen: NtorHkdfKeyGenerator) -> Self { + keygen.codec + } +} + +#[cfg(test)] +mod integration; diff --git a/crates/o5/src/handshake/utils.rs b/crates/o5/src/handshake/utils.rs new file mode 100644 index 0000000..fc89649 --- /dev/null +++ b/crates/o5/src/handshake/utils.rs @@ -0,0 +1,264 @@ +use crate::{constants::*, Result}; + +use std::time::{SystemTime, UNIX_EPOCH}; + +use rand_core::RngCore; +use subtle::ConstantTimeEq; + +use ptrs::trace; + +pub fn get_epoch_hour() -> u64 { + SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap() + .as_secs() + / 3600 +} + +pub fn make_hs_pad(pad_len: usize) -> Result> { + trace!("[make_hs_pad] generating {pad_len}B"); + let mut pad = vec![u8::default(); pad_len]; + rand::thread_rng() + .try_fill_bytes(&mut pad) + .expect("rng failure"); + Ok(pad) +} + +pub fn find_mac_mark( + mark: [u8; MARK_LENGTH], + buf: impl AsRef<[u8]>, + start_pos: usize, + max_pos: usize, + from_tail: bool, +) -> Option { + let buffer = buf.as_ref(); + if buffer.len() < MARK_LENGTH { + return None; + } + trace!( + "finding mac mark: buf: {}B, {}-{}, from_tail: {}", + buffer.len(), + start_pos, + max_pos, + from_tail + ); + + if start_pos > buffer.len() { + return None; + } + + let mut end_pos = buffer.len(); + if end_pos > max_pos { + end_pos = max_pos; + } + + if end_pos - start_pos < MARK_LENGTH + MAC_LENGTH { + return None; + } + + let mut pos: usize; + if from_tail { + // The server can optimize the search process by only examining the + // tail of the buffer. The client can't send valid data past M_C | + // MAC_C as it does not have the server's public key yet. + pos = end_pos - (MARK_LENGTH + MAC_LENGTH); + // trace!("{pos}\n{}\n{}", hex::encode(mark), hex::encode(&buffer[pos..pos + MARK_LENGTH])); + if mark[..] + .ct_eq(buffer[pos..pos + MARK_LENGTH].as_ref()) + .into() + { + return Some(pos); + } + return None; + } + + // The client has to actually do a substring search since the server can + // and will send payload trailing the response. + // + // XXX: .windows().position() uses a naive search, which kind of sucks. + // but better algorithms (like `contains` for String) aren't implemented + // for byte slices in std. + pos = buffer[start_pos..end_pos] + .windows(MARK_LENGTH) + .position(|window| window.ct_eq(&mark[..]).into())?; + + // Ensure that there is enough trailing data for the MAC. + if start_pos + pos + MARK_LENGTH + MAC_LENGTH > end_pos { + return None; + } + + // Return the index relative to the start of the slice. + pos += start_pos; + Some(pos) +} + +#[cfg(test)] +mod test { + use super::*; + use bytes::Bytes; + + struct MacMarkTest { + mark: [u8; MARK_LENGTH], + buf: Vec, + start_pos: usize, + max_pos: usize, + from_tail: bool, + expected: Option, + } + + #[test] + fn find_mac_mark_thorough() -> Result<()> { + let cases = vec![ + MacMarkTest { + mark: [0_u8; MARK_LENGTH], + buf: vec![0_u8; 100], + start_pos: 0, + max_pos: 100, + from_tail: false, + expected: Some(0), + }, + MacMarkTest { + mark: hex::decode("00112233445566778899aabbccddeeff") + .unwrap() + .try_into() + .unwrap(), + buf: hex::decode( + "00112233445566778899aabbccddeeff00000000000000000000000000000000", + ) + .unwrap(), + start_pos: 0, + max_pos: 100, + from_tail: false, + expected: Some(0), + }, + MacMarkTest { + // from tail + mark: hex::decode("00112233445566778899aabbccddeeff") + .unwrap() + .try_into() + .unwrap(), + buf: hex::decode( + "00112233445566778899aabbccddeeff00000000000000000000000000000000", + ) + .unwrap(), + start_pos: 0, + max_pos: 100, + from_tail: true, + expected: Some(0), + }, + MacMarkTest { + // from tail not align with start + mark: hex::decode("00112233445566778899aabbccddeeff") + .unwrap() + .try_into() + .unwrap(), + buf: hex::decode( + "000000112233445566778899aabbccddeeff00000000000000000000000000000000", + ) + .unwrap(), + start_pos: 0, + max_pos: 100, + from_tail: true, + expected: Some(2), + }, + MacMarkTest { + mark: hex::decode("00112233445566778899aabbccddeeff") + .unwrap() + .try_into() + .unwrap(), + buf: hex::decode( + "000000112233445566778899aabbccddeeff00000000000000000000000000000000", + ) + .unwrap(), + start_pos: 0, + max_pos: 100, + from_tail: false, + expected: Some(2), + }, + MacMarkTest { + mark: hex::decode("00112233445566778899aabbccddeeff") + .unwrap() + .try_into() + .unwrap(), + buf: hex::decode( + "00000000112233445566778899aabbccddeeff00000000000000000000000000000000", + ) + .unwrap(), + start_pos: 2, + max_pos: 100, + from_tail: false, + expected: Some(3), + }, + MacMarkTest { + // Not long enough to contain MAC + mark: hex::decode("00112233445566778899aabbccddeeff") + .unwrap() + .try_into() + .unwrap(), + buf: hex::decode("00112233445566778899aabbccddeeff").unwrap(), + start_pos: 0, + max_pos: 100, + from_tail: false, + expected: None, + }, + MacMarkTest { + // Access from tail success + mark: [0_u8; MARK_LENGTH], + buf: vec![0_u8; 100], + start_pos: 0, + max_pos: 100, + from_tail: true, + expected: Some(100 - MARK_LENGTH - MAC_LENGTH), + }, + MacMarkTest { + // from tail fail + mark: [0_u8; MARK_LENGTH], + buf: hex::decode( + "00112233445566778899aabbccddeeff00000000000000000000000000000000", + ) + .unwrap(), + start_pos: 0, + max_pos: 100, + from_tail: true, + expected: None, + }, + MacMarkTest { + // provided buf too short + mark: [0_u8; MARK_LENGTH], + buf: vec![0_u8; MARK_LENGTH - 1], + start_pos: 0, + max_pos: 100, + from_tail: false, + expected: None, + }, + MacMarkTest { + // provided buf cant contain mark and mac + mark: [0_u8; MARK_LENGTH], + buf: vec![0_u8; MARK_LENGTH + MAC_LENGTH - 1], + start_pos: 0, + max_pos: 100, + from_tail: false, + expected: None, + }, + ]; + + for m in cases { + let actual = find_mac_mark( + m.mark, + &Bytes::from(m.buf), + m.start_pos, + m.max_pos, + m.from_tail, + ); + assert_eq!(actual, m.expected); + } + + Ok(()) + } + + #[test] + fn epoch_format() { + let _h = format!("{}", get_epoch_hour()); + // println!("{h} {}", hex::encode(h.as_bytes())); + } +} diff --git a/crates/o5/src/handshake_old/integration.rs b/crates/o5/src/handshake_old/integration.rs new file mode 100644 index 0000000..6dc00f5 --- /dev/null +++ b/crates/o5/src/handshake_old/integration.rs @@ -0,0 +1,297 @@ +#![allow(non_snake_case)] // to enable variable names matching the spec. +#![allow(clippy::many_single_char_names)] // ibid + +// @@ begin test lint list maintained by maint/add_warning @@ +#![allow(clippy::bool_assert_comparison)] +#![allow(clippy::clone_on_copy)] +#![allow(clippy::dbg_macro)] +#![allow(clippy::print_stderr)] +#![allow(clippy::print_stdout)] +#![allow(clippy::single_char_pattern)] +#![allow(clippy::unwrap_used)] +#![allow(clippy::unchecked_duration_subtraction)] +#![allow(clippy::useless_vec)] +#![allow(clippy::needless_pass_by_value)] +//! + +use super::*; +use crate::common::ntor_arti::{ClientHandshake, ServerHandshake}; + +use hex_literal::hex; +use tor_basic_utils::test_rng::testing_rng; +use digest::XofReader; + + + +#[test] +fn test_obfs4_roundtrip() { + let mut rng = rand::thread_rng(); + let relay_private = O5NtorSecretKey::generate_for_test(&mut testing_rng()); + + let verification = &b"shared secret"[..]; + let client_message = &b"Hello. I am a client. Let's be friends!"[..]; + let relay_message = &b"Greetings, client. I am a robot. Beep boop."[..]; + + let (c_state, c_handshake) = + client_handshake_obfs4(&mut rng, &relay_private.pk, client_message, verification) + .unwrap(); + + struct Rep(Vec, Vec); + impl MsgReply for Rep { + fn reply(&mut self, msg: &[u8]) -> Option> { + self.0 = msg.to_vec(); + Some(self.1.clone()) + } + } + let mut rep = Rep(Vec::new(), relay_message.to_vec()); + + let (s_handshake, mut s_keygen) = server_handshake_obfs4( + &mut rng, + &mut rep, + &c_handshake, + &[relay_private], + verification, + ) + .unwrap(); + + let (s_msg, mut c_keygen) = + client_handshake_obfs4_part2(&c_state, &s_handshake, verification).unwrap(); + + assert_eq!(rep.0[..], client_message[..]); + assert_eq!(s_msg[..], relay_message[..]); + let mut s_keys = [0_u8; 100]; + let mut c_keys = [0_u8; 1000]; + s_keygen.read(&mut s_keys); + c_keygen.read(&mut c_keys); + assert_eq!(s_keys[..], c_keys[..100]); +} + +// Same as previous test, but use the higher-level APIs instead. +#[test] +fn test_obfs4_roundtrip_highlevel() { + let mut rng = rand::thread_rng(); + let relay_private = O5NtorSecretKey::generate_for_test(&mut testing_rng()); + + let (c_state, c_handshake) = + Obfs4NtorClient::client1(&mut rng, &relay_private.pk, &[]).unwrap(); + + let mut rep = |_: &[NtorV3Extension]| Some(vec![]); + + let (s_keygen, s_handshake) = + Obfs4NtorServer::server(&mut rng, &mut rep, &[relay_private], &c_handshake).unwrap(); + + let (extensions, keygen) = Obfs4NtorClient::client2(c_state, s_handshake).unwrap(); + + assert!(extensions.is_empty()); + let c_keys = keygen.expand(1000).unwrap(); + let s_keys = s_keygen.expand(100).unwrap(); + assert_eq!(s_keys[..], c_keys[..100]); +} + +// Same as previous test, but encode some congestion control extensions. +#[test] +fn test_obfs4_roundtrip_highlevel_cc() { + let mut rng = rand::thread_rng(); + let relay_private = O5NtorSecretKey::generate_for_test(&mut testing_rng()); + + let client_exts = vec![NtorV3Extension::RequestCongestionControl]; + let reply_exts = vec![NtorV3Extension::AckCongestionControl { sendme_inc: 42 }]; + + let (c_state, c_handshake) = Obfs4NtorClient::client1( + &mut rng, + &relay_private.pk, + &[NtorV3Extension::RequestCongestionControl], + ) + .unwrap(); + + let mut rep = |msg: &[NtorV3Extension]| -> Option> { + assert_eq!(msg, client_exts); + Some(reply_exts.clone()) + }; + + let (s_keygen, s_handshake) = + Obfs4NtorServer::server(&mut rng, &mut rep, &[relay_private], &c_handshake).unwrap(); + + let (extensions, keygen) = Obfs4NtorClient::client2(c_state, s_handshake).unwrap(); + + assert_eq!(extensions, reply_exts); + let c_keys = keygen.expand(1000).unwrap(); + let s_keys = s_keygen.expand(100).unwrap(); + assert_eq!(s_keys[..], c_keys[..100]); +} + +#[test] +fn test_obfs4_testvec() { + let id = hex!("9fad2af287ef942632833d21f946c6260c33fae6172b60006e86e4a6911753a2"); + let b = hex!("a8649010896d3c05ab0e2ab75e3e9368695c8f72652e8aa73016756007054e59"); // identity key + let x = hex!("f886d140047a115b228a8f7f63cbc5a3ad74e9c970ad3cb4a7f7fd8067f0dd68"); // client session key + let y = hex!("403ec0927a8852bdff12129244fdb03cb3c94b8b8d15c863462fcda52b510d73"); // server session key + let b: curve25519::StaticSecret = b.into(); + let B: curve25519::PublicKey = (&b).into(); + let id: Ed25519Identity = id.into(); + let x: curve25519::StaticSecret = x.into(); + let y: curve25519::StaticSecret = y.into(); + + let client_message = hex!("68656c6c6f20776f726c64"); + let verification = hex!("78797a7a79"); + let server_message = hex!("486f6c61204d756e646f"); + + let identity_public = O5NtorPublicKey { pk: B, id, rp: None }; + let identity_private = O5NtorSecretKey { + sk: b, + pk: identity_public.clone(), + }; + + let (state, client_handshake) = + client_handshake_obfs4_no_keygen(&identity_public, &client_message, &verification, x) + .unwrap(); + + // assert_eq!(client_handshake[..], hex!("9fad2af287ef942632833d21f946c6260c33fae6172b60006e86e4a6911753a2f8307a2bc1870b00b828bb74dbb8fd88e632a6375ab3bcd1ae706aaa8b6cdd1d252fe9ae91264c91d4ecb8501f79d0387e34ad8ca0f7c995184f7d11d5da4f463bebd9151fd3b47c180abc9e044d53565f04d82bbb3bebed3d06cea65db8be9c72b68cd461942088502f67")[..]); + + struct Replier(Vec, Vec, bool); + impl MsgReply for Replier { + fn reply(&mut self, msg: &[u8]) -> Option> { + assert_eq!(msg, &self.0); + self.2 = true; + Some(self.1.clone()) + } + } + let mut rep = Replier(client_message.to_vec(), server_message.to_vec(), false); + + let (server_handshake, mut server_keygen) = server_handshake_obfs4_no_keygen( + &mut rep, + &y, + &client_handshake, + &[identity_private], + &verification, + ) + .unwrap(); + assert!(rep.2); + + // assert_eq!(server_handshake[..], hex!("4bf4814326fdab45ad5184f5518bd7fae25dc59374062698201a50a22954246d2fc5f8773ca824542bc6cf6f57c7c29bbf4e5476461ab130c5b18ab0a91276651202c3e1e87c0d32054c")[..]); + + let (server_msg_received, mut client_keygen) = + client_handshake_obfs4_part2(&state, &server_handshake, &verification).unwrap(); + assert_eq!(&server_msg_received, &server_message); + + let (c_keys, s_keys) = { + let mut c = [0_u8; 256]; + let mut s = [0_u8; 256]; + client_keygen.read(&mut c); + server_keygen.read(&mut s); + (c, s) + }; + assert_eq!(c_keys, s_keys); + assert_eq!(c_keys[..], hex!("05b858d18df21a01566c74d39a5b091b4415f103c05851e77e79b274132dc5b5")[..]); + // assert_eq!(c_keys[..], hex!("9c19b631fd94ed86a817e01f6c80b0743a43f5faebd39cfaa8b00fa8bcc65c3bfeaa403d91acbd68a821bf6ee8504602b094a254392a07737d5662768c7a9fb1b2814bb34780eaee6e867c773e28c212ead563e98a1cd5d5b4576f5ee61c59bde025ff2851bb19b721421694f263818e3531e43a9e4e3e2c661e2ad547d8984caa28ebecd3e4525452299be26b9185a20a90ce1eac20a91f2832d731b54502b09749b5a2a2949292f8cfcbeffb790c7790ed935a9d251e7e336148ea83b063a5618fcff674a44581585fd22077ca0e52c59a24347a38d1a1ceebddbf238541f226b8f88d0fb9c07a1bcd2ea764bbbb5dacdaf5312a14c0b9e4f06309b0333b4a")[..]); +} + +#[test] +fn about_half() -> Result<()> { + let mut rng = rand::thread_rng(); + + let mut success = 0; + let mut not_found = 0; + let mut not_match = 0; + for _ in 0..1_000 { + + let sk = curve25519::StaticSecret::random_from_rng(&mut rng); + let rp: Option= (&sk).into(); + let repres = match rp { + Some(r) => r, + None => { + not_found += 1; + continue; + } + }; + + let pk = curve25519::PublicKey::from(&sk); + + + let decoded_pk = curve25519::PublicKey::from(&repres); + if hex::encode(pk) != hex::encode(decoded_pk) { + not_match += 1; + continue; + } + success += 1; + } + + if not_match != 0 { + println!("{not_found}/{not_match}/{success}/10_000"); + assert_eq!(not_match, 0); + } + assert!(not_found < 600); + assert!(not_found > 400); + Ok(()) +} + +#[test] +fn keypair() -> Result<()> { + let mut rng = rand::thread_rng(); + for _ in 0..1_000 { + let kp = O5NtorSecretKey::generate_for_test(&mut rng); + + let pk = kp.pk.pk.to_bytes(); + let repres = kp.pk.rp; + + let pubkey = curve25519::PublicKey::from(&repres.unwrap()); + assert_eq!(hex::encode(pk), hex::encode(pubkey.to_bytes())); + } + Ok(()) +} + + +/* +// Benchmark Client/Server handshake. The actual time taken that will be +// observed on either the Client or Server is half the reported time per +// operation since the benchmark does both sides. +func BenchmarkHandshake(b *testing.B) { + // Generate the "long lasting" identity key and NodeId. + idKeypair, err := NewKeypair(false) + if err != nil || idKeypair == nil { + b.Fatal("Failed to generate identity keypair") + } + nodeID, err := NewNodeID([]byte("\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13")) + if err != nil { + b.Fatal("Failed to load NodeId:", err) + } + b.ResetTimer() + + // Start the actual benchmark. + for i := 0; i < b.N; i++ { + // Generate the keypairs. + serverKeypair, err := NewKeypair(true) + if err != nil || serverKeypair == nil { + b.Fatal("Failed to generate server keypair") + } + + clientKeypair, err := NewKeypair(true) + if err != nil || clientKeypair == nil { + b.Fatal("Failed to generate client keypair") + } + + // Server handshake. + clientPublic := clientKeypair.Representative().ToPublic() + ok, serverSeed, serverAuth := ServerHandshake(clientPublic, + serverKeypair, idKeypair, nodeID) + if !ok || serverSeed == nil || serverAuth == nil { + b.Fatal("ServerHandshake failed") + } + + // Client handshake. + serverPublic := serverKeypair.Representative().ToPublic() + ok, clientSeed, clientAuth := ClientHandshake(clientKeypair, + serverPublic, idKeypair.Public(), nodeID) + if !ok || clientSeed == nil || clientAuth == nil { + b.Fatal("ClientHandshake failed") + } + + // Validate the authenticator. Real code would pass the AUTH read off + // the network as a slice to CompareAuth here. + if !CompareAuth(clientAuth, serverAuth.Bytes()[:]) || + !CompareAuth(serverAuth, clientAuth.Bytes()[:]) { + b.Fatal("AUTH mismatched between client/server") + } + } +} +*/ diff --git a/crates/o5/src/handshake_old/mod.rs b/crates/o5/src/handshake_old/mod.rs new file mode 100644 index 0000000..30b2330 --- /dev/null +++ b/crates/o5/src/handshake_old/mod.rs @@ -0,0 +1,774 @@ +//! Implements the ntor v3 key exchange, as described in proposal 332. +//! +//! The main difference between the ntor v3r handshake and the +//! original ntor handshake is that this this one allows each party to +//! encrypt data (without forward secrecy) after it sends the first +//! message. + +// TODO: +// Remove the "allow" item for dead_code. +// Make terminology and variable names consistent with spec. + +// This module is still unused: so allow some dead code for now. +#![allow(dead_code)] + +use std::borrow::Borrow; + +use crate::common::ntor_arti::{KeyGenerator, RelayHandshakeError, RelayHandshakeResult}; +use crate::common::ct; +use crate::common::curve25519; +use crate::{Error, Result}; +use tor_bytes::{EncodeResult, Reader, SecretBuf, Writeable, Writer}; +use tor_error::into_internal; +use tor_llcrypto::d::{Sha256, Shake256, Shake256Reader}; +use tor_llcrypto::pk::ed25519::Ed25519Identity; +use tor_llcrypto::util::ct::ct_lookup; + +use cipher::{KeyIvInit, StreamCipher}; + +use rand_core::{CryptoRng, RngCore}; +use subtle::{Choice, ConstantTimeEq}; +use tor_cell::relaycell::extend::NtorV3Extension; +use tor_llcrypto::cipher::aes::Aes256Ctr; +use zeroize::Zeroizing; + +/// The verification string to be used for circuit extension. +const OBFS4_CIRC_VERIFICATION: &[u8] = b"circuit extend"; + +/// The size of an encryption key in bytes. +const ENC_KEY_LEN: usize = 32; +/// The size of a MAC key in bytes. +const MAC_KEY_LEN: usize = 32; +/// The size of a curve25519 public key in bytes. +const PUB_KEY_LEN: usize = 32; +/// The size of a digest output in bytes. +const DIGEST_LEN: usize = 32; +/// The length of a MAC output in bytes. +const MAC_LEN: usize = 32; +/// The length of a node identity in bytes. +const ID_LEN: usize = 32; + +/// The output of the digest, as an array. +type DigestVal = [u8; DIGEST_LEN]; +/// The output of the MAC. +type MacVal = [u8; MAC_LEN]; +/// A key for symmetric encryption or decryption. +// +// TODO (nickm): Any move operations applied to this key could subvert the zeroizing. +type EncKey = Zeroizing<[u8; ENC_KEY_LEN]>; +/// A key for message authentication codes. +type MacKey = [u8; MAC_KEY_LEN]; + +/// Opaque wrapper type for Obfs4Ntor's hash reader. +struct Obfs4NtorXofReader(Shake256Reader); + +impl digest::XofReader for Obfs4NtorXofReader { + fn read(&mut self, buffer: &mut [u8]) { + self.0.read(buffer); + } +} + +/// An encapsulated value for passing as input to a MAC, digest, or +/// KDF algorithm. +/// +/// This corresponds to the ENCAP() function in proposal 332. +struct Encap<'a>(&'a [u8]); + +impl<'a> Writeable for Encap<'a> { + fn write_onto(&self, b: &mut B) -> EncodeResult<()> { + b.write_u64(self.0.len() as u64); + b.write(self.0) + } +} + +impl<'a> Encap<'a> { + /// Return the length of the underlying data in bytes. + fn len(&self) -> usize { + self.0.len() + } + /// Return the underlying data + fn data(&self) -> &'a [u8] { + self.0 + } +} + +/// Helper to define a set of tweak values as instances of `Encap`. +macro_rules! define_tweaks { + { + $(#[$pid_meta:meta])* + PROTOID = $protoid:expr; + $( $(#[$meta:meta])* $name:ident <= $suffix:expr ; )* + } => { + $(#[$pid_meta])* + const PROTOID: &'static [u8] = $protoid.as_bytes(); + $( + $(#[$meta])* + const $name : Encap<'static> = + Encap(concat!($protoid, ":", $suffix).as_bytes()); + )* + } +} + +define_tweaks! { + + pub(crate) const PROTO_ID: &[u8; 24] = b"ntor-curve25519-sha256-1"; + + pub(crate) const T_MAC: &[u8; 28] = b"ntor-curve25519-sha256-1:mac"; + + pub(crate) const T_VERIFY: &[u8; 35] = b"ntor-curve25519-sha256-1:key_verify"; + + pub(crate) const T_KEY: &[u8; 36] = b"ntor-curve25519-sha256-1:key_extract"; + + + /// Protocol ID: concatenated with other things in the protocol to + /// prevent hash confusion. + PROTOID = "ntor3-curve25519-sha3_256-1"; + + /// Message MAC tweak: used to compute the MAC of an encrypted client + /// message. + T_MSGMAC <= "msg_mac"; + /// Message KDF tweak: used when deriving keys for encrypting and MACing + /// client message. + T_MSGKDF <= "kdf_phase1"; + /// Key seeding tweak: used to derive final KDF input from secret_input. + T_KEY_SEED <= "key_seed"; + /// Verifying tweak: used to derive 'verify' value from secret_input. + T_VERIFY <= "verify"; + /// Final KDF tweak: used to derive keys for encrypting relay message + /// and for the actual tor circuit. + T_FINAL <= "kdf_final"; + /// Authentication tweak: used to derive the final authentication + /// value for the handshake. + T_AUTH <= "auth_final"; +} + +/// Compute a tweaked hash. +fn hash(t: &Encap<'_>, data: &[u8]) -> DigestVal { + use digest::Digest; + let mut d = Sha256::new(); + d.update((t.len() as u64).to_be_bytes()); + d.update(t.data()); + d.update(data); + d.finalize().into() +} + +/// Perform a symmetric encryption operation and return the encrypted data. +/// +/// (This isn't safe to do more than once with the same key, but we never +/// do that in this protocol.) +fn encrypt(key: &EncKey, m: &[u8]) -> Vec { + let mut d = m.to_vec(); + let zero_iv = Default::default(); + let mut cipher = Aes256Ctr::new(key.as_ref().into(), &zero_iv); + cipher.apply_keystream(&mut d); + d +} +/// Perform a symmetric decryption operation and return the encrypted data. +fn decrypt(key: &EncKey, m: &[u8]) -> Vec { + encrypt(key, m) +} + +/// Wrapper around a Digest or ExtendedOutput object that lets us use it +/// as a tor_bytes::Writer. +struct DigestWriter(U); +impl tor_bytes::Writer for DigestWriter { + fn write_all(&mut self, bytes: &[u8]) { + self.0.update(bytes); + } +} +impl DigestWriter { + /// Consume this wrapper and return the underlying object. + fn take(self) -> U { + self.0 + } +} + +/// Hash tweaked with T_KEY_SEED +fn h_key_seed(d: &[u8]) -> DigestVal { + hash(&T_KEY_SEED, d) +} +/// Hash tweaked with T_VERIFY +fn h_verify(d: &[u8]) -> DigestVal { + hash(&T_VERIFY, d) +} + +/// Helper: compute the encryption key and mac_key for the client's +/// encrypted message. +/// +/// Takes as inputs `xb` (the shared secret derived from +/// diffie-hellman as Bx or Xb), the relay's public key information, +/// the client's public key (B), and the shared verification string. +fn kdf_msgkdf( + xb: &curve25519::SharedSecret, + relay_public: &O5NtorPublicKey, + client_public: &curve25519::PublicKey, + verification: &[u8], +) -> EncodeResult<(EncKey, DigestWriter)> { + // secret_input_phase1 = Bx | ID | X | B | PROTOID | ENCAP(VER) + // phase1_keys = KDF_msgkdf(secret_input_phase1) + // (ENC_K1, MAC_K1) = PARTITION(phase1_keys, ENC_KEY_LEN, MAC_KEY_LEN + use digest::{ExtendableOutput, XofReader}; + let mut msg_kdf = DigestWriter(Shake256::default()); + msg_kdf.write(&T_MSGKDF)?; + msg_kdf.write(xb.as_bytes())?; + msg_kdf.write(&relay_public.id)?; + msg_kdf.write(client_public.as_bytes())?; + msg_kdf.write(&relay_public.pk.as_bytes())?; + msg_kdf.write(PROTOID)?; + msg_kdf.write(&Encap(verification))?; + let mut r = msg_kdf.take().finalize_xof(); + let mut enc_key = Zeroizing::new([0; ENC_KEY_LEN]); + let mut mac_key = Zeroizing::new([0; MAC_KEY_LEN]); + + r.read(&mut enc_key[..]); + r.read(&mut mac_key[..]); + let mut mac = DigestWriter(Sha256::default()); + { + mac.write(&T_MSGMAC)?; + mac.write(&Encap(&mac_key[..]))?; + mac.write(&relay_public.id)?; + mac.write(&relay_public.pk.as_bytes())?; + mac.write(client_public.as_bytes())?; + } + + Ok((enc_key, mac)) +} + +/// Client side of the ntor v3 handshake. +pub(crate) struct Obfs4NtorClient; + +impl crate::common::ntor_arti::ClientHandshake for Obfs4NtorClient { + type KeyType = O5NtorPublicKey; + type StateType = O5NtorHandshakeState; + type KeyGen = Obfs4NtorKeyGenerator; + type ClientAuxData = [NtorV3Extension]; + type ServerAuxData = Vec; + + /// Generate a new client onionskin for a relay with a given onion key. + /// If any `extensions` are provided, encode them into to the onionskin. + /// + /// On success, return a state object that will be used to complete the handshake, along + /// with the message to send. + fn client1>( + rng: &mut R, + key: &O5NtorPublicKey, + extensions: &M, + ) -> Result<(Self::StateType, Vec)> { + let mut message = Vec::new(); + NtorV3Extension::write_many_onto(extensions.borrow(), &mut message) + .map_err(|e| Error::from_bytes_enc(e, "ntor3 handshake extensions"))?; + Ok( + client_handshake_obfs4(rng, key, &message, OBFS4_CIRC_VERIFICATION) + .map_err(into_internal!("Can't encode obfs4 client handshake."))?, + ) + } + + /// Handle an onionskin from a relay, and produce a key generator. + /// + /// The state object must match the one that was used to make the + /// client onionskin that the server is replying to. + fn client2>( + state: Self::StateType, + msg: T, + ) -> Result<(Vec, Self::KeyGen)> { + let (message, xofreader) = + client_handshake_obfs4_part2(&state, msg.as_ref(), OBFS4_CIRC_VERIFICATION)?; + let extensions = NtorV3Extension::decode(&message).map_err(|err| Error::CellDecodeErr { + object: "ntor v3 extensions", + err, + })?; + let keygen = Obfs4NtorKeyGenerator { reader: xofreader }; + + Ok((extensions, keygen)) + } +} + +/// Server side of the ntor v3 handshake. +pub(crate) struct Obfs4NtorServer; + +impl crate::common::ntor_arti::ServerHandshake for Obfs4NtorServer { + type KeyType = O5NtorSecretKey; + type KeyGen = Obfs4NtorKeyGenerator; + type ClientAuxData = [NtorV3Extension]; + type ServerAuxData = Vec; + + fn server, T: AsRef<[u8]>>( + rng: &mut R, + reply_fn: &mut REPLY, + key: &[Self::KeyType], + msg: T, + ) -> RelayHandshakeResult<(Self::KeyGen, Vec)> { + let mut bytes_reply_fn = |bytes: &[u8]| -> Option> { + let client_exts = NtorV3Extension::decode(bytes).ok()?; + let reply_exts = reply_fn.reply(&client_exts)?; + let mut out = vec![]; + NtorV3Extension::write_many_onto(&reply_exts, &mut out).ok()?; + Some(out) + }; + + let (res, reader) = server_handshake_obfs4( + rng, + &mut bytes_reply_fn, + msg.as_ref(), + key, + OBFS4_CIRC_VERIFICATION, + )?; + Ok((Obfs4NtorKeyGenerator { reader }, res)) + } +} + +/// Key information about a relay used for the ntor v3 handshake. +/// +/// Contains a single curve25519 ntor onion key, and the relay's ed25519 +/// identity. +#[derive(Clone, Debug)] +pub(crate) struct O5NtorPublicKey { + /// The relay's identity. + pub(crate) id: Ed25519Identity, + /// The Bridge's identity key. + pub(crate) pk: curve25519::PublicKey, + /// The Elligator2 representative for the public key + pub(crate) rp: Option, +} + +/// Secret key information used by a relay for the ntor v3 handshake. +pub(crate) struct O5NtorSecretKey { + /// The relay's public key information + pk: O5NtorPublicKey, + /// The secret onion key. + sk: curve25519::StaticSecret, +} + +impl O5NtorSecretKey { + /// Construct a new O5NtorSecretKey from its components. + #[allow(unused)] + pub(crate) fn new( + sk: curve25519::StaticSecret, + pk: curve25519::PublicKey, + rp: Option, + id: Ed25519Identity, + ) -> Self { + Self { + pk: O5NtorPublicKey { id, pk, rp }, + sk, + } + } + + /// Generate a key using the given `rng`, suitable for testing. + #[cfg(test)] + pub(crate) fn generate_for_test(mut rng: R) -> Self { + let mut id = [0_u8; 32]; + // Random bytes will work for testing, but aren't necessarily actually a valid id. + rng.fill_bytes(&mut id); + + let mut sk: curve25519::StaticSecret = [0u8;32].into(); + let mut pk1: curve25519::PublicKey = [0u8;32].into(); + let mut rp: Option = None; + + for _ in 0..64 { // artificial ceil of 64 so this can't infinite loop + + // approx 50% of keys do not have valid representatives so we just + // iterate until we find a key where it is valid. This should take + // a low number of iteratations and always succeed eventually. + sk = curve25519::StaticSecret::random_from_rng(&mut rng); + rp = (&sk).into(); + if rp.is_none() { + continue + } + pk1 = (&sk).into(); + break + } + + let pk = O5NtorPublicKey { + pk: pk1, + id: id.into(), + rp, + }; + Self { pk, sk } + } + + /// Checks whether `id` and `pk` match this secret key. + /// + /// Used to perform a constant-time secret key lookup. + fn matches(&self, id: Ed25519Identity, pk: curve25519::PublicKey) -> Choice { + // TODO: use similar pattern in ntor_v1! + id.as_bytes().ct_eq(self.pk.id.as_bytes()) & pk.as_bytes().ct_eq(self.pk.pk.as_bytes()) + } +} + +/// Client state for the ntor v3 handshake. +/// +/// The client needs to hold this state between when it sends its part +/// of the handshake and when it receives the relay's reply. +pub(crate) struct O5NtorHandshakeState { + /// The public key of the relay we're communicating with. + relay_public: O5NtorPublicKey, // B, ID. + /// Our ephemeral secret key for this handshake. + my_sk: curve25519::StaticSecret, // x + /// Our ephemeral public key for this handshake. + my_public: curve25519::PublicKey, // X + + /// The shared secret generated as Bx or Xb. + shared_secret: curve25519::SharedSecret, // Bx + /// The MAC of our original encrypted message. + msg_mac: MacVal, // msg_mac +} + +/// A key generator returned from an ntor v3 handshake. +pub(crate) struct Obfs4NtorKeyGenerator { + /// The underlying `digest::XofReader`. + reader: Obfs4NtorXofReader, +} + +impl KeyGenerator for Obfs4NtorKeyGenerator { + fn expand(mut self, keylen: usize) -> Result { + use digest::XofReader; + let mut ret: SecretBuf = vec![0; keylen].into(); + self.reader.read(ret.as_mut()); + Ok(ret) + } +} + +/// Client-side Ntor version 3 handshake, part one. +/// +/// Given a secure `rng`, a relay's public key, a secret message to send, +/// and a shared verification string, generate a new handshake state +/// and a message to send to the relay. +fn client_handshake_obfs4( + rng: &mut R, + relay_public: &O5NtorPublicKey, + client_msg: &[u8], + verification: &[u8], +) -> EncodeResult<(O5NtorHandshakeState, Vec)> { + let my_sk = curve25519::StaticSecret::random_from_rng(rng); + client_handshake_obfs4_no_keygen(relay_public, client_msg, verification, my_sk) +} + +/// As `client_handshake_obfs4`, but don't generate an ephemeral DH +/// key: instead take that key an arguments `my_sk`. +fn client_handshake_obfs4_no_keygen( + relay_public: &O5NtorPublicKey, + client_msg: &[u8], + verification: &[u8], + my_sk: curve25519::StaticSecret, +) -> EncodeResult<(O5NtorHandshakeState, Vec)> { + let my_public = curve25519::PublicKey::from(&my_sk); + let bx = my_sk.diffie_hellman(&relay_public.pk); + + let (enc_key, mut mac) = kdf_msgkdf(&bx, relay_public, &my_public, verification)?; + + //encrypted_msg = ENC(ENC_K1, CM) + // msg_mac = MAC_msgmac(MAC_K1, ID | B | X | encrypted_msg) + let encrypted_msg = encrypt(&enc_key, client_msg); + let msg_mac: DigestVal = { + use digest::Digest; + mac.write(&encrypted_msg)?; + mac.take().finalize().into() + }; + + let mut message = Vec::new(); + message.write(&relay_public.id)?; + message.write(&relay_public.pk.as_bytes())?; + message.write(&my_public.as_bytes())?; + message.write(&encrypted_msg)?; + message.write(&msg_mac)?; + + let state = O5NtorHandshakeState { + relay_public: relay_public.clone(), + my_sk, + my_public, + shared_secret: bx, + msg_mac, + }; + + Ok((state, message)) +} + +/// Trait for an object that handle and incoming client message and +/// return a server's reply. +/// +/// This is implemented for `FnMut(&[u8]) -> Option>` automatically. +pub(crate) trait MsgReply { + /// Given a message received from a client, parse it and decide + /// how (and whether) to reply. + /// + /// Return None if the handshake should fail. + fn reply(&mut self, msg: &[u8]) -> Option>; +} + +impl MsgReply for F +where + F: FnMut(&[u8]) -> Option>, +{ + fn reply(&mut self, msg: &[u8]) -> Option> { + self(msg) + } +} + +/// Complete an ntor v3 handshake as a server. +/// +/// Use the provided `rng` to generate keys; use the provided +/// `reply_fn` to handle incoming client secret message and decide how +/// to reply. The client's handshake is in `message`. Our private +/// key(s) are in `keys`. The `verification` string must match the +/// string provided by the client. +/// +/// On success, return the server handshake message to send, and an XofReader +/// to use in generating circuit keys. +fn server_handshake_obfs4( + rng: &mut RNG, + reply_fn: &mut REPLY, + message: &[u8], + keys: &[O5NtorSecretKey], + verification: &[u8], +) -> RelayHandshakeResult<(Vec, Obfs4NtorXofReader)> { + let secret_key_y = curve25519::StaticSecret::random_from_rng(rng); + server_handshake_obfs4_no_keygen(reply_fn, &secret_key_y, message, keys, verification) +} + +/// As `server_handshake_obfs4`, but take a secret key instead of an RNG. +fn server_handshake_obfs4_no_keygen( + reply_fn: &mut REPLY, + secret_key_y: &curve25519::StaticSecret, + message: &[u8], + keys: &[O5NtorSecretKey], + verification: &[u8], +) -> RelayHandshakeResult<(Vec, Obfs4NtorXofReader)> { + // Decode the message. + let mut r = Reader::from_slice(message); + let id: Ed25519Identity = r.extract()?; + + let pk_buf: [u8;32] = r.extract()?; + let requested_pk = curve25519::PublicKey::from(pk_buf); + let pk_buf: [u8;32] = r.extract()?; + let client_pk = curve25519::PublicKey::from(pk_buf); + let client_msg = if let Some(msg_len) = r.remaining().checked_sub(MAC_LEN) { + r.take(msg_len)? + } else { + return Err(tor_bytes::Error::Truncated.into()); + }; + let msg_mac: MacVal = r.extract()?; + r.should_be_exhausted()?; + + // See if we recognize the provided (id,requested_pk) pair. + let keypair = ct_lookup(keys, |key| key.matches(id, requested_pk)); + let keypair = match keypair { + Some(k) => k, + None => return Err(RelayHandshakeError::MissingKey), + }; + + let xb = keypair.sk.diffie_hellman(&client_pk); + let (enc_key, mut mac) = kdf_msgkdf(&xb, &keypair.pk, &client_pk, verification) + .map_err(into_internal!("Can't apply obfs4 kdf."))?; + // Verify the message we received. + let computed_mac: DigestVal = { + use digest::Digest; + mac.write(client_msg) + .map_err(into_internal!("Can't compute MAC input."))?; + mac.take().finalize().into() + }; + let y_pk: curve25519::PublicKey = (secret_key_y).into(); + let xy = secret_key_y.diffie_hellman(&client_pk); + + let mut okay = computed_mac.ct_eq(&msg_mac) + & ct::bool_to_choice(xy.was_contributory()) + & ct::bool_to_choice(xb.was_contributory()); + + let plaintext_msg = decrypt(&enc_key, client_msg); + + // Handle the message and decide how to reply. + let reply = reply_fn.reply(&plaintext_msg); + + // It's not exactly constant time to use is_some() and + // unwrap_or_else() here, but that should be somewhat + // hidden by the rest of the computation. + okay &= ct::bool_to_choice(reply.is_some()); + let reply = reply.unwrap_or_default(); + + // If we reach this point, we are actually replying, or pretending + // that we're going to reply. + + let secret_input = { + let mut si = SecretBuf::new(); + si.write(&xy.as_bytes()) + .and_then(|_| si.write(&xb.as_bytes())) + .and_then(|_| si.write(&keypair.pk.id)) + .and_then(|_| si.write(&keypair.pk.pk.as_bytes())) + .and_then(|_| si.write(&client_pk.as_bytes())) + .and_then(|_| si.write(&y_pk.as_bytes())) + .and_then(|_| si.write(PROTOID)) + .and_then(|_| si.write(&Encap(verification))) + .map_err(into_internal!("can't derive obfs4 secret_input"))?; + si + }; + let ntor_key_seed = h_key_seed(&secret_input); + let verify = h_verify(&secret_input); + + let (enc_key, keystream) = { + use digest::{ExtendableOutput, XofReader}; + let mut xof = DigestWriter(Shake256::default()); + xof.write(&T_FINAL) + .and_then(|_| xof.write(&ntor_key_seed)) + .map_err(into_internal!("can't generate obfs4 xof."))?; + let mut r = xof.take().finalize_xof(); + let mut enc_key = Zeroizing::new([0_u8; ENC_KEY_LEN]); + r.read(&mut enc_key[..]); + (enc_key, r) + }; + let encrypted_reply = encrypt(&enc_key, &reply); + let auth: DigestVal = { + use digest::Digest; + let mut auth = DigestWriter(Sha256::default()); + auth.write(&T_AUTH) + .and_then(|_| auth.write(&verify)) + .and_then(|_| auth.write(&keypair.pk.id)) + .and_then(|_| auth.write(&keypair.pk.pk.as_bytes())) + .and_then(|_| auth.write(&y_pk.as_bytes())) + .and_then(|_| auth.write(&client_pk.as_bytes())) + .and_then(|_| auth.write(&msg_mac)) + .and_then(|_| auth.write(&Encap(&encrypted_reply))) + .and_then(|_| auth.write(PROTOID)) + .and_then(|_| auth.write(&b"Server"[..])) + .map_err(into_internal!("can't derive obfs4 authentication"))?; + auth.take().finalize().into() + }; + + let reply = { + let mut reply = Vec::new(); + reply + .write(&y_pk.as_bytes()) + .and_then(|_| reply.write(&auth)) + .and_then(|_| reply.write(&encrypted_reply)) + .map_err(into_internal!("can't encode obfs4 reply."))?; + reply + }; + + if okay.into() { + Ok((reply, Obfs4NtorXofReader(keystream))) + } else { + Err(RelayHandshakeError::BadClientHandshake) + } +} + +/// Finalize the handshake on the client side. +/// +/// Called after we've received a message from the relay: try to +/// complete the handshake and verify its correctness. +/// +/// On success, return the server's reply to our original encrypted message, +/// and an `XofReader` to use in generating circuit keys. +fn client_handshake_obfs4_part2( + state: &O5NtorHandshakeState, + relay_handshake: &[u8], + verification: &[u8], +) -> Result<(Vec, Obfs4NtorXofReader)> { + let mut reader = Reader::from_slice(relay_handshake); + let pk_buf: [u8;32] = reader + .extract() + .map_err(|e| Error::from_bytes_err(e, "v3 ntor handshake"))?; + let y_pk = curve25519::PublicKey::from(pk_buf); + let auth: DigestVal = reader + .extract() + .map_err(|e| Error::from_bytes_err(e, "v3 ntor handshake"))?; + let encrypted_msg = reader.into_rest(); + + // TODO: Some of this code is duplicated from the server handshake code! It + // would be better to factor it out. + let yx = state.my_sk.diffie_hellman(&y_pk); + let secret_input = { + let mut si = SecretBuf::new(); + si.write(&yx.as_bytes()) + .and_then(|_| si.write(&state.shared_secret.as_bytes())) + .and_then(|_| si.write(&state.relay_public.id)) + .and_then(|_| si.write(&state.relay_public.pk.as_bytes())) + .and_then(|_| si.write(&state.my_public.as_bytes())) + .and_then(|_| si.write(&y_pk.as_bytes())) + .and_then(|_| si.write(PROTOID)) + .and_then(|_| si.write(&Encap(verification))) + .map_err(into_internal!("error encoding obfs4 secret_input"))?; + si + }; + let ntor_key_seed = h_key_seed(&secret_input); + let verify = h_verify(&secret_input); + + let computed_auth: DigestVal = { + use digest::Digest; + let mut auth = DigestWriter(Sha256::default()); + auth.write(&T_AUTH) + .and_then(|_| auth.write(&verify)) + .and_then(|_| auth.write(&state.relay_public.id)) + .and_then(|_| auth.write(&state.relay_public.pk.as_bytes())) + .and_then(|_| auth.write(&y_pk.as_bytes())) + .and_then(|_| auth.write(&state.my_public.as_bytes())) + .and_then(|_| auth.write(&state.msg_mac)) + .and_then(|_| auth.write(&Encap(encrypted_msg))) + .and_then(|_| auth.write(PROTOID)) + .and_then(|_| auth.write(&b"Server"[..])) + .map_err(into_internal!("error encoding obfs4 authentication input"))?; + auth.take().finalize().into() + }; + + let okay = computed_auth.ct_eq(&auth) + & ct::bool_to_choice(yx.was_contributory()) + & ct::bool_to_choice(state.shared_secret.was_contributory()); + + let (enc_key, keystream) = { + use digest::{ExtendableOutput, XofReader}; + let mut xof = DigestWriter(Shake256::default()); + xof.write(&T_FINAL) + .and_then(|_| xof.write(&ntor_key_seed)) + .map_err(into_internal!("error encoding obfs4 xof input"))?; + let mut r = xof.take().finalize_xof(); + let mut enc_key = Zeroizing::new([0_u8; ENC_KEY_LEN]); + r.read(&mut enc_key[..]); + println!("{}", hex::encode(&enc_key)); + (enc_key, r) + }; + let server_reply = decrypt(&enc_key, encrypted_msg); + + if okay.into() { + Ok((server_reply, Obfs4NtorXofReader(keystream))) + } else { + Err(Error::BadCircHandshakeAuth) + } +} + +fn derive_ntor_shared( + secret_input: impl AsRef<[u8]>, + id: &ID, + b: &PublicKey, + x: &PublicKey, + y: &PublicKey, +) -> (KeySeed, Auth) { + let mut key_seed = KeySeed::default(); + let mut auth = Auth::default(); + + let mut message = secret_input.as_ref().to_vec(); + message.append(&mut b.to_bytes().to_vec()); + message.append(&mut x.to_bytes().to_vec()); + message.append(&mut y.to_bytes().to_vec()); + message.append(&mut PROTO_ID.to_vec()); + message.append(&mut id.to_bytes().to_vec()); + + let mut h = HmacSha256::new_from_slice(&T_KEY[..]).unwrap(); + h.update(message.as_ref()); + let tmp: &[u8] = &h.finalize().into_bytes()[..]; + key_seed.0 = tmp.try_into().expect("unable to write key_seed"); + + let mut h = HmacSha256::new_from_slice(&T_VERIFY[..]).unwrap(); + h.update(message.as_ref()); + let mut verify = h.finalize().into_bytes().to_vec(); + + // auth_input = verify | ID | B | Y | X | PROTOID | "Server" + verify.append(&mut message.to_vec()); + verify.append(&mut b"Server".to_vec()); + let mut h = HmacSha256::new_from_slice(&T_MAC[..]).unwrap(); + h.update(verify.as_ref()); + let mut tmp = &h.finalize().into_bytes()[..]; + auth.0 = tmp.try_into().expect("unable to write auth"); + + (key_seed, auth) +} + +#[cfg(test)] +mod integration; diff --git a/crates/o5/src/lib.rs b/crates/o5/src/lib.rs index f14f12c..ab7f616 100644 --- a/crates/o5/src/lib.rs +++ b/crates/o5/src/lib.rs @@ -1,9 +1,44 @@ #![doc = include_str!("../README.md")] +pub mod client; +pub mod common; +pub mod server; -mod framing; -// mod handshake; -// mod transport; +pub mod framing; +pub mod proto; +pub use client::{Client, ClientBuilder}; +pub use server::{Server, ServerBuilder}; + +pub(crate) mod constants; +pub(crate) mod handshake; +pub(crate) mod sessions; + +#[cfg(test)] +mod testing; + +mod pt; +pub use pt::{O5PT, Transport}; + +mod error; +pub use error::{Error, Result}; + +pub const OBFS4_NAME: &str = "obfs4"; + +#[cfg(test)] +pub(crate) mod test_utils; + +#[cfg(debug_assertions)] +pub mod dev { + /// Pre-generated / shared key for use while running in debug mode. + pub const DEV_PRIV_KEY: &[u8; 32] = b"0123456789abcdeffedcba9876543210"; + + /// Client obfs4 arguments based on pre-generated dev key `DEV_PRIV_KEY`. + pub const CLIENT_ARGS: &str = + "cert=AAAAAAAAAAAAAAAAAAAAAAAAAADTSFvsGKxNFPBcGdOCBSgpEtJInG9zCYZezBPVBuBWag;iat-mode=0"; + + /// Server obfs4 arguments based on pre-generated dev key `DEV_PRIV_KEY`. + pub const SERVER_ARGS: &str = "drbg-seed=0a0b0c0d0e0f0a0b0c0d0e0f0a0b0c0d0e0f0a0b0c0d0e0f;node-id=0000000000000000000000000000000000000000;private-key=3031323334353637383961626364656666656463626139383736353433323130;iat-mode=0"; +} #[cfg(test)] #[allow(unused)] diff --git a/crates/o5/src/proto.rs b/crates/o5/src/proto.rs new file mode 100644 index 0000000..ae1a2f5 --- /dev/null +++ b/crates/o5/src/proto.rs @@ -0,0 +1,373 @@ +use crate::{ + common::{ + drbg, + probdist::{self, WeightedDist}, + }, + constants::*, + framing, + sessions::Session, + Error, Result, +}; + +use bytes::{Buf, BytesMut}; +use futures::{Sink, Stream}; +use pin_project::pin_project; +use ptrs::trace; +use sha2::{Digest, Sha256}; +use tokio::io::{AsyncRead, AsyncWrite, ReadBuf}; +use tokio::time::{Duration, Instant}; +use tokio_util::codec::Framed; + +use std::{ + io::Error as IoError, + pin::Pin, + result::Result as StdResult, + task::{Context, Poll}, +}; + +use super::framing::{FrameError, Messages}; + +#[allow(dead_code, unused)] +#[derive(Default, Debug, Clone, Copy, PartialEq)] +pub enum IAT { + #[default] + Off, + Enabled, + Paranoid, +} + +#[derive(Debug, Clone)] +pub(crate) enum MaybeTimeout { + Default_, + Fixed(Instant), + Length(Duration), + Unset, +} + +impl std::str::FromStr for IAT { + type Err = Error; + fn from_str(s: &str) -> StdResult { + match s { + "0" => Ok(IAT::Off), + "1" => Ok(IAT::Enabled), + "2" => Ok(IAT::Paranoid), + _ => Err(format!("invalid iat-mode '{s}'").into()), + } + } +} + +impl std::fmt::Display for IAT { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + IAT::Off => write!(f, "0")?, + IAT::Enabled => write!(f, "1")?, + IAT::Paranoid => write!(f, "2")?, + } + Ok(()) + } +} + +impl MaybeTimeout { + pub(crate) fn duration(&self) -> Option { + match self { + MaybeTimeout::Default_ => Some(CLIENT_HANDSHAKE_TIMEOUT), + MaybeTimeout::Fixed(i) => { + if *i < Instant::now() { + None + } else { + Some(*i - Instant::now()) + } + } + MaybeTimeout::Length(d) => Some(*d), + MaybeTimeout::Unset => None, + } + } +} + +#[pin_project] +pub struct O5Stream +where + T: AsyncRead + AsyncWrite + Unpin, +{ + // s: Arc>>, + #[pin] + s: O4Stream, +} + +impl O5Stream +where + T: AsyncRead + AsyncWrite + Unpin, +{ + pub(crate) fn from_o4(o4: O4Stream) -> Self { + O5Stream { + // s: Arc::new(Mutex::new(o4)), + s: o4, + } + } +} + +#[pin_project] +pub(crate) struct O4Stream +where + T: AsyncRead + AsyncWrite + Unpin, +{ + #[pin] + pub stream: Framed, + + pub length_dist: probdist::WeightedDist, + pub iat_dist: probdist::WeightedDist, + + pub session: Session, +} + +impl O4Stream +where + T: AsyncRead + AsyncWrite + Unpin, +{ + pub(crate) fn new( + // inner: &'a mut dyn Stream<'a>, + inner: T, + codec: framing::O5Codec, + session: Session, + ) -> O4Stream { + let stream = Framed::new(inner, codec); + let len_seed = session.len_seed(); + + let mut hasher = Sha256::new(); + hasher.update(len_seed.as_bytes()); + // the result of a sha256 haash is 32 bytes (256 bits) so we will + // always have enough for a seed here. + let iat_seed = drbg::Seed::try_from(&hasher.finalize()[..SEED_LENGTH]).unwrap(); + + let length_dist = WeightedDist::new( + len_seed, + 0, + framing::MAX_SEGMENT_LENGTH as i32, + session.biased(), + ); + let iat_dist = WeightedDist::new( + iat_seed, + 0, + framing::MAX_SEGMENT_LENGTH as i32, + session.biased(), + ); + + Self { + stream, + session, + length_dist, + iat_dist, + } + } + + pub(crate) fn try_handle_non_payload_message(&mut self, msg: framing::Messages) -> Result<()> { + match msg { + Messages::Payload(_) => Err(FrameError::InvalidMessage.into()), + Messages::Padding(_) => Ok(()), + + // TODO: Handle other Messages + _ => Ok(()), + } + } + + /*// TODO Apply pad_burst logic and IAT policy to packet assembly (probably as part of AsyncRead / AsyncWrite impl) + /// Attempts to pad a burst of data so that the last packet is of the length + /// `to_pad_to`. This can involve creating multiple packets, making this + /// slightly complex. + /// + /// TODO: document logic more clearly + pub(crate) fn pad_burst(&self, buf: &mut BytesMut, to_pad_to: usize) -> Result<()> { + let tail_len = buf.len() % framing::MAX_SEGMENT_LENGTH; + + let pad_len: usize = if to_pad_to >= tail_len { + to_pad_to - tail_len + } else { + (framing::MAX_SEGMENT_LENGTH - tail_len) + to_pad_to + }; + + if pad_len > HEADER_LENGTH { + // pad_len > 19 + Ok(framing::build_and_marshall( + buf, + MessageTypes::Payload.into(), + vec![], + pad_len - HEADER_LENGTH, + )?) + } else if pad_len > 0 { + framing::build_and_marshall( + buf, + MessageTypes::Payload.into(), + vec![], + framing::MAX_MESSAGE_PAYLOAD_LENGTH, + )?; + // } else { + Ok(framing::build_and_marshall( + buf, + MessageTypes::Payload.into(), + vec![], + pad_len, + )?) + } else { + Ok(()) + } + } */ +} + +impl AsyncWrite for O4Stream +where + T: AsyncRead + AsyncWrite + Unpin, +{ + fn poll_write( + mut self: Pin<&mut Self>, + cx: &mut Context<'_>, + buf: &[u8], + ) -> Poll> { + let msg_len = buf.remaining(); + let mut this = self.as_mut().project(); + + // determine if the stream is ready to send an event? + if futures::Sink::<&[u8]>::poll_ready(this.stream.as_mut(), cx) == Poll::Pending { + return Poll::Pending; + } + + // while we have bytes in the buffer write MAX_MESSAGE_PAYLOAD_LENGTH + // chunks until we have less than that amount left. + // TODO: asyncwrite - apply length_dist instead of just full payloads + let mut len_sent: usize = 0; + let mut out_buf = BytesMut::with_capacity(framing::MAX_MESSAGE_PAYLOAD_LENGTH); + while msg_len - len_sent > framing::MAX_MESSAGE_PAYLOAD_LENGTH { + // package one chunk of the mesage as a payload + let payload = framing::Messages::Payload( + buf[len_sent..len_sent + framing::MAX_MESSAGE_PAYLOAD_LENGTH].to_vec(), + ); + + // send the marshalled payload + payload.marshall(&mut out_buf)?; + this.stream.as_mut().start_send(&mut out_buf)?; + + len_sent += framing::MAX_MESSAGE_PAYLOAD_LENGTH; + out_buf.clear(); + + // determine if the stream is ready to send more data. if not back off + if futures::Sink::<&[u8]>::poll_ready(this.stream.as_mut(), cx) == Poll::Pending { + return Poll::Ready(Ok(len_sent)); + } + } + + let payload = framing::Messages::Payload(buf[len_sent..].to_vec()); + + let mut out_buf = BytesMut::new(); + payload.marshall(&mut out_buf)?; + this.stream.as_mut().start_send(out_buf)?; + + Poll::Ready(Ok(msg_len)) + } + + fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + trace!("{} flushing", self.session.id()); + let mut this = self.project(); + match futures::Sink::<&[u8]>::poll_flush(this.stream.as_mut(), cx) { + Poll::Ready(Ok(_)) => Poll::Ready(Ok(())), + Poll::Ready(Err(e)) => Poll::Ready(Err(e.into())), + Poll::Pending => Poll::Pending, + } + } + + fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + trace!("{} shutting down", self.session.id()); + let mut this = self.project(); + match futures::Sink::<&[u8]>::poll_close(this.stream.as_mut(), cx) { + Poll::Ready(Ok(_)) => Poll::Ready(Ok(())), + Poll::Ready(Err(e)) => Poll::Ready(Err(e.into())), + Poll::Pending => Poll::Pending, + } + } +} + +impl AsyncRead for O4Stream +where + T: AsyncRead + AsyncWrite + Unpin, +{ + fn poll_read( + mut self: Pin<&mut Self>, + cx: &mut Context<'_>, + buf: &mut ReadBuf<'_>, + ) -> Poll> { + // If there is no payload from the previous Read() calls, consume data off + // the network. Not all data received is guaranteed to be usable payload, + // so do this in a loop until we would block on a read or an error occurs. + loop { + let msg = { + // mutable borrow of self is dropped at the end of this block + let mut this = self.as_mut().project(); + match this.stream.as_mut().poll_next(cx) { + Poll::Pending => return Poll::Pending, + Poll::Ready(res) => { + // TODO: when would this be None? + // It seems like this maybe happens when reading an EOF + // or reading from a closed connection + if res.is_none() { + return Poll::Ready(Ok(())); + } + + match res.unwrap() { + Ok(m) => m, + Err(e) => Err(e)?, + } + } + } + }; + + if let framing::Messages::Payload(message) = msg { + buf.put_slice(&message); + return Poll::Ready(Ok(())); + } + if let Messages::Padding(_) = msg { + continue; + } + + match self.as_mut().try_handle_non_payload_message(msg) { + Ok(_) => continue, + Err(e) => return Poll::Ready(Err(e.into())), + } + } + } +} + +impl AsyncWrite for O5Stream +where + T: AsyncRead + AsyncWrite + Unpin, +{ + fn poll_write( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + buf: &[u8], + ) -> Poll> { + let this = self.project(); + this.s.poll_write(cx, buf) + } + + fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + let this = self.project(); + this.s.poll_flush(cx) + } + + fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + let this = self.project(); + this.s.poll_shutdown(cx) + } +} + +impl AsyncRead for O5Stream +where + T: AsyncRead + AsyncWrite + Unpin, +{ + fn poll_read( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + buf: &mut ReadBuf<'_>, + ) -> Poll> { + let this = self.project(); + this.s.poll_read(cx, buf) + } +} diff --git a/crates/o5/src/pt.rs b/crates/o5/src/pt.rs new file mode 100644 index 0000000..9988807 --- /dev/null +++ b/crates/o5/src/pt.rs @@ -0,0 +1,274 @@ +use crate::{ + constants::*, + handshake::O5NtorPublicKey, + proto::{O5Stream, IAT}, + Error, OBFS4_NAME, +}; +use ptrs::{args::Args, FutureResult as F}; + +use std::{ + marker::PhantomData, + net::{SocketAddrV4, SocketAddrV6}, + pin::Pin, + str::FromStr, + time::Duration, +}; + +use hex::FromHex; +use ptrs::trace; +use tokio::{ + io::{AsyncRead, AsyncWrite}, + net::TcpStream, +}; + +pub type O5PT = Transport; + +#[derive(Debug, Default)] +pub struct Transport { + _p: PhantomData, +} +impl Transport { + pub const NAME: &'static str = OBFS4_NAME; +} + +impl ptrs::PluggableTransport for Transport +where + T: AsyncRead + AsyncWrite + Send + Sync + Unpin + 'static, +{ + type ClientBuilder = crate::ClientBuilder; + type ServerBuilder = crate::ServerBuilder; + + fn name() -> String { + OBFS4_NAME.into() + } + + fn client_builder() -> >::ClientBuilder { + crate::ClientBuilder::default() + } + + fn server_builder() -> >::ServerBuilder { + crate::ServerBuilder::default() + } +} + +impl ptrs::ServerBuilder for crate::ServerBuilder +where + T: AsyncRead + AsyncWrite + Send + Sync + Unpin + 'static, +{ + type ServerPT = crate::Server; + type Error = Error; + type Transport = Transport; + + fn build(&self) -> Self::ServerPT { + crate::ServerBuilder::build(self) + } + + fn method_name() -> String { + OBFS4_NAME.into() + } + + fn options(&mut self, opts: &Args) -> Result<&mut Self, Self::Error> { + // TODO: pass on opts + + let state = Self::parse_state(None::<&str>, opts)?; + self.identity_keys = state.private_key; + self.iat_mode(state.iat_mode); + // self.drbg = state.drbg_seed; // TODO apply seed from args to server + + trace!( + "node_pubkey: {}, node_id: {}, iat: {}", + hex::encode(self.identity_keys.pk.pk.as_bytes()), + hex::encode(self.identity_keys.pk.id.as_bytes()), + self.iat_mode, + ); + Ok(self) + } + + fn get_client_params(&self) -> String { + self.client_params() + } + + fn statefile_location(&mut self, _path: &str) -> Result<&mut Self, Self::Error> { + Ok(self) + } + + fn timeout(&mut self, _timeout: Option) -> Result<&mut Self, Self::Error> { + Ok(self) + } + + fn v4_bind_addr(&mut self, _addr: SocketAddrV4) -> Result<&mut Self, Self::Error> { + Ok(self) + } + + fn v6_bind_addr(&mut self, _addr: SocketAddrV6) -> Result<&mut Self, Self::Error> { + Ok(self) + } +} + +impl ptrs::ClientBuilder for crate::ClientBuilder +where + T: AsyncRead + AsyncWrite + Send + Sync + Unpin + 'static, +{ + type ClientPT = crate::Client; + type Error = Error; + type Transport = Transport; + + fn method_name() -> String { + OBFS4_NAME.into() + } + + /// Builds a new PtCommonParameters. + /// + /// **Errors** + /// If a required field has not been initialized. + fn build(&self) -> Self::ClientPT { + crate::ClientBuilder::build(self) + } + + /// Pluggable transport attempts to parse and validate options from a string, + /// typically using ['parse_smethod_args']. + fn options(&mut self, opts: &Args) -> Result<&mut Self, Self::Error> { + let server_materials = match opts.retrieve(CERT_ARG) { + Some(cert_strs) => { + // The "new" (version >= 0.0.3) bridge lines use a unified "cert" argument + // for the Node ID and Public Key. + if cert_strs.is_empty() { + return Err(format!("missing argument '{NODE_ID_ARG}'").into()); + } + trace!("cert string: {}", &cert_strs); + let ntor_pk = O5NtorPublicKey::from_str(&cert_strs)?; + let pk: [u8; NODE_PUBKEY_LENGTH] = *ntor_pk.pk.as_bytes(); + let id: [u8; NODE_ID_LENGTH] = ntor_pk.id.as_bytes().try_into().unwrap(); + (pk, id) + } + None => { + // The "old" style (version <= 0.0.2) bridge lines use separate Node ID + // and Public Key arguments in Base16 encoding and are a UX disaster. + let node_id_strs = opts + .retrieve(NODE_ID_ARG) + .ok_or(format!("missing argument '{NODE_ID_ARG}'"))?; + let id = <[u8; NODE_ID_LENGTH]>::from_hex(node_id_strs) + .map_err(|e| format!("malformed node id: {e}"))?; + + let public_key_strs = opts + .retrieve(PUBLIC_KEY_ARG) + .ok_or(format!("missing argument '{PUBLIC_KEY_ARG}'"))?; + + let pk = <[u8; 32]>::from_hex(public_key_strs) + .map_err(|e| format!("malformed public key: {e}"))?; + // O5NtorPublicKey::new(pk, node_id) + (pk, id) + } + }; + + // IAT config is common across the two bridge line formats. + let iat_strs = opts + .retrieve(IAT_ARG) + .ok_or(format!("missing argument '{IAT_ARG}'"))?; + let iat_mode = IAT::from_str(&iat_strs)?; + + self.with_node_pubkey(server_materials.0) + .with_node_id(server_materials.1) + .with_iat_mode(iat_mode); + trace!( + "node_pubkey: {}, node_id: {}, iat: {}", + hex::encode(self.station_pubkey), + hex::encode(self.station_id), + iat_mode + ); + + Ok(self) + } + + /// A path where the launched PT can store state. + fn statefile_location(&mut self, _path: &str) -> Result<&mut Self, Self::Error> { + Ok(self) + } + + /// The maximum time we should wait for a pluggable transport binary to + /// report successful initialization. If `None`, a default value is used. + fn timeout(&mut self, _timeout: Option) -> Result<&mut Self, Self::Error> { + Ok(self) + } + + /// An IPv4 address to bind outgoing connections to (if specified). + /// + /// Leaving this out will mean the PT uses a sane default. + fn v4_bind_addr(&mut self, _addr: SocketAddrV4) -> Result<&mut Self, Self::Error> { + Ok(self) + } + + /// An IPv6 address to bind outgoing connections to (if specified). + /// + /// Leaving this out will mean the PT uses a sane default. + fn v6_bind_addr(&mut self, _addr: SocketAddrV6) -> Result<&mut Self, Self::Error> { + Ok(self) + } +} + +/// Example wrapping transport that just passes the incoming connection future through +/// unmodified as a proof of concept. +impl ptrs::ClientTransport for crate::Client +where + InRW: AsyncRead + AsyncWrite + Send + Sync + Unpin + 'static, + InErr: std::error::Error + Send + Sync + 'static, +{ + type OutRW = O5Stream; + type OutErr = Error; + type Builder = crate::ClientBuilder; + + fn establish(self, input: Pin>) -> Pin> { + Box::pin(crate::Client::establish(self, input)) + } + + fn wrap(self, io: InRW) -> Pin> { + Box::pin(crate::Client::wrap(self, io)) + } + + fn method_name() -> String { + OBFS4_NAME.into() + } +} + +impl ptrs::ServerTransport for crate::Server +where + InRW: AsyncRead + AsyncWrite + Send + Sync + Unpin + 'static, +{ + type OutRW = O5Stream; + type OutErr = Error; + type Builder = crate::ServerBuilder; + + /// Use something that can be accessed reference (Arc, Rc, etc.) + fn reveal(self, io: InRW) -> Pin> { + Box::pin(crate::Server::wrap(self, io)) + } + + fn method_name() -> String { + OBFS4_NAME.into() + } +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn check_name() { + let pt_name = >::name(); + assert_eq!(pt_name, O5PT::NAME); + + let cb_name = >::method_name(); + assert_eq!(cb_name, O5PT::NAME); + + let sb_name = + as ptrs::ServerBuilder>::method_name(); + assert_eq!(sb_name, O5PT::NAME); + + let ct_name = + >::method_name(); + assert_eq!(ct_name, O5PT::NAME); + + let st_name = >::method_name(); + assert_eq!(st_name, O5PT::NAME); + } +} diff --git a/crates/o5/src/server.rs b/crates/o5/src/server.rs new file mode 100644 index 0000000..74287c3 --- /dev/null +++ b/crates/o5/src/server.rs @@ -0,0 +1,386 @@ +#![allow(unused)] + +use super::*; +use crate::{ + client::ClientBuilder, + common::{ + colorize, + curve25519::{PublicKey, StaticSecret}, + drbg, + replay_filter::{self, ReplayFilter}, + HmacSha256, + }, + constants::*, + framing::{FrameError, Marshall, O5Codec, TryParse, KEY_LENGTH}, + handshake::{O5NtorPublicKey, O5NtorSecretKey}, + proto::{MaybeTimeout, O5Stream, IAT}, + sessions::Session, + Error, Result, +}; +use ptrs::args::Args; + +use std::{borrow::BorrowMut, marker::PhantomData, ops::Deref, str::FromStr, sync::Arc}; + +use bytes::{Buf, BufMut, Bytes}; +use hex::FromHex; +use hmac::{Hmac, Mac}; +use ptrs::{debug, info}; +use rand::prelude::*; +use subtle::ConstantTimeEq; +use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}; +use tokio::time::{Duration, Instant}; +use tokio_util::codec::Encoder; +use tor_llcrypto::pk::rsa::RsaIdentity; + +const STATE_FILENAME: &str = "obfs4_state.json"; + +pub struct ServerBuilder { + pub iat_mode: IAT, + pub statefile_path: Option, + pub(crate) identity_keys: O5NtorSecretKey, + pub(crate) handshake_timeout: MaybeTimeout, + // pub(crate) drbg: Drbg, // TODO: build in DRBG + _stream_type: PhantomData, +} + +impl Default for ServerBuilder { + fn default() -> Self { + let identity_keys = O5NtorSecretKey::getrandom(); + Self { + iat_mode: IAT::Off, + statefile_path: None, + identity_keys, + handshake_timeout: MaybeTimeout::Default_, + _stream_type: PhantomData, + } + } +} + +impl ServerBuilder { + /// 64 byte combined representation of an x25519 public key, private key + /// combination. + pub fn node_keys(&mut self, keys: [u8; KEY_LENGTH * 2]) -> &Self { + let sk: [u8; KEY_LENGTH] = keys[..KEY_LENGTH].try_into().unwrap(); + let pk: [u8; KEY_LENGTH] = keys[KEY_LENGTH..].try_into().unwrap(); + self.identity_keys.sk = sk.into(); + self.identity_keys.pk.pk = (&self.identity_keys.sk).into(); + self + } + + pub fn statefile_path(&mut self, path: &str) -> &Self { + self.statefile_path = Some(path.into()); + self + } + + pub fn node_id(&mut self, id: [u8; NODE_ID_LENGTH]) -> &Self { + self.identity_keys.pk.id = id.into(); + self + } + + pub fn iat_mode(&mut self, iat: IAT) -> &Self { + self.iat_mode = iat; + self + } + + pub fn with_handshake_timeout(&mut self, d: Duration) -> &Self { + self.handshake_timeout = MaybeTimeout::Length(d); + self + } + + pub fn with_handshake_deadline(&mut self, deadline: Instant) -> &Self { + self.handshake_timeout = MaybeTimeout::Fixed(deadline); + self + } + + pub fn fail_fast(&mut self) -> &Self { + self.handshake_timeout = MaybeTimeout::Unset; + self + } + + pub fn client_params(&self) -> String { + let mut params = Args::new(); + params.insert(CERT_ARG.into(), vec![self.identity_keys.pk.to_string()]); + params.insert(IAT_ARG.into(), vec![self.iat_mode.to_string()]); + params.encode_smethod_args() + } + + pub fn build(&self) -> Server { + Server(Arc::new(ServerInner { + identity_keys: self.identity_keys.clone(), + iat_mode: self.iat_mode, + biased: false, + handshake_timeout: self.handshake_timeout.duration(), + + // metrics: Arc::new(std::sync::Mutex::new(ServerMetrics {})), + replay_filter: ReplayFilter::new(REPLAY_TTL), + })) + } + + pub fn validate_args(args: &Args) -> Result<()> { + let _ = RequiredServerState::try_from(args)?; + + Ok(()) + } + + pub(crate) fn parse_state( + statedir: Option>, + args: &Args, + ) -> Result { + if statedir.is_none() { + return RequiredServerState::try_from(args); + } + + // if the provided arguments do not satisfy all required arguments, we + // attempt to parse the server state from json IFF a statedir path was + // provided. Otherwise this method just fails. + let mut required_args = args.clone(); + match RequiredServerState::try_from(args) { + Ok(state) => Ok(state), + Err(e) => { + Self::server_state_from_file(statedir.unwrap(), &mut required_args)?; + RequiredServerState::try_from(&required_args) + } + } + } + + fn server_state_from_file(statedir: impl AsRef, args: &mut Args) -> Result<()> { + let mut file_path = String::from(statedir.as_ref()); + file_path.push_str(STATE_FILENAME); + + let state_str = std::fs::read(file_path)?; + + Self::server_state_from_json(&state_str[..], args) + } + + fn server_state_from_json(state_rdr: impl std::io::Read, args: &mut Args) -> Result<()> { + let state: JsonServerState = + serde_json::from_reader(state_rdr).map_err(|e| Error::Other(Box::new(e)))?; + + state.extend_args(args); + Ok(()) + } +} + +#[derive(Debug, serde::Serialize, serde::Deserialize)] +struct JsonServerState { + #[serde(rename = "node-id")] + node_id: Option, + #[serde(rename = "private-key")] + private_key: Option, + #[serde(rename = "public-key")] + public_key: Option, + #[serde(rename = "drbg-seed")] + drbg_seed: Option, + #[serde(rename = "iat-mode")] + iat_mode: Option, +} + +impl JsonServerState { + fn extend_args(self, args: &mut Args) { + if let Some(id) = self.node_id { + args.add(NODE_ID_ARG, &id); + } + if let Some(sk) = self.private_key { + args.add(PRIVATE_KEY_ARG, &sk); + } + if let Some(pubkey) = self.public_key { + args.add(PUBLIC_KEY_ARG, &pubkey); + } + if let Some(seed) = self.drbg_seed { + args.add(SEED_ARG, &seed); + } + if let Some(mode) = self.iat_mode { + args.add(IAT_ARG, &mode); + } + } +} + +pub(crate) struct RequiredServerState { + pub(crate) private_key: O5NtorSecretKey, + pub(crate) drbg_seed: drbg::Drbg, + pub(crate) iat_mode: IAT, +} + +impl TryFrom<&Args> for RequiredServerState { + type Error = Error; + fn try_from(value: &Args) -> std::prelude::v1::Result { + let privkey_str = value + .retrieve(PRIVATE_KEY_ARG) + .ok_or("missing argument {PRIVATE_KEY_ARG}")?; + let sk = <[u8; KEY_LENGTH]>::from_hex(privkey_str)?; + + let drbg_seed_str = value + .retrieve(SEED_ARG) + .ok_or("missing argument {SEED_ARG}")?; + let drbg_seed = drbg::Seed::from_hex(drbg_seed_str)?; + + let node_id_str = value + .retrieve(NODE_ID_ARG) + .ok_or("missing argument {NODE_ID_ARG}")?; + let node_id = <[u8; NODE_ID_LENGTH]>::from_hex(node_id_str)?; + + let iat_mode = match value.retrieve(IAT_ARG) { + Some(s) => IAT::from_str(&s)?, + None => IAT::default(), + }; + + let secret_key = StaticSecret::from(sk); + let private_key = O5NtorSecretKey::new(secret_key, RsaIdentity::from(node_id)); + + Ok(RequiredServerState { + private_key, + drbg_seed: drbg::Drbg::new(Some(drbg_seed))?, + iat_mode, + }) + } +} + +#[derive(Clone)] +pub struct Server(Arc); + +pub struct ServerInner { + pub(crate) handshake_timeout: Option, + pub(crate) iat_mode: IAT, + pub(crate) biased: bool, + pub(crate) identity_keys: O5NtorSecretKey, + + pub(crate) replay_filter: ReplayFilter, + // pub(crate) metrics: Metrics, +} + +impl Deref for Server { + type Target = ServerInner; + fn deref(&self) -> &Self::Target { + self.0.as_ref() + } +} + +impl Server { + pub fn new(sec: [u8; KEY_LENGTH], id: [u8; NODE_ID_LENGTH]) -> Self { + let sk = StaticSecret::from(sec); + let pk = O5NtorPublicKey { + pk: PublicKey::from(&sk), + id: id.into(), + }; + + let identity_keys = O5NtorSecretKey { pk, sk }; + + Self::new_from_key(identity_keys) + } + + pub(crate) fn new_from_key(identity_keys: O5NtorSecretKey) -> Self { + Self(Arc::new(ServerInner { + handshake_timeout: Some(SERVER_HANDSHAKE_TIMEOUT), + identity_keys, + iat_mode: IAT::Off, + biased: false, + + // metrics: Arc::new(std::sync::Mutex::new(ServerMetrics {})), + replay_filter: ReplayFilter::new(REPLAY_TTL), + })) + } + + pub fn new_from_random(mut rng: R) -> Self { + let mut id = [0_u8; 20]; + // Random bytes will work for testing, but aren't necessarily actually a valid id. + rng.fill_bytes(&mut id); + + // Generated identity secret key does not need to be elligator2 representable + // so we can use the regular dalek_x25519 key generation. + let sk = StaticSecret::random_from_rng(rng); + + let pk = O5NtorPublicKey { + pk: PublicKey::from(&sk), + id: id.into(), + }; + + let identity_keys = O5NtorSecretKey { pk, sk }; + + Self::new_from_key(identity_keys) + } + + pub fn getrandom() -> Self { + let identity_keys = O5NtorSecretKey::getrandom(); + Self::new_from_key(identity_keys) + } + + pub async fn wrap(self, stream: T) -> Result> + where + T: AsyncRead + AsyncWrite + Unpin, + { + let session = self.new_server_session()?; + let deadline = self.handshake_timeout.map(|d| Instant::now() + d); + + session.handshake(&self, stream, deadline).await + } + + // pub fn set_iat_mode(&mut self, mode: IAT) -> &Self { + // self.iat_mode = mode; + // self + // } + + pub fn set_args(&mut self, args: &dyn std::any::Any) -> Result<&Self> { + Ok(self) + } + + pub fn new_from_statefile() -> Result { + Err(Error::NotImplemented) + } + + pub fn write_statefile(f: std::fs::File) -> Result<()> { + Err(Error::NotImplemented) + } + + pub fn client_params(&self) -> ClientBuilder { + ClientBuilder { + station_pubkey: *self.identity_keys.pk.pk.as_bytes(), + station_id: self.identity_keys.pk.id.as_bytes().try_into().unwrap(), + iat_mode: self.iat_mode, + statefile_path: None, + handshake_timeout: MaybeTimeout::Default_, + } + } + + pub(crate) fn new_server_session( + &self, + ) -> Result> { + let mut session_id = [0u8; SESSION_ID_LEN]; + rand::thread_rng().fill_bytes(&mut session_id); + Ok(sessions::ServerSession { + // fixed by server + identity_keys: self.identity_keys.clone(), + biased: self.biased, + + // generated per session + session_id, + len_seed: drbg::Seed::new().unwrap(), + iat_seed: drbg::Seed::new().unwrap(), + + _state: sessions::Initialized {}, + }) + } +} + +#[cfg(test)] +mod tests { + use crate::dev; + + use super::*; + + use ptrs::trace; + use tokio::net::TcpStream; + + #[test] + fn parse_json_state() -> Result<()> { + crate::test_utils::init_subscriber(); + + let mut args = Args::new(); + let test_state = format!( + r#"{{"{NODE_ID_ARG}": "00112233445566778899", "{PRIVATE_KEY_ARG}":"0123456789abcdeffedcba9876543210", "{IAT_ARG}": "0", "{SEED_ARG}": "abcdefabcdefabcdefabcdef"}}"# + ); + ServerBuilder::::server_state_from_json(test_state.as_bytes(), &mut args)?; + debug!("{:?}\n{}", args.encode_smethod_args(), test_state); + + Ok(()) + } +} diff --git a/crates/o5/src/sessions.rs b/crates/o5/src/sessions.rs new file mode 100644 index 0000000..694f944 --- /dev/null +++ b/crates/o5/src/sessions.rs @@ -0,0 +1,497 @@ +//! obfs4 session details and construction +//! +/// Session state management as a way to organize session establishment and +/// steady state transfer. +use crate::{ + common::{ + colorize, discard, drbg, + ntor_arti::{ClientHandshake, RelayHandshakeError, ServerHandshake}, + }, + constants::*, + framing, + handshake::{ + CHSMaterials, O5Keygen, O5NtorHandshake, O5NtorPublicKey, O5NtorSecretKey, + SHSMaterials, + }, + proto::{O4Stream, O5Stream, IAT}, + server::Server, + Error, Result, +}; + +use std::io::{Error as IoError, ErrorKind as IoErrorKind}; + +use bytes::BytesMut; +use ptrs::{debug, info, trace}; +use rand_core::RngCore; +use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}; +use tokio::time::Instant; +use tokio_util::codec::Decoder; + +/// Initial state for a Session, created with any params. +pub(crate) struct Initialized; + +/// A session has completed the handshake and made it to steady state transfer. +pub(crate) struct Established; + +/// The session broke due to something like a timeout, reset, lost connection, etc. +trait Fault {} + +pub enum Session { + Client(ClientSession), + Server(ServerSession), +} + +impl Session { + #[allow(unused)] + pub fn id(&self) -> String { + match self { + Session::Client(cs) => format!("c{}", cs.session_id()), + Session::Server(ss) => format!("s{}", ss.session_id()), + } + } + + pub fn biased(&self) -> bool { + match self { + Session::Client(cs) => cs.biased, + Session::Server(ss) => ss.biased, //biased, + } + } + + pub fn len_seed(&self) -> drbg::Seed { + match self { + Session::Client(cs) => cs.len_seed.clone(), + Session::Server(ss) => ss.len_seed.clone(), + } + } +} + +// ================================================================ // +// Client States // +// ================================================================ // + +pub(crate) struct ClientSession { + node_pubkey: O5NtorPublicKey, + session_id: [u8; SESSION_ID_LEN], + iat_mode: IAT, // TODO: add IAT normal / paranoid writing modes + epoch_hour: String, + + biased: bool, + + len_seed: drbg::Seed, + + _state: S, +} + +#[allow(unused)] +struct ClientHandshakeFailed { + details: String, +} + +struct ClientHandshaking {} + +pub(crate) trait ClientSessionState {} +impl ClientSessionState for Initialized {} +impl ClientSessionState for ClientHandshaking {} +impl ClientSessionState for Established {} + +impl ClientSessionState for ClientHandshakeFailed {} +impl Fault for ClientHandshakeFailed {} + +impl ClientSession { + pub fn session_id(&self) -> String { + String::from("c-") + &colorize(self.session_id) + } + + pub(crate) fn set_session_id(&mut self, id: [u8; SESSION_ID_LEN]) { + debug!( + "{} -> {} client updating session id", + colorize(self.session_id), + colorize(id) + ); + self.session_id = id; + } + + /// Helper function to perform state transitions. + fn transition(self, t: T) -> ClientSession { + ClientSession { + node_pubkey: self.node_pubkey, + session_id: self.session_id, + iat_mode: self.iat_mode, + epoch_hour: self.epoch_hour, + biased: self.biased, + + len_seed: self.len_seed, + _state: t, + } + } + + /// Helper function to perform state transitions. + fn fault(self, f: F) -> ClientSession { + ClientSession { + node_pubkey: self.node_pubkey, + session_id: self.session_id, + iat_mode: self.iat_mode, + epoch_hour: self.epoch_hour, + biased: self.biased, + + len_seed: self.len_seed, + _state: f, + } + } +} + +pub fn new_client_session( + station_pubkey: O5NtorPublicKey, + iat_mode: IAT, +) -> ClientSession { + let mut session_id = [0u8; SESSION_ID_LEN]; + rand::thread_rng().fill_bytes(&mut session_id); + ClientSession { + node_pubkey: station_pubkey, + session_id, + iat_mode, + epoch_hour: "".into(), + biased: false, + + len_seed: drbg::Seed::new().unwrap(), + _state: Initialized, + } +} + +impl ClientSession { + /// Perform a Handshake over the provided stream. + /// ``` + /// + /// ``` + /// + /// TODO: make sure failure modes align with golang obfs4 + /// - FIN/RST based on buffered data. + /// - etc. + pub async fn handshake( + self, + mut stream: T, + deadline: Option, + ) -> Result> + where + T: AsyncRead + AsyncWrite + Unpin, + { + // set up for handshake + let mut session = self.transition(ClientHandshaking {}); + + let materials = CHSMaterials::new(session.node_pubkey, session.session_id()); + + // default deadline + let d_def = Instant::now() + CLIENT_HANDSHAKE_TIMEOUT; + let handshake_fut = Self::complete_handshake(&mut stream, materials, deadline); + let (mut remainder, mut keygen) = + match tokio::time::timeout_at(deadline.unwrap_or(d_def), handshake_fut).await { + Ok(result) => match result { + Ok(handshake) => handshake, + Err(e) => { + // non-timeout error, + let id = session.session_id(); + let _ = session.fault(ClientHandshakeFailed { + details: format!("{id} handshake failed {e}"), + }); + return Err(e); + } + }, + Err(_) => { + let id = session.session_id(); + let _ = session.fault(ClientHandshakeFailed { + details: format!("{id} timed out"), + }); + return Err(Error::HandshakeTimeout); + } + }; + + // post-handshake state updates + session.set_session_id(keygen.session_id()); + let mut codec: framing::O5Codec = keygen.into(); + + let res = codec.decode(&mut remainder); + if let Ok(Some(framing::Messages::PrngSeed(seed))) = res { + // try to parse the remainder of the server hello packet as a + // PrngSeed since it should be there. + let len_seed = drbg::Seed::from(seed); + session.set_len_seed(len_seed); + } else { + debug!("NOPE {res:?}"); + } + + // mark session as Established + let session_state: ClientSession = session.transition(Established {}); + info!("{} handshake complete", session_state.session_id()); + + codec.handshake_complete(); + let o4 = O4Stream::new(stream, codec, Session::Client(session_state)); + + Ok(O5Stream::from_o4(o4)) + } + + async fn complete_handshake( + mut stream: T, + materials: CHSMaterials, + deadline: Option, + ) -> Result<(BytesMut, impl O5Keygen)> + where + T: AsyncRead + AsyncWrite + Unpin, + { + let (state, chs_message) = O5NtorHandshake::client1(&materials, &())?; + // let mut file = tokio::fs::File::create("message.hex").await?; + // file.write_all(&chs_message).await?; + stream.write_all(&chs_message).await?; + + debug!( + "{} handshake sent {}B, waiting for sever response", + materials.session_id, + chs_message.len() + ); + + let mut buf = [0u8; MAX_HANDSHAKE_LENGTH]; + loop { + let n = stream.read(&mut buf).await?; + if n == 0 { + Err(Error::IOError(IoError::new( + IoErrorKind::UnexpectedEof, + "read 0B in client handshake", + )))? + } + debug!( + "{} read {n}/{}B of server handshake", + materials.session_id, + buf.len() + ); + + match O5NtorHandshake::client2(state.clone(), &buf[..n]) { + Ok(r) => return Ok(r), + Err(Error::HandshakeErr(RelayHandshakeError::EAgain)) => continue, + Err(e) => { + // if a deadline was set and has not passed already, discard + // from the stream until the deadline, then close. + if deadline.is_some_and(|d| d > Instant::now()) { + debug!("{} discarding due to: {e}", materials.session_id); + discard(&mut stream, deadline.unwrap() - Instant::now()).await?; + } + stream.shutdown().await?; + return Err(e); + } + } + } + } +} + +impl ClientSession { + pub(crate) fn set_len_seed(&mut self, seed: drbg::Seed) { + debug!( + "{} setting length seed {}", + self.session_id(), + hex::encode(seed.as_bytes()) + ); + self.len_seed = seed; + } +} + +impl std::fmt::Debug for ClientSession { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!( + f, + "[ id:{}, ident_pk:{}, iat:{:?}, epoch_hr:{} ]", + hex::encode(self.node_pubkey.id.as_bytes()), + hex::encode(self.node_pubkey.pk.as_bytes()), + self.iat_mode, + self.epoch_hour, + ) + } +} + +// ================================================================ // +// Server Sessions States // +// ================================================================ // + +pub(crate) struct ServerSession { + // fixed by server + pub(crate) identity_keys: O5NtorSecretKey, + pub(crate) biased: bool, + // pub(crate) server: &'a Server, + + // generated per session + pub(crate) session_id: [u8; SESSION_ID_LEN], + pub(crate) len_seed: drbg::Seed, + pub(crate) iat_seed: drbg::Seed, + + pub(crate) _state: S, +} + +pub(crate) struct ServerHandshaking {} + +#[allow(unused)] +pub(crate) struct ServerHandshakeFailed { + details: String, +} + +pub(crate) trait ServerSessionState {} +impl ServerSessionState for Initialized {} +impl ServerSessionState for ServerHandshaking {} +impl ServerSessionState for Established {} + +impl ServerSessionState for ServerHandshakeFailed {} +impl Fault for ServerHandshakeFailed {} + +impl ServerSession { + pub fn session_id(&self) -> String { + String::from("s-") + &colorize(self.session_id) + } + + pub(crate) fn set_session_id(&mut self, id: [u8; SESSION_ID_LEN]) { + debug!( + "{} -> {} server updating session id", + colorize(self.session_id), + colorize(id) + ); + self.session_id = id; + } + + /// Helper function to perform state transitions. + fn transition(self, _state: T) -> ServerSession { + ServerSession { + // fixed by server + identity_keys: self.identity_keys, + biased: self.biased, + + // generated per session + session_id: self.session_id, + len_seed: self.len_seed, + iat_seed: self.iat_seed, + + _state, + } + } + + /// Helper function to perform state transition on error. + fn fault(self, f: F) -> ServerSession { + ServerSession { + // fixed by server + identity_keys: self.identity_keys, + biased: self.biased, + + // generated per session + session_id: self.session_id, + len_seed: self.len_seed, + iat_seed: self.iat_seed, + + _state: f, + } + } +} + +impl ServerSession { + /// Attempt to complete the handshake with a new client connection. + pub async fn handshake( + self, + server: &Server, + mut stream: T, + deadline: Option, + ) -> Result> + where + T: AsyncRead + AsyncWrite + Unpin, + { + // set up for handshake + let mut session = self.transition(ServerHandshaking {}); + + let materials = SHSMaterials::new( + &session.identity_keys, + session.session_id(), + session.len_seed.to_bytes(), + ); + + // default deadline + let d_def = Instant::now() + SERVER_HANDSHAKE_TIMEOUT; + let handshake_fut = server.complete_handshake(&mut stream, materials, deadline); + + let mut keygen = + match tokio::time::timeout_at(deadline.unwrap_or(d_def), handshake_fut).await { + Ok(result) => match result { + Ok(handshake) => handshake, + Err(e) => { + // non-timeout error, + let id = session.session_id(); + let _ = session.fault(ServerHandshakeFailed { + details: format!("{id} handshake failed {e}"), + }); + return Err(e); + } + }, + Err(_) => { + let id = session.session_id(); + let _ = session.fault(ServerHandshakeFailed { + details: format!("{id} timed out"), + }); + return Err(Error::HandshakeTimeout); + } + }; + + // post handshake state updates + session.set_session_id(keygen.session_id()); + let mut codec: framing::O5Codec = keygen.into(); + + // mark session as Established + let session_state: ServerSession = session.transition(Established {}); + + codec.handshake_complete(); + let o4 = O4Stream::new(stream, codec, Session::Server(session_state)); + + Ok(O5Stream::from_o4(o4)) + } +} + +impl Server { + /// Complete the handshake with the client. This function assumes that the + /// client has already sent a message and that we do not know yet if the + /// message is valid. + async fn complete_handshake( + &self, + mut stream: T, + materials: SHSMaterials, + deadline: Option, + ) -> Result + where + T: AsyncRead + AsyncWrite + Unpin, + { + let session_id = materials.session_id.clone(); + + // wait for and attempt to consume the client hello message + let mut buf = [0_u8; MAX_HANDSHAKE_LENGTH]; + loop { + let n = stream.read(&mut buf).await?; + if n == 0 { + stream.shutdown().await?; + return Err(IoError::from(IoErrorKind::UnexpectedEof).into()); + } + trace!("{} successful read {n}B", session_id); + + match self.server(&mut |_: &()| Some(()), &[materials.clone()], &buf[..n]) { + Ok((keygen, response)) => { + stream.write_all(&response).await?; + info!("{} handshake complete", session_id); + return Ok(keygen); + } + Err(RelayHandshakeError::EAgain) => { + trace!("{} reading more", session_id); + continue; + } + Err(e) => { + trace!("{} failed to parse client handshake: {e}", session_id); + // if a deadline was set and has not passed already, discard + // from the stream until the deadline, then close. + if deadline.is_some_and(|d| d > Instant::now()) { + debug!("{} discarding due to: {e}", session_id); + discard(&mut stream, deadline.unwrap() - Instant::now()).await? + } + stream.shutdown().await?; + return Err(e.into()); + } + }; + } + } +} diff --git a/crates/o5/src/test_utils/fake_prng.rs b/crates/o5/src/test_utils/fake_prng.rs new file mode 100644 index 0000000..28279ef --- /dev/null +++ b/crates/o5/src/test_utils/fake_prng.rs @@ -0,0 +1,27 @@ +pub(crate) struct FakePRNG<'a> { + bytes: &'a [u8], +} +impl<'a> FakePRNG<'a> { + pub(crate) fn new(bytes: &'a [u8]) -> Self { + Self { bytes } + } +} +impl<'a> rand_core::RngCore for FakePRNG<'a> { + fn next_u32(&mut self) -> u32 { + rand_core::impls::next_u32_via_fill(self) + } + fn next_u64(&mut self) -> u64 { + rand_core::impls::next_u64_via_fill(self) + } + fn try_fill_bytes(&mut self, dest: &mut [u8]) -> std::result::Result<(), rand_core::Error> { + self.fill_bytes(dest); + Ok(()) + } + fn fill_bytes(&mut self, dest: &mut [u8]) { + assert!(dest.len() <= self.bytes.len()); + + dest.copy_from_slice(&self.bytes[0..dest.len()]); + self.bytes = &self.bytes[dest.len()..]; + } +} +impl rand_core::CryptoRng for FakePRNG<'_> {} diff --git a/crates/o5/src/test_utils/mod.rs b/crates/o5/src/test_utils/mod.rs new file mode 100644 index 0000000..f88fb88 --- /dev/null +++ b/crates/o5/src/test_utils/mod.rs @@ -0,0 +1,185 @@ +#![cfg(test)] +#![allow(dead_code)] + +mod fake_prng; +pub mod tests; +pub(crate) use fake_prng::*; + +use std::env; +use std::io::{Read, Result, Write}; +use std::os::unix::net::UnixStream; +use std::str::FromStr; +use std::sync::Once; + +use tokio::io::{AsyncRead, AsyncWrite}; +use tokio::net::UnixStream as AsyncUnixStream; +use tracing_subscriber::filter::LevelFilter; + +static SUBSCRIBER_INIT: Once = Once::new(); + +pub fn init_subscriber() { + SUBSCRIBER_INIT.call_once(|| { + let level = env::var("RUST_LOG_LEVEL").unwrap_or("error".into()); + let lf = LevelFilter::from_str(&level).unwrap(); + + tracing_subscriber::fmt().with_max_level(lf).init(); + }); +} + +#[cfg(unix)] +pub fn pipe_set() -> Result<( + (impl Read + Write + Sized, impl Read + Write + Sized), + (impl Read + Write + Sized, impl Read + Write + Sized), +)> { + Ok((UnixStream::pair()?, UnixStream::pair()?)) +} + +#[cfg(unix)] +pub fn pipes() -> Result<(impl Read + Write + Sized, impl Read + Write + Sized)> { + UnixStream::pair() +} + +#[cfg(unix)] +pub fn pipe_set_async() -> Result<( + ( + impl AsyncRead + AsyncWrite + Sized, + impl AsyncRead + AsyncWrite + Sized, + ), + ( + impl AsyncRead + AsyncWrite + Sized, + impl AsyncRead + AsyncWrite + Sized, + ), +)> { + Ok((AsyncUnixStream::pair()?, AsyncUnixStream::pair()?)) +} + +#[cfg(unix)] +pub fn pipe_set_async_unixstream() -> Result<( + (AsyncUnixStream, AsyncUnixStream), + (AsyncUnixStream, AsyncUnixStream), +)> { + Ok((AsyncUnixStream::pair()?, AsyncUnixStream::pair()?)) +} + +#[cfg(unix)] +pub fn pipes_async() -> Result<( + impl AsyncRead + AsyncWrite + Sized, + impl AsyncRead + AsyncWrite + Sized, +)> { + AsyncUnixStream::pair() +} + +// // TODO: implement with something like named_pipes for windows +// #[cfg(windows)] +// pub fn pipe_set() -> ((RW,RW), (RW,RW)) +// where +// RW: Read + Write + ?Sized +// { +// // Ok((UnixStream::pair()?, UnixStream::pair()?)) +// } + +#[cfg(test)] +mod test { + + use super::*; + use std::{io, thread}; + + use tokio::io::{AsyncReadExt, AsyncWriteExt}; + + #[cfg(unix)] + #[tokio::test] + async fn build_async_pipes() { + let (mut client_host, mut client_wasm) = pipes_async().unwrap(); + let (mut wasm_remote, mut remote) = AsyncUnixStream::pair().unwrap(); + + let buf = b"hello world"; + + tokio::spawn(async move { + let transport_result = { + client_host.write_all(buf).await.unwrap(); + tokio::io::copy(&mut client_wasm, &mut wasm_remote).await + }; + assert!(transport_result.is_ok()); + let n = transport_result.unwrap() as usize; + assert_eq!(n, buf.len()); + }); + + let mut out = vec![0_u8; 1024]; + let nr = remote.read(&mut out).await.unwrap(); + assert_eq!(nr, buf.len()); + assert_eq!(std::str::from_utf8(&out[..nr]).unwrap(), "hello world"); + } + + #[cfg(unix)] + #[tokio::test] + async fn build_async_pipe_set() { + let ((mut client_host, mut client_wasm), (mut wasm_remote, mut remote)) = + pipe_set_async().unwrap(); + + let buf = b"hello world"; + + tokio::spawn(async move { + let transport_result = { + client_host.write_all(buf).await.unwrap(); + tokio::io::copy(&mut client_wasm, &mut wasm_remote).await + }; + assert!(transport_result.is_ok()); + let n = transport_result.unwrap() as usize; + assert_eq!(n, buf.len()); + }); + + let mut out = vec![0_u8; 1024]; + let nr = remote.read(&mut out).await.unwrap(); + assert_eq!(nr, buf.len()); + assert_eq!(std::str::from_utf8(&out[..nr]).unwrap(), "hello world"); + } + + #[cfg(unix)] + #[test] + fn build_pipes() -> Result<()> { + let (mut client_host, mut client_wasm) = pipes()?; + let (mut wasm_remote, mut remote) = UnixStream::pair()?; + + let buf = b"hello world"; + + thread::spawn(move || { + let transport_result = { + client_host.write_all(buf).unwrap(); + io::copy(&mut client_wasm, &mut wasm_remote) + }; + assert!(transport_result.is_ok()); + let n = transport_result.unwrap() as usize; + assert_eq!(n, buf.len()); + }); + + let mut out = vec![0_u8; 1024]; + let nr = remote.read(&mut out)?; + assert_eq!(nr, buf.len()); + assert_eq!(std::str::from_utf8(&out[..nr]).unwrap(), "hello world"); + Ok(()) + } + + #[cfg(unix)] + #[test] + fn build_pipe_set() -> Result<()> { + let ((mut client_host, mut client_wasm), (mut wasm_remote, mut remote)) = pipe_set()?; + + let buf = b"hello world"; + + thread::spawn(move || { + let transport_result = { + client_host.write_all(buf).unwrap(); + io::copy(&mut client_wasm, &mut wasm_remote) + }; + assert!(transport_result.is_ok()); + let n = transport_result.unwrap() as usize; + assert_eq!(n, buf.len()); + }); + + let mut out = vec![0_u8; 1024]; + let nr = remote.read(&mut out)?; + assert_eq!(nr, buf.len()); + assert_eq!(std::str::from_utf8(&out[..nr]).unwrap(), "hello world"); + Ok(()) + } +} diff --git a/crates/o5/src/test_utils/tests.rs b/crates/o5/src/test_utils/tests.rs new file mode 100644 index 0000000..ce81e5b --- /dev/null +++ b/crates/o5/src/test_utils/tests.rs @@ -0,0 +1,101 @@ +// use crate::{stream::Stream, Error, Result}; +use crate::Result; + +// use futures::join; + +use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt, ReadHalf, WriteHalf}; + +use ptrs::debug; +/* +/// +/// write ===================> encode ===================> >| +/// read <=================== decode <=================== <| echo +/// +/// [ loop Buffer ] -> | source | -> | plaintext | -> | ciphertext | -> | echo | +/// pipe pipe +/// +#[allow(non_snake_case)] +pub async fn duplex_end_to_end_1_MB<'a, A, B>( + source: A, + mut plaintext: A, + mut ciphertext: B, + echo: B, + duplex: impl DuplexTransform + 'a, +) -> Result<(u64, u64)> +where + A: Stream<'a> + 'a, + B: Stream<'a> + 'a, +{ + let proxy_task = async { + let r = duplex + .copy_bidirectional(&mut plaintext, &mut ciphertext) + .await; + plaintext.flush().await?; + plaintext.shutdown().await?; + std::thread::sleep(std::time::Duration::from_millis(100)); + ciphertext.flush().await?; + ciphertext.shutdown().await?; + debug!("proxy finished"); + r + }; + + let (echo_r, echo_w) = tokio::io::split(echo); + let echo_task = echo_fn(echo_r, echo_w); + + let (source_r, source_w) = tokio::io::split(source); + let trash_task = trash(source_r); + + let client_write = write_and_close(source_w); + + let (trash_result, proxy_result, echo_result, client_result) = + join!(trash_task, proxy_task, echo_task, client_write); + echo_result.unwrap(); // ensure result is Ok - otherwise result is useless. + assert_eq!(client_result?, 1024 * 1024); + assert_eq!(trash_result?, 1024 * 1024); + + debug!("test_complete"); + let out = proxy_result.map_err(Error::IOError); + debug!("returning"); + out +} +*/ + +async fn echo_fn<'a, A, B>(mut r: ReadHalf, mut w: WriteHalf) -> std::io::Result<()> +where + A: AsyncRead + Unpin + 'a, + B: AsyncWrite + Unpin + 'a, +{ + let _n = tokio::io::copy(&mut r, &mut w).await?; + _ = w.write(&[]).await?; + w.flush().await?; + w.shutdown().await?; + debug!("echo_fn finished"); + Ok(()) +} + +async fn write_and_close<'a, A: AsyncWrite + Unpin + 'a>( + mut w: WriteHalf, +) -> std::io::Result { + let write_me = vec![0_u8; 1024]; + let mut n = 0; + for _ in 0..1024 { + n += w.write(&write_me).await?; + } + n += w.write(&[]).await?; + w.flush().await?; + assert_eq!(n, 1024 * 1024); + + debug!("finished writing... sleeping 1s"); + std::thread::sleep(std::time::Duration::from_millis(100)); + w.shutdown().await?; + debug!("writer closed"); + Ok(n) +} + +async fn trash<'a, A: AsyncRead + Unpin + 'a>(mut r: ReadHalf) -> Result { + let out_file = tokio::fs::File::create("/dev/null").await.unwrap(); + let mut out_file = tokio::io::BufWriter::new(out_file); + let n = tokio::io::copy(&mut r, &mut out_file).await.unwrap(); + debug!("trash finished"); + Ok(n) +} diff --git a/crates/o5/src/testing.rs b/crates/o5/src/testing.rs new file mode 100644 index 0000000..185aab1 --- /dev/null +++ b/crates/o5/src/testing.rs @@ -0,0 +1,354 @@ +use crate::{test_utils::init_subscriber, Result, Server}; + +use ptrs::{debug, trace}; +use tokio::io::{AsyncReadExt, AsyncWriteExt}; + +use std::cmp::Ordering; +use std::time::Duration; + +#[tokio::test] +async fn public_handshake() -> Result<()> { + init_subscriber(); + let (mut c, mut s) = tokio::io::duplex(65_536); + let mut rng = rand::thread_rng(); + + let o4_server = Server::new_from_random(&mut rng); + let client_config = o4_server.client_params(); + + tokio::spawn(async move { + let o4s_stream = o4_server.wrap(&mut s).await.unwrap(); + let _ = tokio::io::split(o4s_stream); + }); + + let o4_client = client_config.build(); + let _o4c_stream = o4_client.wrap(&mut c).await?; + + Ok(()) +} + +#[tokio::test] +async fn public_iface() -> Result<()> { + init_subscriber(); + let message = b"awoewaeojawenwaefaw lfawn;awe da;wfenalw fawf aw"; + let (mut c, mut s) = tokio::io::duplex(65_536); + let mut rng = rand::thread_rng(); + + let o4_server = Server::new_from_random(&mut rng); + let client_config = o4_server.client_params(); + + tokio::spawn(async move { + let mut o4s_stream = o4_server.wrap(&mut s).await.unwrap(); + // let (mut r, mut w) = tokio::io::split(o4s_stream); + // tokio::io::copy(&mut r, &mut w).await.unwrap(); + + let mut buf = [0_u8; 50]; + let n = o4s_stream.read(&mut buf).await.unwrap(); + o4s_stream.write_all(&buf[..n]).await.unwrap(); + o4s_stream.flush().await.unwrap(); + + if n != 48 { + debug!("echo lengths don't match {n} != 48"); + } + }); + + let o4_client = client_config.build(); + let mut o4c_stream = o4_client.wrap(&mut c).await?; + + o4c_stream.write_all(&message[..]).await?; + o4c_stream.flush().await?; + + let mut buf = vec![0_u8; message.len()]; + let n = o4c_stream.read(&mut buf).await?; + assert_eq!(n, message.len()); + assert_eq!( + &message[..], + &buf, + "\"{}\" != \"{}\"", + String::from_utf8(message.to_vec())?, + String::from_utf8(buf.clone())?, + ); + + Ok(()) +} + +#[allow(non_snake_case)] +#[tokio::test] +async fn transfer_10k_x1() -> Result<()> { + init_subscriber(); + + let (c, mut s) = tokio::io::duplex(1024 * 1000); + let mut rng = rand::thread_rng(); + + let o4_server = Server::new_from_random(&mut rng); + let client_config = o4_server.client_params(); + + tokio::spawn(async move { + let o4s_stream = o4_server.wrap(&mut s).await.unwrap(); + let (mut r, mut w) = tokio::io::split(o4s_stream); + tokio::io::copy(&mut r, &mut w).await.unwrap(); + }); + + let o4_client = client_config.build(); + let o4c_stream = o4_client.wrap(c).await?; + + let (mut r, mut w) = tokio::io::split(o4c_stream); + + tokio::spawn(async move { + let msg = [0_u8; 10240]; + w.write_all(&msg) + .await + .unwrap_or_else(|e| panic!("failed on write {e}")); + w.flush().await.unwrap(); + }); + + let expected_total = 10240; + let mut buf = vec![0_u8; 1024 * 11]; + let mut received: usize = 0; + for i in 0..8 { + debug!("client read: {i}"); + tokio::select! { + res = r.read(&mut buf) => { + let n = res?; + received += n; + trace!("received: {n}: total:{received}"); + } + _ = tokio::time::sleep(std::time::Duration::from_millis(1000)) => { + panic!("client failed to read after {i} iterations: timeout"); + } + } + } + + if received != expected_total { + panic!("incorrect amount received {received} != {expected_total}"); + } + Ok(()) +} + +#[allow(non_snake_case)] +#[tokio::test] +async fn transfer_10k_x3() -> Result<()> { + init_subscriber(); + + let (c, mut s) = tokio::io::duplex(1024 * 1000); + + let o4_server = Server::getrandom(); + let client_config = o4_server.client_params(); + + tokio::spawn(async move { + let o4s_stream = o4_server.wrap(&mut s).await.unwrap(); + let (mut r, mut w) = tokio::io::split(o4s_stream); + tokio::io::copy(&mut r, &mut w).await.unwrap(); + }); + + let o4_client = client_config.build(); + let o4c_stream = o4_client.wrap(c).await?; + + let (mut r, mut w) = tokio::io::split(o4c_stream); + + tokio::spawn(async move { + for _ in 0..3 { + let msg = [0_u8; 10240]; + w.write_all(&msg) + .await + .unwrap_or_else(|e| panic!("failed on write {e}")); + w.flush().await.unwrap(); + } + }); + + let expected_total = 10240 * 3; + let mut buf = vec![0_u8; 1024 * 32]; + let mut received: usize = 0; + for i in 0..24 { + // debug!("client read: {i}"); + tokio::select! { + res = r.read(&mut buf) => { + let n = res?; + received += n; + trace!("received: {n}: total:{received}"); + } + _ = tokio::time::sleep(std::time::Duration::from_millis(1000)) => { + panic!("client failed to read after {i} iterations: timeout"); + } + } + } + + if received != expected_total { + panic!("incorrect amount received {received} != {expected_total}"); + } + Ok(()) +} + +#[allow(non_snake_case)] +#[tokio::test] +async fn transfer_1M_1024x1024() -> Result<()> { + init_subscriber(); + + let (c, mut s) = tokio::io::duplex(1024 * 1000); + let mut rng = rand::thread_rng(); + + let o4_server = Server::new_from_random(&mut rng); + let client_config = o4_server.client_params(); + + tokio::spawn(async move { + let o4s_stream = o4_server.wrap(&mut s).await.unwrap(); + let (mut r, mut w) = tokio::io::split(o4s_stream); + tokio::io::copy(&mut r, &mut w).await.unwrap(); + }); + + let o4_client = client_config.build(); + let o4c_stream = o4_client.wrap(c).await?; + + let (mut r, mut w) = tokio::io::split(o4c_stream); + + tokio::spawn(async move { + let msg = [0_u8; 1024]; + for i in 0..1024 { + w.write_all(&msg) + .await + .unwrap_or_else(|e| panic!("failed on write #{i}: {e}")); + w.flush().await.unwrap(); + } + }); + + let expected_total = 1024 * 1024; + let mut buf = vec![0_u8; 1024 * 1024]; + let mut received: usize = 0; + for i in 0..1024 { + // debug!("client read: {i}"); + tokio::select! { + res = r.read(&mut buf) => { + received += res?; + } + _ = tokio::time::sleep(std::time::Duration::from_secs(10)) => { + panic!("client failed to read after {i} iterations: timeout"); + } + } + } + + if received != expected_total { + panic!("incorrect amount received {received} != {expected_total}"); + } + Ok(()) +} + +#[allow(non_snake_case)] +#[tokio::test] +async fn transfer_512k_x1() -> Result<()> { + init_subscriber(); + + let (c, mut s) = tokio::io::duplex(1024 * 512); + let mut rng = rand::thread_rng(); + + let o4_server = Server::new_from_random(&mut rng); + let client_config = o4_server.client_params(); + + tokio::spawn(async move { + let o4s_stream = o4_server.wrap(&mut s).await.unwrap(); + let (mut r, mut w) = tokio::io::split(o4s_stream); + tokio::io::copy(&mut r, &mut w).await.unwrap(); + }); + + let o4_client = client_config.build(); + let o4c_stream = o4_client.wrap(c).await?; + + let (mut r, mut w) = tokio::io::split(o4c_stream); + + tokio::spawn(async move { + let msg = [0_u8; 1024 * 512]; + w.write_all(&msg) + .await + .unwrap_or_else(|_| panic!("failed on write")); + w.flush().await.unwrap(); + }); + + let expected_total = 1024 * 512; + let mut buf = vec![0_u8; 1024 * 1024]; + let mut received: usize = 0; + let mut i = 0; + while received < expected_total { + debug!("client read: {i} / {received}"); + tokio::select! { + res = r.read(&mut buf) => { + received += res?; + } + _ = tokio::time::sleep(std::time::Duration::from_millis(2000)) => { + panic!("client failed to read after {i} iterations: timeout"); + } + } + i += 1; + } + + assert_eq!( + received, expected_total, + "incorrect amount received {received} != {expected_total}" + ); + Ok(()) +} + +#[tokio::test] +async fn transfer_2_x() -> Result<()> { + init_subscriber(); + + let (c, mut s) = tokio::io::duplex(1024 * 1000); + let mut rng = rand::thread_rng(); + + let o4_server = Server::new_from_random(&mut rng); + let client_config = o4_server.client_params(); + + tokio::spawn(async move { + let o4s_stream = o4_server.wrap(&mut s).await.unwrap(); + let (mut r, mut w) = tokio::io::split(o4s_stream); + tokio::io::copy(&mut r, &mut w).await.unwrap(); + }); + + let o4_client = client_config.build(); + let o4c_stream = o4_client.wrap(c).await?; + + let (mut r, mut w) = tokio::io::split(o4c_stream); + + let base: usize = 2; + tokio::spawn(async move { + for i in (0..20).step_by(2) { + let msg = vec![0_u8; base.pow(i)]; + w.write_all(&msg) + .await + .unwrap_or_else(|_| panic!("failed on write #{i}")); + debug!("wrote 2^{i}"); + w.flush().await.unwrap(); + } + }); + + let mut buf = vec![0_u8; 1024 * 1024 * 100]; + let expected_total: usize = (0..20).step_by(2).map(|i| base.pow(i)).sum(); + let mut received = 0; + + let mut i = 0; + loop { + let res_timeout = + tokio::time::timeout(Duration::from_millis(10000), r.read(&mut buf)).await; + + let res = res_timeout.unwrap(); + let n = res?; + received += n; + if n == 0 { + debug!("read 0?"); + break; + } else { + debug!("({i}) read {n}B - {received}"); + } + + match received.cmp(&expected_total) { + Ordering::Less => {} + Ordering::Equal => break, + Ordering::Greater => { + panic!("received more than expected {received} > {expected_total}") + } + } + i += 1; + } + + if received != expected_total { + panic!("incorrect amount received {received} != {expected_total}"); + } + Ok(()) +} diff --git a/crates/o5/src/transport.rs b/crates/o5/src/transport.rs deleted file mode 100644 index a17c878..0000000 --- a/crates/o5/src/transport.rs +++ /dev/null @@ -1,75 +0,0 @@ -use crate::traits::*; -use std::error::Error; - - -const NAME: &'static str = "o7"; - -#[allow(non_camel_case_types)] -pub struct o7 {} - -impl Named for o7 { - fn name() -> &'static str { - NAME - } -} - -#[derive(Default, Clone, Copy, Debug)] -pub struct Client {} -impl Named for Client { - fn name() -> &'static str { - NAME+"_client" - } -} - - -#[derive(Default, Clone, Copy, Debug)] -pub struct Server {} -impl Named for Server { - fn name() -> &'static str { - NAME+"_server" - } -} - -struct Cfg { - s: String -} - -impl ToConfig for Cfg {} -impl From<&'static str> for Cfg { - fn from(s: &'static str) -> Self { - Cfg { s: s.to_string() } - } -} - -impl From> for Cfg { - fn from(s: dyn Iterator) -> Self { - Cfg { s: s.try_collect().unwrap()} - } -} - - -impl Ingress for Client {} -impl Configurable for Client { - fn with_config(mut self, cfg: Cfg)-> Result { - Ok(self) - } -} - -impl Egress for Server {} -impl Configurable for Server { - fn with_config(mut self, cfg: Cfg)-> Result { - Ok(self) - } -} - -impl IngressBuilder for o7 { - fn client() -> Result { - Ok(Client::default()) - } -} - -impl EgressBuilder for o7 { - fn server(args: Option<()>) -> Result { - Ok(()) - } -} From 980fa9865edf17e13f2374e2bb85d4ec08a5bdcc Mon Sep 17 00:00:00 2001 From: Jack Wampler Date: Sat, 12 Oct 2024 16:18:04 -0600 Subject: [PATCH 2/3] Mlkem1024 x25519 (#65) re-organizing and shifting from pq_kyber to ml-kem --- Cargo.toml | 2 +- crates/o5/Cargo.toml | 39 +- crates/o5/src/client.rs | 39 +- crates/o5/src/common/curve25519.rs | 157 ---- crates/o5/src/common/mlkem1024_x25519.rs | 324 ++++++++ crates/o5/src/common/mod.rs | 5 +- .../common/{ntor_arti/mod.rs => ntor_arti.rs} | 86 +- crates/o5/src/common/skip.rs | 2 - crates/o5/src/{handshake => common}/utils.rs | 0 crates/o5/src/common/x25519_elligator2.rs | 403 +++++++++ crates/o5/src/constants.rs | 16 +- crates/o5/src/error.rs | 30 + crates/o5/src/framing/codecs.rs | 6 +- crates/o5/src/framing/handshake.rs | 246 +++--- crates/o5/src/framing/messages_v1/mod.rs | 45 +- crates/o5/src/framing/mod.rs | 4 +- crates/o5/src/handshake.rs | 489 +++++++++++ crates/o5/src/handshake/README.md | 126 +-- crates/o5/src/handshake/client.rs | 292 +++++++ crates/o5/src/handshake/handshake_client.rs | 335 -------- crates/o5/src/handshake/handshake_server.rs | 284 ------- crates/o5/src/handshake/keys.rs | 321 ++++++++ crates/o5/src/handshake/kyber.rs | 355 -------- crates/o5/src/handshake/mod.rs | 757 ----------------- crates/o5/src/handshake/ntor_obfs4.rs | 352 -------- crates/o5/src/handshake/server.rs | 225 +++++ crates/o5/src/handshake_old/integration.rs | 297 ------- crates/o5/src/handshake_old/mod.rs | 774 ------------------ crates/o5/src/lib.rs | 79 +- crates/o5/src/proto.rs | 68 +- crates/o5/src/pt.rs | 49 +- crates/o5/src/server.rs | 120 +-- crates/o5/src/sessions.rs | 480 +---------- crates/o5/src/sessions/client.rs | 266 ++++++ crates/o5/src/sessions/server.rs | 224 +++++ crates/o5/src/testing.rs | 3 +- .../obfs4/src/handshake/handshake_client.rs | 2 +- doc/pq_obfs/obfs4.png | Bin 0 -> 352725 bytes doc/pq_obfs/pq_obfs_full.png | Bin 0 -> 405776 bytes doc/pq_obfs/pq_obfs_step-1.png | Bin 0 -> 148976 bytes doc/pq_obfs/pq_obfs_step-2.png | Bin 0 -> 166757 bytes doc/pq_obfs/pq_obfs_step-3.png | Bin 0 -> 123441 bytes doc/pq_obfs/st_obfs4.png | Bin 0 -> 481293 bytes 43 files changed, 2945 insertions(+), 4357 deletions(-) delete mode 100644 crates/o5/src/common/curve25519.rs create mode 100644 crates/o5/src/common/mlkem1024_x25519.rs rename crates/o5/src/common/{ntor_arti/mod.rs => ntor_arti.rs} (74%) rename crates/o5/src/{handshake => common}/utils.rs (100%) create mode 100644 crates/o5/src/common/x25519_elligator2.rs create mode 100644 crates/o5/src/handshake.rs create mode 100644 crates/o5/src/handshake/client.rs delete mode 100644 crates/o5/src/handshake/handshake_client.rs delete mode 100644 crates/o5/src/handshake/handshake_server.rs create mode 100644 crates/o5/src/handshake/keys.rs delete mode 100644 crates/o5/src/handshake/kyber.rs delete mode 100644 crates/o5/src/handshake/mod.rs delete mode 100644 crates/o5/src/handshake/ntor_obfs4.rs create mode 100644 crates/o5/src/handshake/server.rs delete mode 100644 crates/o5/src/handshake_old/integration.rs delete mode 100644 crates/o5/src/handshake_old/mod.rs create mode 100644 crates/o5/src/sessions/client.rs create mode 100644 crates/o5/src/sessions/server.rs create mode 100644 doc/pq_obfs/obfs4.png create mode 100644 doc/pq_obfs/pq_obfs_full.png create mode 100644 doc/pq_obfs/pq_obfs_step-1.png create mode 100644 doc/pq_obfs/pq_obfs_step-2.png create mode 100644 doc/pq_obfs/pq_obfs_step-3.png create mode 100644 doc/pq_obfs/st_obfs4.png diff --git a/Cargo.toml b/Cargo.toml index 575115f..3cbffb0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -3,7 +3,7 @@ members = [ "crates/lyrebird", - # "crates/o5", + "crates/o5", "crates/o7", "crates/obfs4", "crates/ptrs", diff --git a/crates/o5/Cargo.toml b/crates/o5/Cargo.toml index ff78b12..6fa7f38 100644 --- a/crates/o5/Cargo.toml +++ b/crates/o5/Cargo.toml @@ -1,7 +1,15 @@ [package] name = "o5" -version = "0.1.0" +version = "0.1.0-alpha.1" edition = "2021" +authors = ["Jack Wampler "] +rust-version = "1.81" +license = "MIT OR Apache-2.0" +description = "Pure rust implementation of the o5 pluggable transport" +keywords = ["tor", "censorship", "pluggable", "transports"] +categories = ["network-programming", "cryptography"] +repository = "https://github.com/jmwample/ptrs" + [lib] name = "o5" @@ -17,14 +25,16 @@ rand = { version="0.8.5", features=["getrandom"]} rand_core = "0.6.4" ## Crypto -digest = { version = "0.10.7", features=["mac"]} +digest = { version = "0.10.7", features=["mac", "core-api"]} +typenum = "1.17.0" +block-buffer = "0.10.4" siphasher = "1.0.0" sha2 = "0.10.8" hmac = { version="0.12.1", features=["reset"]} hkdf = "0.12.3" -crypto_secretbox = { version="0.1.1", features=["salsa20"]} +crypto_secretbox = { version="0.1.1", features=["chacha20"]} subtle = "2.5.0" -x25519-dalek = { version = "2.0.1", features = ["static_secrets", "getrandom", "reusable_secrets", "elligator2"], git = "https://github.com/jmwample/curve25519-dalek.git", branch = "elligator2-ntor"} +x25519-dalek = { version = "2.0.1", features = ["static_secrets", "getrandom", "reusable_secrets"]} ## Utils pin-project = "1.1.3" @@ -42,23 +52,28 @@ tokio-util = { version = "0.7.10", features = ["codec", "io"]} bytes = "1.5.0" ## ntor_arti -tor-cell = "0.16.0" -tor-llcrypto = "0.7.0" -tor-error = "0.6.1" -tor-bytes = "0.10.0" +tor-cell = "0.22.0" +tor-llcrypto = "0.22.0" +tor-error = "0.22.0" +tor-bytes = "0.22.0" cipher = "0.4.4" zeroize = "1.7.0" thiserror = "1.0.56" +curve25519-elligator2 = { version="0.1.0-alpha.1", features=["elligator2"] } + +# o5 pqc +ml-kem = "0.2.1" +kem = "0.3.0-pre.0" +# kemeleon = { version="0.1.0-rc.1", path="../../../../elligantt/kemeleon"} +kemeleon = { version="0.1.0-rc.1", git="https://github.com/jmwample/kemeleon", branch="cleanup"} + [dev-dependencies] anyhow = "1.0" tracing-subscriber = "0.3.18" hex-literal = "0.4.1" -tor-basic-utils = "0.8.0" +tor-basic-utils = "0.22.0" -# o5 pqc test -# pqc_kyber = {version="0.7.1", features=["kyber1024", "std"]} -ml-kem = "0.1.0" [lints.rust] # unexpected_cfgs are used to disable incomplete / WIP features and tests. This is diff --git a/crates/o5/src/client.rs b/crates/o5/src/client.rs index eae4470..0dfb8cd 100644 --- a/crates/o5/src/client.rs +++ b/crates/o5/src/client.rs @@ -1,11 +1,11 @@ #![allow(unused)] use crate::{ - common::{colorize, HmacSha256}, + common::{colorize, mlkem1024_x25519, HmacSha256}, constants::*, framing::{FrameError, Marshall, O5Codec, TryParse, KEY_LENGTH, KEY_MATERIAL_LENGTH}, - handshake::O5NtorPublicKey, - proto::{MaybeTimeout, O5Stream, IAT}, + handshake::IdentityPublicKey, + proto::{MaybeTimeout, O5Stream}, sessions, Error, Result, }; @@ -26,8 +26,7 @@ use std::{ #[derive(Clone, Debug)] pub struct ClientBuilder { - pub iat_mode: IAT, - pub station_pubkey: [u8; KEY_LENGTH], + pub station_pubkey: [u8; PUBLIC_KEY_LEN], pub station_id: [u8; NODE_ID_LENGTH], pub statefile_path: Option, pub(crate) handshake_timeout: MaybeTimeout, @@ -36,8 +35,7 @@ pub struct ClientBuilder { impl Default for ClientBuilder { fn default() -> Self { Self { - iat_mode: IAT::Off, - station_pubkey: [0u8; KEY_LENGTH], + station_pubkey: [0u8; PUBLIC_KEY_LEN], station_id: [0_u8; NODE_ID_LENGTH], statefile_path: None, handshake_timeout: MaybeTimeout::Default_, @@ -49,8 +47,7 @@ impl ClientBuilder { /// TODO: implement client builder from statefile pub fn from_statefile(location: &str) -> Result { Ok(Self { - iat_mode: IAT::Off, - station_pubkey: [0_u8; KEY_LENGTH], + station_pubkey: [0_u8; PUBLIC_KEY_LEN], station_id: [0_u8; NODE_ID_LENGTH], statefile_path: Some(location.into()), handshake_timeout: MaybeTimeout::Default_, @@ -60,15 +57,14 @@ impl ClientBuilder { /// TODO: implement client builder from string args pub fn from_params(param_strs: Vec>) -> Result { Ok(Self { - iat_mode: IAT::Off, - station_pubkey: [0_u8; KEY_LENGTH], + station_pubkey: [0_u8; PUBLIC_KEY_LEN], station_id: [0_u8; NODE_ID_LENGTH], statefile_path: None, handshake_timeout: MaybeTimeout::Default_, }) } - pub fn with_node_pubkey(&mut self, pubkey: [u8; KEY_LENGTH]) -> &mut Self { + pub fn with_node_pubkey(&mut self, pubkey: [u8; PUBLIC_KEY_LEN]) -> &mut Self { self.station_pubkey = pubkey; self } @@ -83,11 +79,6 @@ impl ClientBuilder { self } - pub fn with_iat_mode(&mut self, iat: IAT) -> &mut Self { - self.iat_mode = iat; - self - } - pub fn with_handshake_timeout(&mut self, d: Duration) -> &mut Self { self.handshake_timeout = MaybeTimeout::Length(d); self @@ -105,11 +96,8 @@ impl ClientBuilder { pub fn build(&self) -> Client { Client { - iat_mode: self.iat_mode, - station_pubkey: O5NtorPublicKey { - id: self.station_id.into(), - pk: self.station_pubkey.into(), - }, + station_pubkey: IdentityPublicKey::new(self.station_pubkey, self.station_id) + .expect("failed to build client - bad options."), handshake_timeout: self.handshake_timeout.duration(), } } @@ -129,8 +117,7 @@ impl fmt::Display for ClientBuilder { /// Client implementing the obfs4 protocol. pub struct Client { - iat_mode: IAT, - station_pubkey: O5NtorPublicKey, + station_pubkey: IdentityPublicKey, handshake_timeout: Option, } @@ -144,7 +131,7 @@ impl Client { where T: AsyncRead + AsyncWrite + Unpin + 'a, { - let session = sessions::new_client_session(self.station_pubkey, self.iat_mode); + let session = sessions::new_client_session(self.station_pubkey); let deadline = self.handshake_timeout.map(|d| Instant::now() + d); @@ -163,7 +150,7 @@ impl Client { { let stream = stream_fut.await.map_err(|e| Error::Other(Box::new(e)))?; - let session = sessions::new_client_session(self.station_pubkey, self.iat_mode); + let session = sessions::new_client_session(self.station_pubkey); let deadline = self.handshake_timeout.map(|d| Instant::now() + d); diff --git a/crates/o5/src/common/curve25519.rs b/crates/o5/src/common/curve25519.rs deleted file mode 100644 index 5bdd713..0000000 --- a/crates/o5/src/common/curve25519.rs +++ /dev/null @@ -1,157 +0,0 @@ -//! Re-exporting Curve25519 implementations. -//! -//! *TODO*: Eventually we should probably recommend using this code via some -//! key-agreement trait, but for now we are just re-using the APIs from -//! [`x25519_dalek`]. - -// TODO: We may want eventually want to expose ReusableSecret instead of -// StaticSecret, for use in places where we need to use a single secret -// twice in one handshake, but we do not need that secret to be persistent. -// -// The trouble here is that if we use ReusableSecret in these cases, we -// cannot easily construct it for testing purposes. We could in theory -// kludge something together using a fake Rng, but that might be more -// trouble than we want to go looking for. -#[allow(unused)] -pub use x25519_dalek::{ - EphemeralSecret, PublicKey, PublicRepresentative, ReusableSecret, SharedSecret, StaticSecret, -}; - -use rand_core::{CryptoRng, RngCore}; - -pub const REPRESENTATIVE_LENGTH: usize = 32; - -/// Curve25519 keys that are guaranteed to have a valid Elligator2 representative. -/// As only certain Curve25519 keys can be obfuscated with Elligator2, the -/// representative must be checked when generating the secret key. -/// -/// The probablility that a key does not have a representable elligator2 encoding -/// is ~50%, so we are (statistiscally) guaranteed to find a representable key -/// in relatively few iterations. -pub struct Representable; - -const RETRY_LIMIT: usize = 128; - -#[allow(unused)] -impl Representable { - /// Generate a new Elligator2 representable ['StaticSecret'] with the supplied RNG. - pub fn static_from_rng(mut rng: R) -> StaticSecret { - let mut private = StaticSecret::random_from_rng(&mut rng); - let mut repres: Option = (&private).into(); - - for _ in 0..RETRY_LIMIT { - if repres.is_some() { - return private; - } - private = StaticSecret::random_from_rng(&mut rng); - repres = (&private).into(); - } - - panic!("failed to generate representable secret, bad RNG provided"); - } - - /// Generate a new Elligator2 representable ['ReusableSecret'] with the supplied RNG. - pub fn reusable_from_rng(mut rng: R) -> ReusableSecret { - let mut private = ReusableSecret::random_from_rng(&mut rng); - let mut repres: Option = (&private).into(); - - for _ in 0..RETRY_LIMIT { - if repres.is_some() { - return private; - } - private = ReusableSecret::random_from_rng(&mut rng); - repres = (&private).into(); - } - - panic!("failed to generate representable secret, bad RNG provided"); - } - - /// Generate a new Elligator2 representable ['EphemeralSecret'] with the supplied RNG. - pub fn ephemeral_from_rng(mut rng: R) -> EphemeralSecret { - let mut private = EphemeralSecret::random_from_rng(&mut rng); - let mut repres: Option = (&private).into(); - - for _ in 0..RETRY_LIMIT { - if repres.is_some() { - return private; - } - private = EphemeralSecret::random_from_rng(&mut rng); - repres = (&private).into(); - } - - panic!("failed to generate representable secret, bad RNG provided"); - } - - /// Generate a new Elligator2 representable ['StaticSecret']. - pub fn random_static() -> StaticSecret { - let mut private = StaticSecret::random(); - let mut repres: Option = (&private).into(); - - for _ in 0..RETRY_LIMIT { - if repres.is_some() { - return private; - } - private = StaticSecret::random(); - repres = (&private).into(); - } - - panic!("failed to generate representable secret, getrandom failed"); - } - - /// Generate a new Elligator2 representable ['ReusableSecret']. - pub fn random_reusable() -> ReusableSecret { - let mut private = ReusableSecret::random(); - let mut repres: Option = (&private).into(); - - for _ in 0..RETRY_LIMIT { - if repres.is_some() { - return private; - } - private = ReusableSecret::random(); - repres = (&private).into(); - } - - panic!("failed to generate representable secret, getrandom failed"); - } - - /// Generate a new Elligator2 representable ['EphemeralSecret']. - pub fn random_ephemeral() -> EphemeralSecret { - let mut private = EphemeralSecret::random(); - let mut repres: Option = (&private).into(); - - for _ in 0..RETRY_LIMIT { - if repres.is_some() { - return private; - } - private = EphemeralSecret::random(); - repres = (&private).into(); - } - - panic!("failed to generate representable secret, getrandom failed"); - } -} - -#[cfg(test)] -mod test { - use super::*; - use hex::FromHex; - - #[test] - fn representative_match() { - let mut repres = <[u8; 32]>::from_hex( - "8781b04fefa49473ca5943ab23a14689dad56f8118d5869ad378c079fd2f4079", - ) - .unwrap(); - let incorrect = "1af2d7ac95b5dd1ab2b5926c9019fa86f211e77dd796f178f3fe66137b0d5d15"; - let expected = "a946c3dd16d99b8c38972584ca599da53e32e8b13c1e9a408ff22fdb985c2d79"; - - // we are not clearing the high order bits before translating the representative to a - // public key. - repres[31] &= 0x3f; - - let r = PublicRepresentative::from(repres); - let p = PublicKey::from(&r); - assert_ne!(incorrect, hex::encode(p.as_bytes())); - assert_eq!(expected, hex::encode(p.as_bytes())); - } -} diff --git a/crates/o5/src/common/mlkem1024_x25519.rs b/crates/o5/src/common/mlkem1024_x25519.rs new file mode 100644 index 0000000..414f1c5 --- /dev/null +++ b/crates/o5/src/common/mlkem1024_x25519.rs @@ -0,0 +1,324 @@ +//! Combined Kyber (ML-KEM) 1024 and X25519 Hybrid Public Key Encryption (HPKE) scheme. +//! +//! > For the client's share, the key_exchange value contains the +//! > concatenation of the client's X25519 ephemeral share (32 bytes) and +//! > the client's Kyber768Draft00 public key (1184 bytes). The resulting +//! > key_exchange value is 1216 bytes in length. +//! > +//! > For the server's share, the key_exchange value contains the +//! > concatenation of the server's X25519 ephemeral share (32 bytes) and +//! > the Kyber768Draft00 ciphertext (1088 bytes) returned from +//! > encapsulation for the client's public key. The resulting +//! > key_exchange value is 1120 bytes in length. +//! > +//! > The shared secret is calculated as the concatenation of the X25519 +//! > shared secret (32 bytes) and the Kyber768Draft00 shared secret (32 +//! > bytes). The resulting shared secret value is 64 bytes in length. + +use kem::{Decapsulate, Encapsulate}; +use kemeleon::{DecapsulationKey, EncapsulationKey, Encode, OKemCore}; +use rand::{CryptoRng, RngCore}; +use rand_core::CryptoRngCore; +use subtle::ConstantTimeEq; + +use crate::{Error, Result}; + +pub(crate) use kemeleon::EncodeError; + +pub(crate) const X25519_PUBKEY_LEN: usize = 32; +pub(crate) const X25519_PRIVKEY_LEN: usize = 32; +pub(crate) const MLKEM1024_PUBKEY_LEN: usize = 1530; +pub(crate) const PUBKEY_LEN: usize = MLKEM1024_PUBKEY_LEN + X25519_PUBKEY_LEN; +pub(crate) const PRIVKEY_LEN: usize = 1; + +pub struct StaticSecret(HybridKey); + +struct HybridKey { + x25519: x25519_dalek::StaticSecret, + mlkem: DecapsulationKey, + pub_key: PublicKey, +} + +#[derive(Clone, PartialEq)] +pub(crate) struct PublicKey { + x25519: x25519_dalek::PublicKey, + mlkem: EncapsulationKey, + pub_key: [u8; PUBKEY_LEN], +} + +impl StaticSecret { + pub fn random_from_rng(rng: &mut R) -> Self { + Self(HybridKey::new(rng)) + } + + // TODO: THIS NEEDS TESTED + pub fn try_from_bytes(bytes: impl AsRef<[u8]>) -> Result { + let buf = bytes.as_ref(); + + let sk: [u8; X25519_PRIVKEY_LEN] = core::array::from_fn(|i| buf[i]); + let x25519 = x25519_dalek::StaticSecret::from(sk); + + let mlkem = DecapsulationKey::from_fips_bytes(&buf[X25519_PRIVKEY_LEN..]) + .map_err(|e| Error::EncodeError(e.into()))?; + + let pubkey_buf: [u8; PUBKEY_LEN] = core::array::from_fn(|i| buf[PRIVKEY_LEN + i]); + let pub_key = PublicKey::try_from(pubkey_buf)?; + + Ok(Self(HybridKey { + pub_key, + mlkem, + x25519, + })) + } + + pub fn as_bytes(&self) -> [u8; PRIVKEY_LEN + PUBKEY_LEN] { + let mut out = [0u8; PRIVKEY_LEN + PUBKEY_LEN]; + out[..X25519_PRIVKEY_LEN].copy_from_slice(&self.0.x25519.to_bytes()[..]); + out[X25519_PRIVKEY_LEN..PRIVKEY_LEN].copy_from_slice(&self.0.mlkem.to_fips_bytes()[..]); + out[PRIVKEY_LEN..PRIVKEY_LEN + PUBKEY_LEN].copy_from_slice(&self.0.pub_key.as_bytes()); + out + } + + pub fn with_pub<'a>(&'a self, pubkey: &'a PublicKey) -> KeyMix<'a> { + self.0.with_pub(pubkey) + } + + /// Hybrid Public Key Encryption (HPKE) handshake for ML-KEM1024 + X25519 + /// + /// This is a custom interface for now as there isn't an example interface that I am aware of. + /// (Read - this will likely change in the future) + pub fn hpke( + &self, + rng: &mut R, + pubkey: &PublicKey, + ) -> Result<(Ciphertext, SharedSecret)> { + self.with_pub(&pubkey) + .encapsulate(rng) + .map_err(|e| Error::Crypto(e.to_string())) + } +} + +impl core::fmt::Debug for PublicKey { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", hex::encode(self.as_bytes())) + } +} + +impl PublicKey { + pub fn as_bytes(&self) -> &[u8] { + &self.pub_key + } +} + +impl From<&StaticSecret> for PublicKey { + fn from(value: &StaticSecret) -> Self { + value.0.public_key().clone() + } +} + +impl TryFrom<[u8; PUBKEY_LEN]> for PublicKey { + type Error = Error; + fn try_from(value: [u8; PUBKEY_LEN]) -> Result { + let mut x25519 = [0u8; X25519_PUBKEY_LEN]; + x25519.copy_from_slice(&value[..X25519_PUBKEY_LEN]); + + let mlkem = EncapsulationKey::try_from_bytes(&value[X25519_PUBKEY_LEN..]) + .map_err(|e| Error::EncodeError(e.into()))?; + + Ok(Self { + x25519: x25519.into(), + mlkem, + pub_key: value, + }) + } +} + +pub struct SharedSecret { + x25519: x25519_dalek::SharedSecret, + x25519_raw: [u8; 32], + mlkem: [u8; 32], +} + +impl PartialEq for SharedSecret { + fn eq(&self, other: &Self) -> bool { + self.x25519_raw.ct_eq(&other.x25519_raw).into() && self.mlkem.ct_eq(&other.mlkem).into() + } +} + +impl SharedSecret { + // TODO: Test this layout to make sure this works. + // SAFETY: the type of the SharedSecret object means this should never fail + pub fn as_bytes(&self) -> &[u8] { + unsafe { std::slice::from_raw_parts(self.x25519_raw.as_ptr(), 64) } + } + + /// Ensure in constant-time that the x25519 portion of this shared secret did not result + /// from a key exchange with non-contributory behaviour. + pub fn was_contributory(&self) -> bool { + self.x25519.was_contributory() + } +} + +impl core::fmt::Debug for SharedSecret { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!( + f, + "{} {}", + hex::encode(self.x25519_raw), + hex::encode(self.mlkem) + ) + } +} + +impl HybridKey { + fn new(rng: &mut R) -> Self { + let (dk, ek) = kemeleon::MlKem1024::generate(rng); + let x25519 = x25519_dalek::StaticSecret::random_from_rng(rng); + let x25519_pub = x25519_dalek::PublicKey::from(&x25519); + let mut pub_key = [0u8; PUBKEY_LEN]; + pub_key[..X25519_PUBKEY_LEN].copy_from_slice(x25519_pub.as_bytes()); + pub_key[X25519_PUBKEY_LEN..].copy_from_slice(&ek.as_bytes()); + + Self { + pub_key: PublicKey { + x25519: x25519_dalek::PublicKey::from(&x25519), + mlkem: ek, + pub_key, + }, + mlkem: dk, + x25519, + } + } + + fn public_key(&self) -> &PublicKey { + &self.pub_key + } + + fn with_pub<'a>(&'a self, pubkey: &'a PublicKey) -> KeyMix<'a> { + KeyMix { + local_private: self, + remote_public: pubkey, + } + } +} + +pub struct KeyMix<'a> { + local_private: &'a HybridKey, + remote_public: &'a PublicKey, +} + +impl Encapsulate for KeyMix<'_> { + type Error = EncodeError; + + // Diffie Helman / Encapsulate + fn encapsulate( + &self, + rng: &mut impl CryptoRngCore, + ) -> std::result::Result<(Ciphertext, SharedSecret), Self::Error> { + let (ciphertext, local_ss_mlkem) = self.remote_public.mlkem.encapsulate(rng).unwrap(); + let local_ss_x25519 = self + .local_private + .x25519 + .diffie_hellman(&self.remote_public.x25519); + let ss = SharedSecret { + x25519_raw: (&local_ss_x25519).to_bytes(), + mlkem: local_ss_mlkem.into(), + x25519: local_ss_x25519, + }; + let mut ct = x25519_dalek::PublicKey::from(&self.local_private.x25519) + .as_bytes() + .to_vec(); + ct.append(&mut ciphertext.as_bytes().to_vec()); + Ok((ct, ss)) + } +} + +pub type Ciphertext = Vec; + +impl Decapsulate for HybridKey { + type Error = EncodeError; + + // Required method + fn decapsulate( + &self, + encapsulated_key: &Ciphertext, + ) -> std::result::Result { + let arr = kemeleon::Ciphertext::try_from(&encapsulated_key[32..])?; + let local_ss_mlkem = self.mlkem.decapsulate(&arr)?; + + let mut remote_public = [0u8; 32]; + remote_public[..32].copy_from_slice(&encapsulated_key[..32]); + let local_ss_x25519 = self + .x25519 + .diffie_hellman(&x25519_dalek::PublicKey::from(remote_public)); + + Ok(SharedSecret { + x25519_raw: (&local_ss_x25519).to_bytes(), + mlkem: local_ss_mlkem.into(), + x25519: local_ss_x25519, + }) + } +} + +#[cfg(test)] +mod test { + use super::*; + use kemeleon::MlKem1024; + + #[test] + fn example_lib_usage() { + let rng = &mut rand::thread_rng(); + let alice_priv_key = HybridKey::new(rng); + let alice_pub = alice_priv_key.public_key(); + + let bob_priv_key = HybridKey::new(rng); + let (ct, bob_ss) = bob_priv_key.with_pub(alice_pub).encapsulate(rng).unwrap(); + + let alice_ss = alice_priv_key.decapsulate(&ct).unwrap(); + assert_eq!(alice_ss, bob_ss); + } + + #[test] + fn it_works() { + let mut rng = rand::thread_rng(); + + // --- Generate Keypair (Alice) --- + // x25519 + let alice_secret = x25519_dalek::StaticSecret::random_from_rng(&mut rng); + let alice_public = x25519_dalek::PublicKey::from(&alice_secret); + // mlkem + let (alice_mlkem_dk, alice_mlkem_ek) = MlKem1024::generate(&mut rng); + + // --- alice -> bob (public keys) --- + // alice sends bob the public key for her mlkem1024 keypair with her + // x25519 key appended to the end. + let mut mlkem1024x_pubkey = alice_public.as_bytes().to_vec(); + mlkem1024x_pubkey.extend_from_slice(&alice_mlkem_ek.as_bytes()); + + assert_eq!(mlkem1024x_pubkey.len(), 1562); + + // --- Generate Keypair (Bob) --- + // x25519 + let bob_secret = x25519_dalek::StaticSecret::random_from_rng(&mut rng); + let bob_public = x25519_dalek::PublicKey::from(&bob_secret); + + // (Imagine) upon receiving the mlkemx25519 public key bob parses them + // into their respective structs from bytes + + // Bob encapsulates a shared secret using Alice's public key + let (ciphertext, shared_secret_bob) = alice_mlkem_ek.encapsulate(&mut rng).unwrap(); + let bob_shared_secret = bob_secret.diffie_hellman(&alice_public); + + // // Alice decapsulates a shared secret using the ciphertext sent by Bob + let shared_secret_alice = alice_mlkem_dk.decapsulate(&ciphertext).unwrap(); + let alice_shared_secret = alice_secret.diffie_hellman(&bob_public); + + assert_eq!(alice_shared_secret.as_bytes(), bob_shared_secret.as_bytes()); + assert_eq!(shared_secret_bob, shared_secret_alice); + println!( + "{} ?= {}", + hex::encode(shared_secret_bob), + hex::encode(shared_secret_alice) + ); + } +} diff --git a/crates/o5/src/common/mod.rs b/crates/o5/src/common/mod.rs index 3ea0ed6..b3a1e9b 100644 --- a/crates/o5/src/common/mod.rs +++ b/crates/o5/src/common/mod.rs @@ -5,17 +5,18 @@ use hmac::Hmac; use sha2::Sha256; pub(crate) mod ct; -pub(crate) mod curve25519; pub(crate) mod kdf; +pub(crate) mod utils; mod skip; pub use skip::discard; pub mod drbg; -// pub mod ntor; +pub mod mlkem1024_x25519; pub mod ntor_arti; pub mod probdist; pub mod replay_filter; +pub mod x25519_elligator2; pub trait ArgParse { type Output; diff --git a/crates/o5/src/common/ntor_arti/mod.rs b/crates/o5/src/common/ntor_arti.rs similarity index 74% rename from crates/o5/src/common/ntor_arti/mod.rs rename to crates/o5/src/common/ntor_arti.rs index 34ba8dc..897f429 100644 --- a/crates/o5/src/common/ntor_arti/mod.rs +++ b/crates/o5/src/common/ntor_arti.rs @@ -10,34 +10,77 @@ //! //! Currently, this module implements only the "ntor" handshake used //! for circuits on today's Tor. -use std::borrow::Borrow; +use std::io::{Error as IoError, ErrorKind as IoErrorKind}; -use crate::Result; +use crate::{ + common::{colorize, mlkem1024_x25519}, + Error, Result, +}; //use zeroize::Zeroizing; use tor_bytes::SecretBuf; +pub const SESSION_ID_LEN: usize = 8; +#[derive(PartialEq, PartialOrd, Clone, Copy)] +pub struct SessionID([u8; SESSION_ID_LEN]); + +impl core::fmt::Display for SessionID { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "[{}]", colorize(hex::encode(&self.0))) + } +} + +impl core::fmt::Debug for SessionID { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{self}") + } +} + +impl From<[u8; SESSION_ID_LEN]> for SessionID { + fn from(value: [u8; SESSION_ID_LEN]) -> Self { + SessionID(value) + } +} + +impl TryFrom<&[u8]> for SessionID { + type Error = Error; + fn try_from(buf: &[u8]) -> Result { + if buf.len() < SESSION_ID_LEN { + return Err( + IoError::new(IoErrorKind::InvalidInput, "too few bytes for session id").into(), + ); + } + let v: [u8; SESSION_ID_LEN] = core::array::from_fn(|i| buf[i]); + Ok(SessionID(v)) + } +} + +pub trait ClientHandshakeMaterials { + /// The type for the onion key. + type IdentityKeyType; + /// Type of extra data sent from client (without forward secrecy). + type ClientAuxData: ?Sized; + + fn node_pubkey(&self) -> &Self::IdentityKeyType; + fn aux_data(&self) -> Option<&Self::ClientAuxData>; +} + /// A ClientHandshake is used to generate a client onionskin and /// handle a relay onionskin. -pub(crate) trait ClientHandshake { - /// The type for the onion key. - type KeyType; +pub trait ClientHandshake { + type HandshakeMaterials: ClientHandshakeMaterials; /// The type for the state that the client holds while waiting for a reply. type StateType; /// A type that is returned and used to generate session keys.x type KeyGen; - /// Type of extra data sent from client (without forward secrecy). - type ClientAuxData: ?Sized; /// Type of extra data returned by server (without forward secrecy). type ServerAuxData; + /// Generate a new client onionskin for a relay with a given onion key, /// including `client_aux_data` to be sent without forward secrecy. /// /// On success, return a state object that will be used to /// complete the handshake, along with the message to send. - fn client1>( - key: &Self::KeyType, - client_aux_data: &M, - ) -> Result<(Self::StateType, Vec)>; + fn client1(materials: Self::HandshakeMaterials) -> Result<(Self::StateType, Vec)>; /// Handle an onionskin from a relay, and produce aux data returned /// from the server, and a key generator. /// @@ -75,10 +118,12 @@ where } /// A ServerHandshake is used to handle a client onionskin and generate a -/// server onionskin. +/// server onionskin. It is assumed that the (long term identity) keys are stored +/// as part of the object implementing this trait. pub(crate) trait ServerHandshake { - /// The type for the onion key. This is a private key type. - type KeyType; + /// Custom parameters used per handshake rather than long lived config stored + /// in the object implementing this trait. + type HandshakeParams; /// The returned key generator type. type KeyGen; /// Type of extra data sent from client (without forward secrecy). @@ -98,7 +143,7 @@ pub(crate) trait ServerHandshake { fn server, T: AsRef<[u8]>>( &self, reply_fn: &mut REPLY, - key: &[Self::KeyType], + materials: &Self::HandshakeParams, msg: T, ) -> RelayHandshakeResult<(Self::KeyGen, Vec)>; } @@ -115,6 +160,11 @@ pub trait KeyGenerator { fn expand(self, keylen: usize) -> Result; } +pub trait SessionIdentifier { + type ID: core::fmt::Display + core::fmt::Debug + PartialEq; + fn session_id(&mut self) -> Self::ID; +} + /// Generates keys based on SHAKE-256. pub(crate) struct ShakeKeyGenerator { /// Seed for the key generator @@ -137,7 +187,7 @@ impl KeyGenerator for ShakeKeyGenerator { } /// An error produced by a Relay's attempt to handle a client's onion handshake. -#[derive(Clone, Debug, thiserror::Error)] +#[derive(Debug, thiserror::Error)] pub enum RelayHandshakeError { /// Occurs when a check did not fail, but requires updated input from the /// calling context. For example, a handshake that requires more bytes to @@ -149,6 +199,10 @@ pub enum RelayHandshakeError { #[error("Problem decoding onion handshake")] Fmt(#[from] tor_bytes::Error), + /// Error happened during cryptographic handshake + #[error("")] + CryptoError(mlkem1024_x25519::EncodeError), + /// The client asked for a key we didn't have. #[error("Client asked for a key or ID that we don't have")] MissingKey, diff --git a/crates/o5/src/common/skip.rs b/crates/o5/src/common/skip.rs index a2538ea..0ecaf3a 100644 --- a/crates/o5/src/common/skip.rs +++ b/crates/o5/src/common/skip.rs @@ -2,8 +2,6 @@ use crate::Result; use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt}; -// use std::pin::Pin; -// use std::task::{Context, Poll}; use std::time::Duration; /// copies all data from the reader to a sink. If the reader closes before diff --git a/crates/o5/src/handshake/utils.rs b/crates/o5/src/common/utils.rs similarity index 100% rename from crates/o5/src/handshake/utils.rs rename to crates/o5/src/common/utils.rs diff --git a/crates/o5/src/common/x25519_elligator2.rs b/crates/o5/src/common/x25519_elligator2.rs new file mode 100644 index 0000000..85a9b2e --- /dev/null +++ b/crates/o5/src/common/x25519_elligator2.rs @@ -0,0 +1,403 @@ +//! Re-exporting Curve25519 implementations. +//! +//! *TODO*: Eventually we should probably recommend using this code via some +//! key-agreement trait, but for now we are just wrapping and re-using the APIs +//! from [`x25519_dalek`]. + +pub use curve25519_elligator2::{MapToPointVariant, Randomized}; +use getrandom::getrandom; +#[allow(unused)] +pub use x25519_dalek::{PublicKey, SharedSecret, StaticSecret}; + +/// Ephemeral Key for X25519 Handshakes which intentionally makes writing out the +/// private key value difficult. +/// +/// You can do a Diffie-Hellman exchange with this key multiple times and derive +/// the elligator2 representative, but you cannot write it out, as it is +/// intended to be used only ONCE (i.e. ephemerally). If the key generation +/// succeeds, the key is guaranteed to have a valid elligator2 representative. +#[derive(Clone)] +pub struct EphemeralSecret(x25519_dalek::StaticSecret, u8); + +#[allow(unused)] +impl EphemeralSecret { + pub fn random() -> Self { + Keys::random_ephemeral() + } + + pub fn random_from_rng(csprng: T) -> Self { + Keys::ephemeral_from_rng(csprng) + } + + pub fn diffie_hellman(&self, their_public: &PublicKey) -> SharedSecret { + self.0.diffie_hellman(their_public) + } + + #[cfg(test)] + /// As this function allows building an ['EphemeralSecret'] with a custom secret key, + /// it is not guaranteed to have a valid elligator2 representative. As such, it + /// is intended for testing purposes only. + pub(crate) fn from_parts(sk: StaticSecret, tweak: u8) -> Self { + Self(sk, tweak) + } +} + +impl From for PublicKey { + fn from(value: EphemeralSecret) -> Self { + let pk_bytes = Randomized::mul_base_clamped(value.0.to_bytes()).to_montgomery(); + PublicKey::from(*pk_bytes.as_bytes()) + } +} + +impl<'a> From<&'a EphemeralSecret> for PublicKey { + fn from(val: &'a EphemeralSecret) -> Self { + let pk_bytes = Randomized::mul_base_clamped(val.0.to_bytes()).to_montgomery(); + PublicKey::from(*pk_bytes.as_bytes()) + } +} + +/// [`PublicKey`] transformation to a format indistinguishable from uniform +/// random. +/// +/// This allows public keys to be sent over an insecure channel without +/// revealing that an x25519 public key is being shared. +/// +/// # Example +/// ``` +/// use o5::common::x25519_elligator2::{Keys, PublicRepresentative, PublicKey}; +/// +/// // Generate Alice's key pair. +/// let alice_secret = Keys::random_ephemeral(); +/// let alice_representative = PublicRepresentative::from(&alice_secret); +/// +/// // Generate Bob's key pair. +/// let bob_secret = Keys::random_ephemeral(); +/// let bob_representative = PublicRepresentative::from(&bob_secret); +/// +/// // Alice and Bob should now exchange their representatives and reveal the +/// // public key from the other person. +/// let bob_public = PublicKey::from(&bob_representative); +/// +/// let alice_public = PublicKey::from(&alice_representative); +/// +/// // Once they've done so, they may generate a shared secret. +/// let alice_shared = alice_secret.diffie_hellman(&bob_public); +/// let bob_shared = bob_secret.diffie_hellman(&alice_public); +/// +/// assert_eq!(alice_shared.as_bytes(), bob_shared.as_bytes()); +/// ``` +#[derive(PartialEq, Eq, Hash, Copy, Clone, Debug)] +pub struct PublicRepresentative([u8; 32]); + +impl PublicRepresentative { + /// View this public representative as a byte array. + #[inline] + pub fn as_bytes(&self) -> &[u8; 32] { + &self.0 + } + + /// Extract this representative's bytes for serialization. + #[inline] + pub fn to_bytes(&self) -> [u8; 32] { + self.0 + } +} + +impl AsRef<[u8]> for PublicRepresentative { + /// View this shared secret key as a byte array. + #[inline] + fn as_ref(&self) -> &[u8] { + self.as_bytes() + } +} + +impl From<[u8; 32]> for PublicRepresentative { + /// Build a Elligator2 Public key Representative from bytes + fn from(r: [u8; 32]) -> PublicRepresentative { + PublicRepresentative(r) + } +} + +impl<'a> From<&'a [u8; 32]> for PublicRepresentative { + /// Build a Elligator2 Public key Representative from bytes by reference + fn from(r: &'a [u8; 32]) -> PublicRepresentative { + PublicRepresentative(*r) + } +} + +impl<'a> From<&'a EphemeralSecret> for PublicRepresentative { + /// Given an x25519 [`EphemeralSecret`] key, compute its corresponding [`PublicRepresentative`]. + fn from(secret: &'a EphemeralSecret) -> PublicRepresentative { + let res: Option<[u8; 32]> = + Randomized::to_representative(secret.0.as_bytes(), secret.1).into(); + PublicRepresentative(res.unwrap()) + } +} + +impl<'a> From<&'a PublicRepresentative> for PublicKey { + /// Given an elligator2 [`PublicRepresentative`], compute its corresponding [`PublicKey`]. + fn from(representative: &'a PublicRepresentative) -> PublicKey { + let point = curve25519_elligator2::MontgomeryPoint::map_to_point(&representative.0); + PublicKey::from(*point.as_bytes()) + } +} + +impl From for PublicKey { + /// Given an elligator2 [`PublicRepresentative`], compute its corresponding [`PublicKey`]. + fn from(representative: PublicRepresentative) -> PublicKey { + let point = curve25519_elligator2::MontgomeryPoint::map_to_point(&representative.0); + PublicKey::from(*point.as_bytes()) + } +} + +use rand_core::{CryptoRng, RngCore}; + +pub const REPRESENTATIVE_LENGTH: usize = 32; + +/// A collection of functions for generating x25519 keys wrapping `x25519_dalek`. +// ['EphemeralSecret'] keys are guaranteed to have a valid elligator2 representative. In general +// ['StaticSecret'] should not be converted to PublicRepresentative, use an EphemeralSecret instead. +pub struct Keys; + +trait RetryLimit { + const RETRY_LIMIT: usize = 128; +} + +impl RetryLimit for Keys {} + +#[allow(unused)] +impl Keys { + /// Generate a new Elligator2 representable ['StaticSecret'] with the supplied RNG. + pub fn static_from_rng(mut rng: R) -> StaticSecret { + StaticSecret::random_from_rng(&mut rng) + } + + /// Generate a new Elligator2 representable ['StaticSecret']. + pub fn random_static() -> StaticSecret { + StaticSecret::random() + } + + /// Generate a new Elligator2 representable ['EphemeralSecret'] with the supplied RNG. + /// + /// May panic if the provided csprng fails to generate random values such that no generated + /// secret key maps to a valid elligator2 representative. This should never happen + /// when system CSPRNGs are used (i.e `rand::thread_rng`). + pub fn ephemeral_from_rng(mut csprng: R) -> EphemeralSecret { + let mut private = StaticSecret::random_from_rng(&mut csprng); + + // tweak only needs generated once as it doesn't affect the elligator2 representative validity. + let mut tweak = [0u8]; + csprng.fill_bytes(&mut tweak); + + let mut repres: Option<[u8; 32]> = + Randomized::to_representative(&private.to_bytes(), tweak[0]).into(); + + for _ in 0..Self::RETRY_LIMIT { + if repres.is_some() { + return EphemeralSecret(private, tweak[0]); + } + private = StaticSecret::random_from_rng(&mut csprng); + repres = Randomized::to_representative(&private.to_bytes(), tweak[0]).into(); + } + + panic!("failed to generate representable secret, bad RNG provided"); + } + + /// Generate a new Elligator2 representable ['EphemeralSecret']. + /// + /// May panic if the system random genereator fails such that no generated + /// secret key maps to a valid elligator2 representative. This should never + /// happen under normal use. + pub fn random_ephemeral() -> EphemeralSecret { + let mut private = StaticSecret::random(); + // + // tweak only needs generated once as it doesn't affect the elligator2 representative validity. + let mut tweak = [0u8]; + getrandom(&mut tweak); + + let mut repres: Option<[u8; 32]> = + Randomized::to_representative(&private.to_bytes(), tweak[0]).into(); + + for _ in 0..Self::RETRY_LIMIT { + if repres.is_some() { + return EphemeralSecret(private, tweak[0]); + } + private = StaticSecret::random(); + repres = Randomized::to_representative(&private.to_bytes(), tweak[0]).into(); + } + + panic!("failed to generate representable secret, getrandom failed"); + } +} + +#[cfg(test)] +mod test { + use super::*; + use crate::Result; + + use curve25519_elligator2::{ + traits::IsIdentity, EdwardsPoint, MapToPointVariant, MontgomeryPoint, Randomized, RFC9380, + }; + use hex::FromHex; + + use rand::Rng; + + #[test] + fn representative_match() { + let repres = <[u8; 32]>::from_hex( + "8781b04fefa49473ca5943ab23a14689dad56f8118d5869ad378c079fd2f4079", + ) + .unwrap(); + let incorrect = "1af2d7ac95b5dd1ab2b5926c9019fa86f211e77dd796f178f3fe66137b0d5d15"; + let expected = "a946c3dd16d99b8c38972584ca599da53e32e8b13c1e9a408ff22fdb985c2d79"; + + let r = PublicRepresentative::from(repres); + let p = PublicKey::from(&r); + assert_ne!(incorrect, hex::encode(p.as_bytes())); + assert_eq!(expected, hex::encode(p.as_bytes())); + } + + /// This test confirms that only about half of the `StaticSecret`s generated have + /// valid representatives. This is expected - in ['Keys'] we rely on this fact + /// to ensure that (given the provided csprng works) generating in a loop + /// should statiscally never fail to generate a representable key. + #[test] + fn about_half() -> Result<()> { + let mut rng = rand::thread_rng(); + + let mut success = 0; + let mut not_found = 0; + let mut not_match = 0; + for _ in 0..1_000 { + let sk = StaticSecret::random_from_rng(&mut rng); + let rp: Option<[u8; 32]> = Randomized::to_representative(sk.as_bytes(), 0_u8).into(); + let repres = match rp { + Some(r) => PublicRepresentative::from(r), + None => { + not_found += 1; + continue; + } + }; + + let pk_bytes = Randomized::mul_base_clamped(sk.to_bytes()).to_montgomery(); + + let pk = PublicKey::from(*pk_bytes.as_bytes()); + + let decoded_pk = PublicKey::from(&repres); + if hex::encode(pk) != hex::encode(decoded_pk) { + not_match += 1; + continue; + } + success += 1; + } + + if not_match != 0 { + println!("{not_found}/{not_match}/{success}/10_000"); + assert_eq!(not_match, 0); + } + assert!(not_found < 600); + assert!(not_found > 400); + Ok(()) + } + + #[test] + fn it_works() { + // if this panics we are in trouble + let k = EphemeralSecret::random(); + + // internal serialization and deserialization works + let k_bytes = k.0.as_bytes(); + let _k1 = EphemeralSecret::from_parts(StaticSecret::from(*k_bytes), 0u8); + + // if we send our representative over the wire then recover the pubkey they should match + let pk = PublicKey::from(&k); + let r = PublicRepresentative::from(&k); + let r_bytes = r.to_bytes(); + // send r_bytes over the network + let r1 = PublicRepresentative::from(r_bytes); + let pk1 = PublicKey::from(r1); + assert_eq!(hex::encode(pk.to_bytes()), hex::encode(pk1.to_bytes())); + } + + const BASEPOINT_ORDER_MINUS_ONE: [u8; 32] = [ + 0xec, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, + 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x10, + ]; + + // Generates a new Keypair using, and returns the public key representative + // along, with its public key as a newly allocated edwards25519.Point. + fn generate(rng: &mut R) -> ([u8; 32], EdwardsPoint) { + for _ in 0..63 { + let y_sk = rng.gen::<[u8; 32]>(); + + let y_repr_bytes = match Randomized::to_representative(&y_sk, 0xff).into() { + Some(r) => r, + None => continue, + }; + let y_pk = Randomized::mul_base_clamped(y_sk); + + assert_eq!( + MontgomeryPoint::from_representative::(&y_repr_bytes) + .expect("failed to re-derive point from representative"), + y_pk.to_montgomery() + ); + + return (y_repr_bytes, y_pk); + } + panic!("failed to generate a valid keypair"); + } + + /// Returns a new edwards25519.Point that is v multiplied by the subgroup order. + /// + /// BASEPOINT_ORDER_MINUS_ONE is the same as scMinusOne in filippo.io/edwards25519. + /// https://github.com/FiloSottile/edwards25519/blob/v1.0.0/scalar.go#L34 + fn scalar_mult_order(v: &EdwardsPoint) -> EdwardsPoint { + let order = curve25519_elligator2::Scalar::from_bytes_mod_order(BASEPOINT_ORDER_MINUS_ONE); + + // v * (L - 1) + v => v * L + let p = v * order; + p + v + } + + #[test] + fn off_subgroup_check_edw() { + let mut count = 0; + let n_trials = 100; + let mut rng = rand::thread_rng(); + for _ in 0..n_trials { + let (repr, pk) = generate(&mut rng); + + // check if the generated public key is off the subgroup + let v = scalar_mult_order(&pk); + let _pk_off = !v.is_identity(); + + // ---- + + // check if the public key derived from the representative (top bit 0) + // is off the subgroup + let mut yr_255 = repr; + yr_255[31] &= 0xbf; + let pk_255 = EdwardsPoint::from_representative::(&yr_255) + .expect("from_repr_255, should never fail"); + let v = scalar_mult_order(&pk_255); + let off_255 = !v.is_identity(); + + // check if the public key derived from the representative (top two bits 0 - as + // our representatives are) is off the subgroup. + let mut yr_254 = repr; + yr_254[31] &= 0x3f; + let pk_254 = EdwardsPoint::from_representative::(&yr_254) + .expect("from_repr_254, should never fail"); + let v = scalar_mult_order(&pk_254); + let off_254 = !v.is_identity(); + + // println!("pk_gen: {pk_off}, pk_255: {off_255}, pk_254: {off_254}"); + if off_254 && off_255 { + count += 1; + } + } + assert!(count > 0); + assert!(count < n_trials); + } +} diff --git a/crates/o5/src/constants.rs b/crates/o5/src/constants.rs index db8a870..9af94e8 100644 --- a/crates/o5/src/constants.rs +++ b/crates/o5/src/constants.rs @@ -1,15 +1,18 @@ #![allow(unused)] -use tor_llcrypto::pk::rsa::RSA_ID_LEN; +use tor_llcrypto::pk::ed25519::ED25519_ID_LEN; +pub use crate::common::ntor_arti::SESSION_ID_LEN; use crate::{ - common::{curve25519::REPRESENTATIVE_LENGTH, drbg}, + common::{drbg, mlkem1024_x25519, x25519_elligator2::REPRESENTATIVE_LENGTH}, framing, handshake::AUTHCODE_LENGTH, }; use std::time::Duration; +pub const PUBLIC_KEY_LEN: usize = mlkem1024_x25519::PUBKEY_LEN; + //=========================[Framing/Msgs]=====================================// /// Maximum handshake size including padding @@ -51,7 +54,6 @@ pub const NODE_ID_ARG: &str = "node-id"; pub const PUBLIC_KEY_ARG: &str = "public-key"; pub const PRIVATE_KEY_ARG: &str = "private-key"; pub const SEED_ARG: &str = "drbg-seed"; -pub const IAT_ARG: &str = "iat-mode"; pub const CERT_ARG: &str = "cert"; pub const BIAS_CMD_ARG: &str = "obfs4-distBias"; @@ -66,14 +68,12 @@ pub const CLIENT_HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(60); #[cfg(not(test))] pub const SERVER_HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(60); -pub const MAX_IAT_DELAY: usize = 100; +pub const MAX_IPT_DELAY: usize = 100; pub const MAX_CLOSE_DELAY: usize = 60; pub const MAX_CLOSE_DELAY_BYTES: usize = MAX_HANDSHAKE_LENGTH; pub const SEED_LENGTH: usize = drbg::SEED_LENGTH; pub const HEADER_LENGTH: usize = framing::FRAME_OVERHEAD + framing::MESSAGE_OVERHEAD; -pub const SESSION_ID_LEN: usize = 8; - -pub const NODE_ID_LENGTH: usize = RSA_ID_LEN; -pub const NODE_PUBKEY_LENGTH: usize = 32; +pub const NODE_ID_LENGTH: usize = ED25519_ID_LEN; +pub const NODE_PUBKEY_LENGTH: usize = mlkem1024_x25519::PUBKEY_LEN; diff --git a/crates/o5/src/error.rs b/crates/o5/src/error.rs index 0f50b3d..901ede1 100644 --- a/crates/o5/src/error.rs +++ b/crates/o5/src/error.rs @@ -1,6 +1,7 @@ use crate::framing::FrameError; use std::array::TryFromSliceError; +use std::num::NonZeroUsize; use std::string::FromUtf8Error; use std::{fmt::Display, str::FromStr}; @@ -32,6 +33,16 @@ pub enum Error { BadCircHandshakeAuth, InvalidKDFOutputLength, + /// An error that occurred in the tor_bytes crate while decoding an + /// object. + // #[error("Unable to parse {object}")] + BytesError { + /// What we were trying to parse. + object: &'static str, + /// The error that occurred while parsing it. + // #[source] + err: tor_bytes::Error, + }, // TODO: do we need to keep this? CellDecodeErr { /// What we were trying to parse. @@ -63,6 +74,7 @@ impl Display for Error { Error::InvalidKDFOutputLength => { write!(f, "Tried to extract too many bytes from a KDF") } + Error::BytesError { object, err } => write!(f, "Unable to parse {object}: {err}"), Error::CellDecodeErr { object, err } => { write!(f, "Unable to decode cell {object}: {err}") } @@ -185,6 +197,24 @@ impl From for Error { } } +impl Error { + /// Create an error for a tor_bytes error that occurred while encoding + /// something of type `object`. + pub(crate) fn from_bytes_enc(err: tor_bytes::EncodeError, _object: &'static str) -> Error { + Error::EncodeError(Box::new(err)) + } + + /// Create an error for a tor_bytes error that occurred while parsing + /// something of type `object`. + pub(crate) fn from_bytes_err(err: tor_bytes::Error, object: &'static str) -> Error { + Error::BytesError { err, object } + } + + pub(crate) fn incomplete_error(_deficit: NonZeroUsize) -> tor_bytes::Error { + tor_bytes::Error::Truncated + } +} + #[cfg(test)] mod tests { use super::*; diff --git a/crates/o5/src/framing/codecs.rs b/crates/o5/src/framing/codecs.rs index f37e9c5..15cf707 100644 --- a/crates/o5/src/framing/codecs.rs +++ b/crates/o5/src/framing/codecs.rs @@ -7,7 +7,7 @@ use crate::{ use bytes::{Buf, BufMut, BytesMut}; use crypto_secretbox::{ aead::{generic_array::GenericArray, Aead, KeyInit}, - XSalsa20Poly1305, + XChaCha20Poly1305, }; use ptrs::{debug, error, trace}; use rand::prelude::*; @@ -199,7 +199,7 @@ impl Decoder for EncryptingCodec { // Unseal the frame let key = GenericArray::from_slice(&self.decoder.key); - let cipher = XSalsa20Poly1305::new(key); + let cipher = XChaCha20Poly1305::new(key); let nonce = GenericArray::from_slice(&self.decoder.next_nonce); // unique per message let res = cipher.decrypt(nonce, data.as_ref()); @@ -284,7 +284,7 @@ impl Encoder for EncryptingCodec { // Encrypt and MAC payload let key = GenericArray::from_slice(&self.encoder.key); - let cipher = XSalsa20Poly1305::new(key); + let cipher = XChaCha20Poly1305::new(key); let nonce = GenericArray::from_slice(&nonce_bytes); // unique per message let ciphertext = cipher.encrypt(nonce, plaintext_frame.as_ref())?; diff --git a/crates/o5/src/framing/handshake.rs b/crates/o5/src/framing/handshake.rs index fdab8fd..ed88886 100644 --- a/crates/o5/src/framing/handshake.rs +++ b/crates/o5/src/framing/handshake.rs @@ -1,91 +1,94 @@ use crate::{ common::{ - curve25519::{PublicKey, PublicRepresentative}, + utils::get_epoch_hour, // make_hs_pad}, HmacSha256, }, - constants::*, - handshake::{get_epoch_hour, make_hs_pad, Authcode, AUTHCODE_LENGTH}, + handshake::{Authcode, CHSMaterials, AUTHCODE_LENGTH}, + sessions::SessionPublicKey, Result, }; use bytes::BufMut; -use hmac::Mac; +use block_buffer::Eager; +use digest::{core_api::{BlockSizeUser, CoreProxy, UpdateCore, FixedOutputCore, BufferKindUser}, HashMarker}; +use hmac::{Hmac, Mac}; use ptrs::trace; -use rand::Rng; +use typenum::{consts::U256, operator_aliases::Le, type_operators::IsLess, marker_traits::NonZero}; +use tor_cell::relaycell::extend::NtorV3Extension; +use tor_llcrypto::d::Sha3_256; // -----------------------------[ Server ]----------------------------- pub struct ServerHandshakeMessage { server_auth: [u8; AUTHCODE_LENGTH], pad_len: usize, - repres: PublicRepresentative, - pubkey: Option, + session_pubkey: SessionPublicKey, epoch_hour: String, + aux_data: Vec, } impl ServerHandshakeMessage { - pub fn new( - repres: PublicRepresentative, - server_auth: [u8; AUTHCODE_LENGTH], - epoch_hr: String, - ) -> Self { - Self { - server_auth, - pad_len: rand::thread_rng().gen_range(SERVER_MIN_PAD_LENGTH..SERVER_MAX_PAD_LENGTH), - repres, - pubkey: None, - epoch_hour: epoch_hr, - } + pub fn new(_client_pubkey: SessionPublicKey, _session_pubkey: SessionPublicKey) -> Self { + todo!("SHS MSG - this should probably be built directly from the client HS MSG"); + // Self { + // server_auth: [0u8; AUTHCODE_LENGTH], + // pad_len: rand::thread_rng().gen_range(SERVER_MIN_PAD_LENGTH..SERVER_MAX_PAD_LENGTH), + // epoch_hour: epoch_hr, + // } } - pub fn server_pubkey(&mut self) -> PublicKey { - match self.pubkey { - Some(pk) => pk, - None => { - let pk = PublicKey::from(&self.repres); - self.pubkey = Some(pk); - pk - } - } + pub fn with_pad_len(&mut self, pad_len: usize) -> &Self { + self.pad_len = pad_len; + self + } + + pub fn with_aux_data(&mut self, aux_data: Vec) -> &Self { + self.aux_data = aux_data; + self + } + + pub fn server_pubkey(&mut self) -> SessionPublicKey { + self.session_pubkey.clone() } pub fn server_auth(self) -> Authcode { self.server_auth } - pub fn marshall(&mut self, buf: &mut impl BufMut, mut h: HmacSha256) -> Result<()> { + pub fn marshall(&mut self, _buf: &mut impl BufMut, mut _h: HmacSha256) -> Result<()> { trace!("serializing server handshake"); - - h.reset(); - h.update(self.repres.as_bytes().as_ref()); - let mark: &[u8] = &h.finalize_reset().into_bytes()[..MARK_LENGTH]; - - // The server handshake is Y | AUTH | P_S | M_S | MAC(Y | AUTH | P_S | M_S | E) where: - // * Y is the server's ephemeral Curve25519 public key representative. - // * AUTH is the ntor handshake AUTH value. - // * P_S is [serverMinPadLength,serverMaxPadLength] bytes of random padding. - // * M_S is HMAC-SHA256-128(serverIdentity | NodeID, Y) - // * MAC is HMAC-SHA256-128(serverIdentity | NodeID, Y .... E) - // * E is the string representation of the number of hours since the UNIX - // epoch. - - // Generate the padding - let pad: &[u8] = &make_hs_pad(self.pad_len)?; - - // Write Y, AUTH, P_S, M_S. - let mut params = vec![]; - params.extend_from_slice(self.repres.as_bytes()); - params.extend_from_slice(&self.server_auth); - params.extend_from_slice(pad); - params.extend_from_slice(mark); - buf.put(params.as_slice()); - - // Calculate and write MAC - h.update(¶ms); - h.update(self.epoch_hour.as_bytes()); - buf.put(&h.finalize_reset().into_bytes()[..MAC_LENGTH]); - - Ok(()) + todo!("marshall server hello"); + + // h.reset(); + // h.update(self.session_pubkey.as_bytes().as_ref()); + // let mark: &[u8] = &h.finalize_reset().into_bytes()[..MARK_LENGTH]; + + // // The server handshake is Y | AUTH | P_S | M_S | MAC(Y | AUTH | P_S | M_S | E) where: + // // * Y is the server's ephemeral Curve25519 public key representative. + // // * AUTH is the ntor handshake AUTH value. + // // * P_S is [serverMinPadLength,serverMaxPadLength] bytes of random padding. + // // * M_S is HMAC-SHA256-128(serverIdentity | NodeID, Y) + // // * MAC is HMAC-SHA256-128(serverIdentity | NodeID, Y .... E) + // // * E is the string representation of the number of hours since the UNIX + // // epoch. + + // // Generate the padding + // let pad: &[u8] = &make_hs_pad(self.pad_len)?; + + // // Write Y, AUTH, P_S, M_S. + // let mut params = vec![]; + // params.extend_from_slice(self.session_pubkey.as_bytes()); + // params.extend_from_slice(&self.server_auth); + // params.extend_from_slice(pad); + // params.extend_from_slice(mark); + // buf.put(params.as_slice()); + + // // Calculate and write MAC + // h.update(¶ms); + // h.update(self.epoch_hour.as_bytes()); + // buf.put(&h.finalize_reset().into_bytes()[..MAC_LENGTH]); + + // Ok(()) } } @@ -93,43 +96,28 @@ impl ServerHandshakeMessage { /// Preliminary message sent in an obfs4 handshake attempting to open a /// connection from a client to a potential server. -pub struct ClientHandshakeMessage { - pub(crate) pad_len: usize, - pub(crate) repres: PublicRepresentative, - pub(crate) pubkey: Option, +pub struct ClientHandshakeMessage<'a> { + hs_materials: &'a CHSMaterials, + client_session_pubkey: SessionPublicKey, // only used when parsing (i.e. on the server side) pub(crate) epoch_hour: String, } -impl ClientHandshakeMessage { - pub fn new(repres: PublicRepresentative, pad_len: usize, epoch_hour: String) -> Self { +impl<'a> ClientHandshakeMessage<'a> { + pub fn new(client_session_pubkey: SessionPublicKey, hs_materials: &'a CHSMaterials) -> Self { Self { - pad_len, - repres, - pubkey: None, + hs_materials, + client_session_pubkey, // only used when parsing (i.e. on the server side) - epoch_hour, - } - } - - pub fn get_public(&mut self) -> PublicKey { - trace!("repr: {}", hex::encode(self.repres)); - match self.pubkey { - Some(pk) => pk, - None => { - let pk = PublicKey::from(&self.repres); - self.pubkey = Some(pk); - pk - } + epoch_hour: get_epoch_hour().to_string(), } } - #[allow(unused)] - /// Return the elligator2 representative of the public key value. - pub fn get_representative(&self) -> PublicRepresentative { - self.repres + pub fn get_public(&mut self) -> SessionPublicKey { + // trace!("repr: {}", hex::encode(self.client_session_pubkey.id); + self.client_session_pubkey.clone() } /// return the epoch hour used in the ntor handshake. @@ -137,40 +125,60 @@ impl ClientHandshakeMessage { self.epoch_hour.clone() } - pub fn marshall(&mut self, buf: &mut impl BufMut, mut h: HmacSha256) -> Result<()> { + pub fn marshall( + &mut self, + buf: &mut impl BufMut, + key: &[u8], + ) -> Result<()> { trace!("serializing client handshake"); - h.reset(); // disambiguate reset() implementations Mac v digest - h.update(self.repres.as_bytes().as_ref()); - let mark: &[u8] = &h.finalize_reset().into_bytes()[..MARK_LENGTH]; - - // The client handshake is X | P_C | M_C | MAC(X | P_C | M_C | E) where: - // * X is the client's ephemeral Curve25519 public key representative. - // * P_C is [clientMinPadLength,clientMaxPadLength] bytes of random padding. - // * M_C is HMAC-SHA256-128(serverIdentity | NodeID, X) - // * MAC is HMAC-SHA256-128(serverIdentity | NodeID, X .... E) - // * E is the string representation of the number of hours since the UNIX - // epoch. - - // Generate the padding - let pad = make_hs_pad(self.pad_len)?; - - // Write X, P_C, M_C - let mut params = vec![]; - params.extend_from_slice(self.repres.as_bytes()); - params.extend_from_slice(&pad); - params.extend_from_slice(mark); - buf.put(params.as_slice()); - - // Calculate and write MAC - h.update(¶ms); - self.epoch_hour = format!("{}", get_epoch_hour()); - h.update(self.epoch_hour.as_bytes()); - let mac = &h.finalize_reset().into_bytes()[..MARK_LENGTH]; - buf.put(mac); - - trace!("mark: {}, mac: {}", hex::encode(mark), hex::encode(mac)); - - Ok(()) + let h = Hmac::::new_from_slice(key).unwrap(); + + self.marshall_inner(buf, h) + } + + pub fn marshall_inner(&mut self, _buf: &mut impl BufMut, _h: Hmac) -> Result<()> + where + D: CoreProxy, + D::Core: HashMarker + UpdateCore + FixedOutputCore + BufferKindUser + Default + Clone, + ::BlockSize: IsLess, + Le<::BlockSize, U256>: NonZero, + { + todo!("when this is causing panic re-visit"); + // NtorV3Extension::write_many_onto(client_aux_data.borrow(), &mut message) + // .map_err(|e| Error::from_bytes_enc(e, "ntor3 handshake extensions"))?; + + // h.reset(); // disambiguate reset() implementations Mac v digest + // h.update(self.repres.as_bytes().as_ref()); + // let mark: &[u8] = &h.finalize_reset().into_bytes()[..MARK_LENGTH]; + + // // The client handshake is X | P_C | M_C | MAC(X | P_C | M_C | E) where: + // // * X is the client's ephemeral Curve25519 public key representative. + // // * P_C is [clientMinPadLength,clientMaxPadLength] bytes of random padding. + // // * M_C is HMAC-SHA256-128(serverIdentity | NodeID, X) + // // * MAC is HMAC-SHA256-128(serverIdentity | NodeID, X .... E) + // // * E is the string representation of the number of hours since the UNIX + // // epoch. + + // // Generate the padding + // let pad = make_hs_pad(self.pad_len)?; + + // // Write X, P_C, M_C + // let mut params = vec![]; + // params.extend_from_slice(self.repres.as_bytes()); + // params.extend_from_slice(&pad); + // params.extend_from_slice(mark); + // buf.put(params.as_slice()); + + // // Calculate and write MAC + // h.update(¶ms); + // self.epoch_hour = format!("{}", get_epoch_hour()); + // h.update(self.epoch_hour.as_bytes()); + // let mac = &h.finalize_reset().into_bytes()[..MARK_LENGTH]; + // buf.put(mac); + + // trace!("mark: {}, mac: {}", hex::encode(mark), hex::encode(mac)); + + // Ok(()) } } diff --git a/crates/o5/src/framing/messages_v1/mod.rs b/crates/o5/src/framing/messages_v1/mod.rs index 729dd53..c28d73f 100644 --- a/crates/o5/src/framing/messages_v1/mod.rs +++ b/crates/o5/src/framing/messages_v1/mod.rs @@ -1,25 +1,4 @@ //! Version 1 of the Protocol Messagess to be included in constructed frames. -//! -//! ## Compatability concerns: -//! -//! Server - when operating as a server we may want to support clients using v0 -//! as well as clients using v1. In order to accomplish this the server can -//! look for the presence of the [`ClientParams`] message. If it is included as -//! a part of the clients handshake we can affirmatively assign protocol message -//! set v1 to the clients session. If we complete the handshake without -//! receiving a [`ClientParams`] messsage then we default to v0 (if the server -//! enables support). -//! -//! Client - When operating as a client we want to support the option to connect -//! with either v0 or v1 servers. when running as a v1 client the server will -//! ignore the unknown frames including [`ClientParams`] and [`CryptoOffer`]. -//! This means that the `SevrerHandshake` will not include [`ServerParams`] or -//! [`CryptoAccept`] frames which indicates to a v1 client that it is speaking -//! with a server unwilling or incapable of speaking v1. This should allow -//! cross compatibility. - -mod crypto; -use crypto::CryptoExtension; use crate::{ constants::*, @@ -37,10 +16,9 @@ pub enum MessageTypes { HeartbeatPing, HeartbeatPong, + HandshakeVersion, ClientParams, ServerParams, - CryptoOffer, - CryptoAccept, HandshakeEnd, } @@ -54,11 +32,11 @@ impl MessageTypes { const HEARTBEAT_PONG: u8 = 0x04; // Handshake messages - const CLIENT_PARAMS: u8 = 0x10; + const HANDSHAKE_VERSION: u8 = 0x10; + const CLIENT_PARAMS: u8 = 0x11; const SERVER_PARAMS: u8 = 0x11; - const CRYPTO_OFFER: u8 = 0x12; - const CRYPTO_ACCEPT: u8 = 0x13; //... + const HANDSHAKE_END: u8 = 0x1f; } @@ -70,10 +48,9 @@ impl From for u8 { MessageTypes::Padding => MessageTypes::PADDING, MessageTypes::HeartbeatPing => MessageTypes::HEARTBEAT_PING, MessageTypes::HeartbeatPong => MessageTypes::HEARTBEAT_PONG, + MessageTypes::HandshakeVersion => MessageTypes::HANDSHAKE_VERSION, MessageTypes::ClientParams => MessageTypes::CLIENT_PARAMS, MessageTypes::ServerParams => MessageTypes::SERVER_PARAMS, - MessageTypes::CryptoOffer => MessageTypes::CRYPTO_OFFER, - MessageTypes::CryptoAccept => MessageTypes::CRYPTO_ACCEPT, MessageTypes::HandshakeEnd => MessageTypes::HANDSHAKE_END, } } @@ -100,8 +77,7 @@ pub enum Messages { ClientParams, ServerParams, - CryptoOffer(CryptoExtension), - CryptoAccept(CryptoExtension), + HandshakeVersion, HandshakeEnd, } @@ -114,10 +90,9 @@ impl Messages { Messages::Padding(_) => MessageTypes::Padding, Messages::HeartbeatPing => MessageTypes::HeartbeatPing, Messages::HeartbeatPong => MessageTypes::HeartbeatPong, + Messages::HandshakeVersion => MessageTypes::HandshakeVersion, Messages::ClientParams => MessageTypes::ClientParams, Messages::ServerParams => MessageTypes::ServerParams, - Messages::CryptoOffer(_) => MessageTypes::CryptoOffer, - Messages::CryptoAccept(_) => MessageTypes::CryptoAccept, Messages::HandshakeEnd => MessageTypes::HandshakeEnd, } } @@ -177,14 +152,12 @@ impl Messages { MessageTypes::HeartbeatPong => Ok(Messages::HeartbeatPong), + MessageTypes::HandshakeVersion => Ok(Messages::HandshakeVersion), + MessageTypes::ClientParams => Ok(Messages::ClientParams), MessageTypes::ServerParams => Ok(Messages::ServerParams), - MessageTypes::CryptoOffer => Ok(Messages::CryptoOffer(CryptoExtension::Kyber)), - - MessageTypes::CryptoAccept => Ok(Messages::CryptoAccept(CryptoExtension::Kyber)), - MessageTypes::HandshakeEnd => Ok(Messages::HandshakeEnd), } } diff --git a/crates/o5/src/framing/mod.rs b/crates/o5/src/framing/mod.rs index 7cdccbc..047bade 100644 --- a/crates/o5/src/framing/mod.rs +++ b/crates/o5/src/framing/mod.rs @@ -13,7 +13,7 @@ /// /// ```txt /// length u16; // (obfsucated, big endian) -/// // NaCl secretbox (Poly1305/XSalsa20) containing: +/// // NaCl secretbox (Poly1305/XChaCha20) containing: /// tag [u8; 16]; // (Part of the secretbox construct) /// payload [u8]; /// ``` @@ -28,7 +28,7 @@ /// // obfs_len = length ^ mask[n] /// ``` /// -/// The NaCl secretbox (Poly1305/XSalsa20) nonce format is: +/// The NaCl secretbox (Poly1305/XChaCha20) nonce format is: /// /// ```txt /// prefix [u8; 24]; //(Fixed) diff --git a/crates/o5/src/handshake.rs b/crates/o5/src/handshake.rs new file mode 100644 index 0000000..09c2ee0 --- /dev/null +++ b/crates/o5/src/handshake.rs @@ -0,0 +1,489 @@ +//! Implements the ntor v3 key exchange, as described in proposal 332. +//! +//! The main difference between the ntor v3r handshake and the +//! original ntor handshake is that this this one allows each party to +//! encrypt data (without forward secrecy) after it sends the first +//! message. + +use crate::sessions::SessionPublicKey; + +use cipher::{KeyIvInit as _, StreamCipher as _}; +use digest::{Digest, ExtendableOutput, XofReader}; +use tor_bytes::{EncodeResult, Writeable, Writer}; +use tor_llcrypto::cipher::aes::Aes256Ctr; +use tor_llcrypto::d::{Sha3_256, Shake256}; +use zeroize::Zeroizing; + +mod keys; +use keys::NtorV3XofReader; +pub(crate) use keys::{Authcode, AUTHCODE_LENGTH}; +pub use keys::{IdentityPublicKey, IdentitySecretKey, NtorV3KeyGen}; + +/// Super trait to be used where we require a distinction between client and server roles. +trait Role { + fn is_client() -> bool; +} + +struct ClientRole {} +impl Role for ClientRole { + fn is_client() -> bool { + true + } +} + +struct ServerRole {} +impl Role for ServerRole { + fn is_client() -> bool { + false + } +} + +mod client; +pub(crate) use client::{HandshakeMaterials as CHSMaterials, NtorV3Client}; + +mod server; +pub(crate) use server::HandshakeMaterials as SHSMaterials; + +use crate::common::mlkem1024_x25519; + +/// The verification string to be used for circuit extension. +pub const NTOR3_CIRC_VERIFICATION: &[u8] = b"circuit extend"; + +/// The size of an encryption key in bytes. +pub const ENC_KEY_LEN: usize = 32; +/// The size of a MAC key in bytes. +pub const MAC_KEY_LEN: usize = 32; +/// The size of a digest output in bytes. +pub const DIGEST_LEN: usize = 32; +/// The length of a MAC output in bytes. +pub const MAC_LEN: usize = 32; +/// The length of a node identity in bytes. +pub const ID_LEN: usize = 32; + +/// The output of the digest, as an array. +type DigestVal = [u8; DIGEST_LEN]; +/// The output of the MAC. +type MessageMac = [u8; MAC_LEN]; +/// A key for symmetric encryption or decryption. +type EncKey = Zeroizing<[u8; ENC_KEY_LEN]>; +/// A key for message authentication codes. +type MacKey = [u8; MAC_KEY_LEN]; + +/// An encapsulated value for passing as input to a MAC, digest, or +/// KDF algorithm. +/// +/// This corresponds to the ENCAP() function in proposal 332. +struct Encap<'a>(&'a [u8]); + +impl<'a> Writeable for Encap<'a> { + fn write_onto(&self, b: &mut B) -> EncodeResult<()> { + b.write_u64(self.0.len() as u64); + b.write(self.0) + } +} + +impl<'a> Encap<'a> { + /// Return the length of the underlying data in bytes. + fn len(&self) -> usize { + self.0.len() + } + /// Return the underlying data + fn data(&self) -> &'a [u8] { + self.0 + } +} + +/// Helper to define a set of tweak values as instances of `Encap`. +macro_rules! define_tweaks { + { + $(#[$pid_meta:meta])* + PROTOID = $protoid:expr; + $( $(#[$meta:meta])* $name:ident <= $suffix:expr ; )* + } => { + $(#[$pid_meta])* + const PROTOID: &'static [u8] = $protoid.as_bytes(); + $( + $(#[$meta])* + const $name : Encap<'static> = + Encap(concat!($protoid, ":", $suffix).as_bytes()); + )* + } +} + +pub(crate) const T_KEY: &[u8; 36] = b"ntor-curve25519-sha256-1:key_extract"; + +define_tweaks! { + /// Protocol ID: concatenated with other things in the protocol to + /// prevent hash confusion. + PROTOID = "ntor3-curve25519-sha3_256-1"; + + /// Message MAC tweak: used to compute the MAC of an encrypted client + /// message. + // in obfs4 -> b"ntor-curve25519-sha256-1:mac" + T_MSGMAC <= "msg_mac"; + /// Message KDF tweak: used when deriving keys for encrypting and MACing + /// client message. + T_MSGKDF <= "kdf_phase1"; + /// Key seeding tweak: used to derive final KDF input from secret_input. + T_KEY_SEED <= "key_seed"; + /// Verifying tweak: used to derive 'verify' value from secret_input. + // in obfs4 -> b"ntor-curve25519-sha256-1:key_verify" + T_VERIFY <= "verify"; + /// Final KDF tweak: used to derive keys for encrypting relay message + /// and for the actual tor circuit. + T_FINAL <= "kdf_final"; + /// Authentication tweak: used to derive the final authentication + /// value for the handshake. + T_AUTH <= "auth_final"; + /// Key Expansion Tweak: obfs4 tweak used for expanding seed into key + M_EXPAND <= "key_expand"; +} + +/// Compute a tweaked hash. +fn hash(t: &Encap<'_>, data: &[u8]) -> DigestVal { + let mut d = Sha3_256::new(); + d.update((t.len() as u64).to_be_bytes()); + d.update(t.data()); + d.update(data); + d.finalize().into() +} + +/// Perform a symmetric encryption operation and return the encrypted data. +/// +/// (This isn't safe to do more than once with the same key, but we never +/// do that in this protocol.) +fn encrypt(key: &EncKey, m: &[u8]) -> Vec { + let mut d = m.to_vec(); + let zero_iv = Default::default(); + let k: &[u8; 32] = key; + let mut cipher = Aes256Ctr::new(k.into(), &zero_iv); + cipher.apply_keystream(&mut d); + d +} +/// Perform a symmetric decryption operation and return the encrypted data. +fn decrypt(key: &EncKey, m: &[u8]) -> Vec { + encrypt(key, m) +} + +/// Wrapper around a Digest or ExtendedOutput object that lets us use it +/// as a tor_bytes::Writer. +struct DigestWriter(U); +impl tor_bytes::Writer for DigestWriter { + fn write_all(&mut self, bytes: &[u8]) { + self.0.update(bytes); + } +} +impl DigestWriter { + /// Consume this wrapper and return the underlying object. + fn take(self) -> U { + self.0 + } +} + +/// Hash tweaked with T_KEY_SEED +fn h_key_seed(d: &[u8]) -> DigestVal { + hash(&T_KEY_SEED, d) +} +/// Hash tweaked with T_VERIFY +fn h_verify(d: &[u8]) -> DigestVal { + hash(&T_VERIFY, d) +} + +/// Helper: compute the encryption key and mac_key for the client's +/// encrypted message. +/// +/// Takes as inputs `xb` (the shared secret derived from +/// diffie-hellman as Bx or Xb), the relay's public key information, +/// the client's public key (B), and the shared verification string. +fn kdf_msgkdf( + xb: &mlkem1024_x25519::SharedSecret, + relay_public: &IdentityPublicKey, + client_public: &SessionPublicKey, + verification: &[u8], +) -> EncodeResult<(EncKey, DigestWriter)> { + // secret_input_phase1 = Bx | ID | X | B | PROTOID | ENCAP(VER) + // phase1_keys = KDF_msgkdf(secret_input_phase1) + // (ENC_K1, MAC_K1) = PARTITION(phase1_keys, ENC_KEY_LEN, MAC_KEY_LEN + let mut msg_kdf = DigestWriter(Shake256::default()); + msg_kdf.write(&T_MSGKDF)?; + msg_kdf.write(&xb.as_bytes())?; + msg_kdf.write(&relay_public.id)?; + msg_kdf.write(&client_public.as_bytes())?; + msg_kdf.write(&relay_public.pk.as_bytes())?; + msg_kdf.write(PROTOID)?; + msg_kdf.write(&Encap(verification))?; + let mut r = msg_kdf.take().finalize_xof(); + let mut enc_key = Zeroizing::new([0; ENC_KEY_LEN]); + let mut mac_key = Zeroizing::new([0; MAC_KEY_LEN]); + + r.read(&mut enc_key[..]); + r.read(&mut mac_key[..]); + let mut mac = DigestWriter(Sha3_256::default()); + { + mac.write(&T_MSGMAC)?; + mac.write(&Encap(&mac_key[..]))?; + mac.write(&relay_public.id)?; + mac.write(&relay_public.pk.as_bytes())?; + mac.write(&client_public.as_bytes())?; + } + + Ok((enc_key, mac)) +} + +/// Trait for an object that handle and incoming client message and +/// return a server's reply. +/// +/// This is implemented for `FnMut(&[u8]) -> Option>` automatically. +pub(crate) trait MsgReply { + /// Given a message received from a client, parse it and decide + /// how (and whether) to reply. + /// + /// Return None if the handshake should fail. + fn reply(&mut self, msg: &[u8]) -> Option>; +} + +impl MsgReply for F +where + F: FnMut(&[u8]) -> Option>, +{ + fn reply(&mut self, msg: &[u8]) -> Option> { + self(msg) + } +} + +#[cfg(test)] +#[allow(non_snake_case)] // to enable variable names matching the spec. +#[allow(clippy::many_single_char_names)] // ibid +mod test { + // @@ begin test lint list maintained by maint/add_warning @@ + #![allow(clippy::bool_assert_comparison)] + #![allow(clippy::clone_on_copy)] + #![allow(clippy::dbg_macro)] + #![allow(clippy::mixed_attributes_style)] + #![allow(clippy::print_stderr)] + #![allow(clippy::print_stdout)] + #![allow(clippy::single_char_pattern)] + #![allow(clippy::unwrap_used)] + #![allow(clippy::unchecked_duration_subtraction)] + #![allow(clippy::useless_vec)] + #![allow(clippy::needless_pass_by_value)] + //! + use crate::common::mlkem1024_x25519::{PublicKey, StaticSecret}; + use crate::common::ntor_arti::{ClientHandshake, KeyGenerator, ServerHandshake}; + use crate::constants::{NODE_ID_LENGTH, SEED_LENGTH}; + use crate::Server; + + use super::*; + use crate::{handshake::IdentitySecretKey, sessions::SessionSecretKey}; + + use hex::FromHex; + use hex_literal::hex; + use rand::thread_rng; + use tor_basic_utils::test_rng::testing_rng; + use tor_cell::relaycell::extend::NtorV3Extension; + + #[test] + fn test_ntor3_roundtrip() { + let mut rng = rand::thread_rng(); + let relay_private = IdentitySecretKey::random_from_rng(&mut testing_rng()); + + let verification = &b"shared secret"[..]; + let client_message = &b"Hello. I am a client. Let's be friends!"[..]; + let relay_message = &b"Greetings, client. I am a robot. Beep boop."[..]; + let materials = CHSMaterials::new(&relay_private.pk, "fake_session_id-1".into()); + + let (c_state, c_handshake) = + client::client_handshake_ntor_v3(&mut rng, materials, verification).unwrap(); + + struct Rep(Vec, Vec); + impl MsgReply for Rep { + fn reply(&mut self, msg: &[u8]) -> Option> { + self.0 = msg.to_vec(); + Some(self.1.clone()) + } + } + let mut rep = Rep(Vec::new(), relay_message.to_vec()); + + let (s_handshake, mut s_keygen) = server::server_handshake_ntor_v3( + &mut rng, + &mut rep, + &c_handshake, + &[relay_private], + verification, + ) + .unwrap(); + + let (s_msg, mut c_keygen) = + client::client_handshake_ntor_v3_part2(&c_state, &s_handshake, verification).unwrap(); + + assert_eq!(rep.0[..], client_message[..]); + assert_eq!(s_msg[..], relay_message[..]); + let mut s_keys = [0_u8; 100]; + let mut c_keys = [0_u8; 1000]; + s_keygen.read(&mut s_keys); + c_keygen.read(&mut c_keys); + assert_eq!(s_keys[..], c_keys[..100]); + } + + // Same as previous test, but use the higher-level APIs instead. + #[test] + fn test_ntor3_roundtrip_highlevel() { + let relay_private = IdentitySecretKey::random_from_rng(&mut testing_rng()); + + let materials = CHSMaterials::new(&relay_private.pk, "fake_session_id-1".into()); + let (c_state, c_handshake) = NtorV3Client::client1(materials).unwrap(); + + let mut rep = |_: &[NtorV3Extension]| Some(vec![]); + + let server = Server::new_from_random(&mut thread_rng()); + let shs_materials = SHSMaterials { + len_seed: [0u8; SEED_LENGTH], + session_id: "roundtrip_test_serverside".into(), + }; + let (s_keygen, s_handshake) = server + .server(&mut rep, &shs_materials, &c_handshake) + .unwrap(); + + let (extensions, keygen) = NtorV3Client::client2(c_state, s_handshake).unwrap(); + + assert!(extensions.is_empty()); + let c_keys = keygen.expand(1000).unwrap(); + let s_keys = s_keygen.expand(100).unwrap(); + assert_eq!(s_keys[..], c_keys[..100]); + } + + // Same as previous test, but encode some congestion control extensions. + #[test] + fn test_ntor3_roundtrip_highlevel_cc() { + let relay_private = IdentitySecretKey::random_from_rng(&mut testing_rng()); + + let client_exts = vec![NtorV3Extension::RequestCongestionControl]; + let reply_exts = vec![NtorV3Extension::AckCongestionControl { sendme_inc: 42 }]; + let materials = CHSMaterials::new(&relay_private.pk, "client_session_1".into()) + .with_aux_data([NtorV3Extension::RequestCongestionControl]); + + let (c_state, c_handshake) = NtorV3Client::client1(materials).unwrap(); + + let mut rep = |msg: &[NtorV3Extension]| -> Option> { + assert_eq!(msg, client_exts); + Some(reply_exts.clone()) + }; + + let shs_materials = SHSMaterials { + len_seed: [0u8; SEED_LENGTH], + session_id: "roundtrip_test_serverside".into(), + }; + let server = Server::new_from_random(&mut thread_rng()); + let (s_keygen, s_handshake) = server + .server(&mut rep, &shs_materials, &c_handshake) + .unwrap(); + + let (extensions, keygen) = NtorV3Client::client2(c_state, s_handshake).unwrap(); + + assert_eq!(extensions, reply_exts); + let c_keys = keygen.expand(1000).unwrap(); + let s_keys = s_keygen.expand(100).unwrap(); + assert_eq!(s_keys[..], c_keys[..100]); + } + + #[test] + fn test_ntor3_testvec() { + let mut rng = rand::thread_rng(); + let b = hex!("4051daa5921cfa2a1c27b08451324919538e79e788a81b38cbed097a5dff454a"); + let id = <[u8; NODE_ID_LENGTH]>::from_hex( + "aaaaaaaaaaaaaaaaaaaaaaaa9fad2af287ef942632833d21f946c6260c33fae6", + ) + .unwrap(); + let x = hex!("b825a3719147bcbe5fb1d0b0fcb9c09e51948048e2e3283d2ab7b45b5ef38b49"); + let y = hex!("4865a5b7689dafd978f529291c7171bc159be076b92186405d13220b80e2a053"); + let b: StaticSecret = b.into(); + let B: PublicKey = (&b).into(); + let x: SessionSecretKey = x.into(); + //let X = (&x).into(); + let y: StaticSecret = y.into(); + + let client_message = hex!("68656c6c6f20776f726c64"); + let verification = hex!("78797a7a79"); + let server_message = hex!("486f6c61204d756e646f"); + + let relay_private = IdentitySecretKey::new(b, id.into()); + let relay_public = relay_private.pk; // { pk: B, id }; + + let mut chs_materials = CHSMaterials::new(&relay_public, "".into()); + let (state, client_handshake) = + client::client_handshake_ntor_v3_no_keygen(x, chs_materials, &verification).unwrap(); + + assert_eq!(client_handshake[..], hex!("9fad2af287ef942632833d21f946c6260c33fae6172b60006e86e4a6911753a2f8307a2bc1870b00b828bb74dbb8fd88e632a6375ab3bcd1ae706aaa8b6cdd1d252fe9ae91264c91d4ecb8501f79d0387e34ad8ca0f7c995184f7d11d5da4f463bebd9151fd3b47c180abc9e044d53565f04d82bbb3bebed3d06cea65db8be9c72b68cd461942088502f67")[..]); + + struct Replier(Vec, Vec, bool); + impl MsgReply for Replier { + fn reply(&mut self, msg: &[u8]) -> Option> { + assert_eq!(msg, &self.0); + self.2 = true; + Some(self.1.clone()) + } + } + let mut rep = Replier(client_message.to_vec(), server_message.to_vec(), false); + + let (server_handshake, mut server_keygen) = server::server_handshake_ntor_v3_no_keygen( + &mut rng, + &mut rep, + &y, + &client_handshake, + &relay_private, + &verification, + ) + .unwrap(); + assert!(rep.2); + + assert_eq!(server_handshake[..], hex!("4bf4814326fdab45ad5184f5518bd7fae25dc59374062698201a50a22954246d2fc5f8773ca824542bc6cf6f57c7c29bbf4e5476461ab130c5b18ab0a91276651202c3e1e87c0d32054c")[..]); + + let (server_msg_received, mut client_keygen) = + client::client_handshake_ntor_v3_part2(&state, &server_handshake, &verification) + .unwrap(); + assert_eq!(&server_msg_received, &server_message); + + let (c_keys, s_keys) = { + let mut c = [0_u8; 256]; + let mut s = [0_u8; 256]; + client_keygen.read(&mut c); + server_keygen.read(&mut s); + (c, s) + }; + assert_eq!(c_keys, s_keys); + assert_eq!(c_keys[..], hex!("9c19b631fd94ed86a817e01f6c80b0743a43f5faebd39cfaa8b00fa8bcc65c3bfeaa403d91acbd68a821bf6ee8504602b094a254392a07737d5662768c7a9fb1b2814bb34780eaee6e867c773e28c212ead563e98a1cd5d5b4576f5ee61c59bde025ff2851bb19b721421694f263818e3531e43a9e4e3e2c661e2ad547d8984caa28ebecd3e4525452299be26b9185a20a90ce1eac20a91f2832d731b54502b09749b5a2a2949292f8cfcbeffb790c7790ed935a9d251e7e336148ea83b063a5618fcff674a44581585fd22077ca0e52c59a24347a38d1a1ceebddbf238541f226b8f88d0fb9c07a1bcd2ea764bbbb5dacdaf5312a14c0b9e4f06309b0333b4a")[..]); + } + + #[test] + fn mlkem1024_x25519_3way_handshake_flow() { + let mut rng = rand::thread_rng(); + // long-term server id and keys + let server_id_keys = StaticSecret::random_from_rng(&mut rng); + let _server_id_pub = PublicKey::from(&server_id_keys); + // let server_id = ID::new(); + + // client open session, generating the associated ephemeral keys + let client_session = StaticSecret::random_from_rng(&mut rng); + + // client sends mlkem1024_x25519 session pubkey(s) + let _cpk = PublicKey::from(&client_session); + + // server computes mlkem1024_x25519 combined shared secret + let _server_session = StaticSecret::random_from_rng(&mut rng); + // let server_hs_res = server_handshake(&server_session, &cpk, &server_id_keys, &server_id); + + // server sends mlkemx25519 session pubkey(s) + let _spk = PublicKey::from(&client_session); + + // // client computes mlkem1024_x25519 combined shared secret + // let client_hs_res = client_handshake(&client_session, &spk, &server_id_pub, &server_id); + + // assert_ne!(client_hs_res.is_some().unwrap_u8(), 0); + // assert_ne!(server_hs_res.is_some().unwrap_u8(), 0); + + // let chsres = client_hs_res.unwrap(); + // let shsres = server_hs_res.unwrap(); + // assert_eq!(chsres.key_seed, shsres.key_seed); + // assert_eq!(&chsres.auth, &shsres.auth); + } +} diff --git a/crates/o5/src/handshake/README.md b/crates/o5/src/handshake/README.md index 7dda9c2..8fc23cf 100644 --- a/crates/o5/src/handshake/README.md +++ b/crates/o5/src/handshake/README.md @@ -1,129 +1,9 @@ -# Obfs4 Ntor Handshake +# PQ Obfs Handshake -While exchanging messages during the handshake the client and -server use (a modified version of) the Ntor handshake to -compute a shared seed as well as an authentication value. -The original implementation of the Obfs4 Ntor Handshake has some -small variation from the actual Ntor V1 handshake and as such -requires an alternative implementation to be compatible with -the existing [golang implementation](https://gitlab.com/yawning/obfs4) +## Differences from Ntorv3 -## Difference from Ntor V1 -* message value used for key seed is different: obfs4 uses a different order and -accidentally writes the server's identity public key bytes twice. - - Ntor V1 - uses `message = (secret_input) | ID | b | x | y | PROTOID` - - Obfs4 - uses `message = (secret_input) | b | b | x | y | PROTOID | ID` - -* seed for key generator - * Ntor V1 - uses raw bytes from `message` - * Obfs4 - uses `HMAC_SHA256(message, T_KEY)` where `T_KEY = "ntor-curve25519-sha256-1:key_extract"` - -* The constant string for `T_VERIFY` - * Ntor V1 - `T_VERIFY = b"ntor-curve25519-sha256-1:verify";` - * Obfs4 - `T_VERIFY = b"ntor-curve25519-sha256-1:key_verify";` - -* message value used for auth is different -- these hash over the same fields, -but result in different hash values. Obfs4 reuses part of the `message` value -so the duplicated server identity public key is included. - * Ntor V1 - uses input `verify | ID | b | y | x | PROTOID | "Server"` - * Obfs4 - uses input `verify | b | b | y | x | PROTOID | ID | "Server"` - -The rust implementation of the Obfs4 Ntor derivation with diff markup. - -```diff - -pub(crate) const PROTO_ID: &[u8; 24] = b"ntor-curve25519-sha256-1"; -pub(crate) const T_MAC: &[u8; 28] = b"ntor-curve25519-sha256-1:mac"; --pub(crate) const T_VERIFY: &[u8; 31] = b"ntor-curve25519-sha256-1:verify"; -+pub(crate) const T_VERIFY: &[u8; 35] = b"ntor-curve25519-sha256-1:key_verify"; -pub(crate) const T_KEY: &[u8; 36] = b"ntor-curve25519-sha256-1:key_extract"; -pub(crate) const T_EXPAND: &[u8; 35] = b"ntor-curve25519-sha256-1:key_expand"; - - -/// helper: compute a key generator and an authentication code from a set -/// of ntor parameters. -/// -/// These parameter names are as described in tor-spec.txt -fn ntor_derive( - xy: &SharedSecret, - xb: &SharedSecret, - server_pk: &O5NtorPublicKey, - x: &PublicKey, - y: &PublicKey, -) -> EncodeResult<(NtorHkdfKeyGenerator, Authcode)> { - let server_string = &b"Server"[..]; - - // shared_secret_input = EXP(X,y) | EXP(X,b) OR = EXP(Y,x) | EXP(B,x) -- // message = (shared_secret_input) | ID | X | Y | PROTOID -- let mut message = SecretBuf::new(); -- message.write(xy.as_bytes())?; // EXP(X,y) -- message.write(xb.as_bytes())?; // EXP(X,b) -- message.write(&server_pk.id)?; // ID -- message.write(&server_pk.pk.as_bytes())?; // b -- message.write(x.as_bytes())?; // x -- message.write(y.as_bytes())?; // y -- message.write(PROTO_ID)?; // PROTOID -+ // obfs4 uses a different order than Ntor V1 and accidentally writes the -+ // server's identity public key bytes twice. -+ let mut suffix = SecretBuf::new(); -+ suffix.write(&server_pk.pk.as_bytes())?; // b -+ suffix.write(&server_pk.pk.as_bytes())?; // b -+ suffix.write(x.as_bytes())?; // x -+ suffix.write(y.as_bytes())?; // y -+ suffix.write(PROTO_ID)?; // PROTOID -+ suffix.write(&server_pk.id)?; // ID -+ -+ // message = (secret_input) | b | b | x | y | PROTOID | ID -+ let mut message = SecretBuf::new(); -+ message.write(xy.as_bytes())?; // EXP(X,y) -+ message.write(xb.as_bytes())?; // EXP(X,b) -+ message.write(&suffix[..])?; // b | b | x | y | PROTOID | ID - - // verify = HMAC_SHA256(message, T_VERIFY) - let verify = { - let mut m = - Hmac::::new_from_slice(T_VERIFY).expect("Hmac allows keys of any size"); - m.update(&message[..]); - m.finalize() - }; - -- // auth_input = verify | ID | b | y | x | PROTOID | "Server" -+ // auth_input = verify | (suffix) | "Server" -+ // auth_input = verify | b | b | y | x | PROTOID | ID | "Server" - let mut auth_input = Vec::new(); - auth_input.write_and_consume(verify)?; // verify -- auth_input.write(&server_pk.id)?; // ID -- auth_input.write(&server_pk.pk.as_bytes())?; // B -- auth_input.write(y.as_bytes())?; // Y -- auth_input.write(x.as_bytes())?; // X -- auth_input.write(PROTO_ID)?; // PROTOID -+ auth_input.write(&suffix[..])?; // b | b | x | y | PROTOID | ID - auth_input.write(server_string)?; // "Server" - - // auth = HMAC_SHA256(auth_input, T_MAC) - let auth_mac = { - let mut m = - Hmac::::new_from_slice(T_MAC).expect("Hmac allows keys of any size"); - m.update(&auth_input[..]); - m.finalize() - }; - -+ let key_seed_bytes = { -+ let mut m = -+ Hmac::::new_from_slice(T_KEY).expect("Hmac allows keys of any size"); -+ m.update(&message[..]); -+ m.finalize() -+ }; -+ let mut key_seed = SecretBuf::new(); -+ key_seed.write_and_consume(key_seed_bytes)?; -+ -+ let keygen = NtorHkdfKeyGenerator::new(key_seed); -- let keygen = NtorHkdfKeyGenerator::new(message); - Ok((keygen, auth_mac)) -} - -``` +## Differences from Obfs4 diff --git a/crates/o5/src/handshake/client.rs b/crates/o5/src/handshake/client.rs new file mode 100644 index 0000000..4d6673a --- /dev/null +++ b/crates/o5/src/handshake/client.rs @@ -0,0 +1,292 @@ +use crate::{ + common::{ + ct, + mlkem1024_x25519::SharedSecret, + ntor_arti::{ClientHandshake, ClientHandshakeMaterials}, + }, + constants::*, + framing::handshake::ClientHandshakeMessage, + handshake::*, + sessions::{SessionPublicKey, SessionSecretKey}, + Error, Result, +}; + +use bytes::BytesMut; +use hmac::Hmac; +use keys::NtorV3KeyGenerator; +// use cipher::KeyIvInit; +use rand::{CryptoRng, Rng, RngCore}; +use subtle::ConstantTimeEq; +use tor_bytes::{EncodeResult, Reader, SecretBuf, Writer}; +use tor_cell::relaycell::extend::NtorV3Extension; +use tor_error::into_internal; +use tor_llcrypto::{ + d::{Sha3_256, Shake256}, + pk::ed25519::Ed25519Identity, +}; +use zeroize::Zeroizing; + + +/// Client state for the o5 (ntor v3) handshake. +/// +/// The client needs to hold this state between when it sends its part +/// of the handshake and when it receives the relay's reply. +pub(crate) struct HandshakeState { + /// The temporary curve25519 secret (x) that we've generated for + /// this handshake. + // We'd like to EphemeralSecret here, but we can't since we need + // to use it twice. + my_sk: SessionSecretKey, + + /// handshake materials + materials: HandshakeMaterials, + + /// the computed hour at which the initial portion of the handshake was sent. + epoch_hr: String, + + /// The shared secret generated as Bx or Xb. + shared_secret: SharedSecret, // Bx + + /// The MAC of our original encrypted message. + msg_mac: MessageMac, // msg_mac +} + +impl HandshakeState { + fn node_pubkey(&self) -> &mlkem1024_x25519::PublicKey { + &self.materials.node_pubkey.pk + } + + fn node_id(&self) -> Ed25519Identity { + self.materials.node_pubkey.id + } +} + +/// Materials required to initiate a handshake from the client role. +#[derive(Debug, Clone, PartialEq)] +pub(crate) struct HandshakeMaterials { + pub(crate) node_pubkey: IdentityPublicKey, + pub(crate) pad_len: usize, + pub(crate) session_id: String, + aux_data: Vec, +} + +impl HandshakeMaterials { + pub(crate) fn new(node_pubkey: &IdentityPublicKey, session_id: String) -> Self { + HandshakeMaterials { + node_pubkey: node_pubkey.clone(), + session_id, + pad_len: rand::thread_rng().gen_range(CLIENT_MIN_PAD_LENGTH..CLIENT_MAX_PAD_LENGTH), + aux_data: vec![], + } + } + + pub fn with_aux_data(mut self, data: impl AsRef<[NtorV3Extension]>) -> Self { + self.aux_data = data.as_ref().to_vec(); + self + } +} + +impl ClientHandshakeMaterials for HandshakeMaterials { + type IdentityKeyType = IdentityPublicKey; + type ClientAuxData = Vec; + + fn node_pubkey(&self) -> &Self::IdentityKeyType { + &self.node_pubkey + } + + fn aux_data(&self) -> Option<&Self::ClientAuxData> { + Some(&self.aux_data) + } +} + +/// Client side of the ntor v3 handshake. +pub(crate) struct NtorV3Client; + +impl ClientHandshake for NtorV3Client { + type StateType = HandshakeState; + type KeyGen = NtorV3KeyGenerator; + type ServerAuxData = Vec; + type HandshakeMaterials = HandshakeMaterials; + + /// Generate a new client onionskin for a relay with a given onion key. + /// If any `extensions` are provided, encode them into to the onionskin. + /// + /// On success, return a state object that will be used to complete the handshake, along + /// with the message to send. + fn client1(hs_materials: Self::HandshakeMaterials) -> Result<(Self::StateType, Vec)> { + let mut rng = rand::thread_rng(); + + Ok( + client_handshake_ntor_v3(&mut rng, hs_materials, NTOR3_CIRC_VERIFICATION) + .map_err(into_internal!("Can't encode ntor3 client handshake."))?, + ) + } + + /// Handle an onionskin from a relay, and produce a key generator. + /// + /// The state object must match the one that was used to make the + /// client onionskin that the server is replying to. + fn client2>( + state: Self::StateType, + msg: T, + ) -> Result<(Vec, Self::KeyGen)> { + let (message, xofreader) = + client_handshake_ntor_v3_part2(&state, msg.as_ref(), NTOR3_CIRC_VERIFICATION)?; + let extensions = NtorV3Extension::decode(&message).map_err(|err| Error::CellDecodeErr { + object: "ntor v3 extensions", + err, + })?; + let keygen = NtorV3KeyGenerator::new::(xofreader); + + Ok((extensions, keygen)) + } +} + +/// Client-side Ntor version 3 handshake, part one. +/// +/// Given a secure `rng`, a relay's public key, a secret message to send, +/// and a shared verification string, generate a new handshake state +/// and a message to send to the relay. +pub(crate) fn client_handshake_ntor_v3( + rng: &mut R, + materials: HandshakeMaterials, + verification: &[u8], +) -> EncodeResult<(HandshakeState, Vec)> { + let my_sk = SessionSecretKey::random_from_rng(rng); + client_handshake_ntor_v3_no_keygen(my_sk, materials, verification) +} + +/// As `client_handshake_ntor_v3`, but don't generate an ephemeral DH +/// key: instead take that key an arguments `my_sk`. +pub(crate) fn client_handshake_ntor_v3_no_keygen( + my_sk: SessionSecretKey, + materials: HandshakeMaterials, + verification: &[u8], +) -> EncodeResult<(HandshakeState, Vec)> { + let my_public = SessionPublicKey::from(&my_sk); + let client_msg = ClientHandshakeMessage::new(my_public.clone(), &materials); + + // -------- + let node_pubkey = materials.node_pubkey(); + // let bx = my_sk.diffie_hellman(&node_pubkey); + let mut rng = rand::thread_rng(); + let (ct, bx) = my_sk.hpke(&mut rng, materials.node_pubkey.pk)?; + // .map_err(|e| Error::Crypto(e.to_string())); + + let (enc_key, mut mac) = kdf_msgkdf(&bx, node_pubkey, &my_public, verification)?; + + // encrypted_msg = ENC(ENC_K1, CM) + // msg_mac = MAC_msgmac(MAC_K1, ID | B | X | encrypted_msg) + let encrypted_msg = encrypt(&enc_key, client_msg); + let msg_mac: DigestVal = { + use digest::Digest; + mac.write(&encrypted_msg)?; + mac.take().finalize().into() + }; + + let mut message = Vec::new(); + message.write(&node_pubkey.id)?; + message.write(&node_pubkey.pk.as_bytes())?; + message.write(&my_public.as_bytes())?; + message.write(&encrypted_msg)?; + message.write(&msg_mac)?; + // -------- + + let mut buf = BytesMut::with_capacity(MAX_HANDSHAKE_LENGTH); + let mut hmac_key = materials.node_pubkey.pk.as_bytes().to_vec(); + hmac_key.append(&mut materials.node_pubkey.id.as_bytes().to_vec()); + client_msg.marshall(&mut buf, &hmac_key[..]); + let message = buf.to_vec(); + + let state = HandshakeState { + materials, + my_sk, + shared_secret: bx, + msg_mac, + epoch_hr: client_msg.get_epoch_hr(), + }; + + Ok((state, message)) +} + +/// Finalize the handshake on the client side. +/// +/// Called after we've received a message from the relay: try to +/// complete the handshake and verify its correctness. +/// +/// On success, return the server's reply to our original encrypted message, +/// and an `XofReader` to use in generating circuit keys. +pub(crate) fn client_handshake_ntor_v3_part2( + state: &HandshakeState, + relay_handshake: &[u8], + verification: &[u8], +) -> Result<(Vec, NtorV3XofReader)> { + let mut reader = Reader::from_slice(relay_handshake); + let y_pk: SessionPublicKey = reader + .extract() + .map_err(|e| Error::from_bytes_err(e, "v3 ntor handshake"))?; + let auth: DigestVal = reader + .extract() + .map_err(|e| Error::from_bytes_err(e, "v3 ntor handshake"))?; + let encrypted_msg = reader.into_rest(); + let my_public = SessionPublicKey::from(&state.my_sk); + + // TODO: Some of this code is duplicated from the server handshake code! It + // would be better to factor it out. + let yx = state.my_sk.diffie_hellman(&y_pk); + let secret_input = { + let mut si = SecretBuf::new(); + si.write(&yx) + .and_then(|_| si.write(&state.shared_secret.as_bytes())) + .and_then(|_| si.write(&state.node_id())) + .and_then(|_| si.write(&state.node_pubkey().as_bytes())) + .and_then(|_| si.write(&my_public.as_bytes())) + .and_then(|_| si.write(&y_pk.as_bytes())) + .and_then(|_| si.write(PROTOID)) + .and_then(|_| si.write(&Encap(verification))) + .map_err(into_internal!("error encoding ntor3 secret_input"))?; + si + }; + let ntor_key_seed = h_key_seed(&secret_input); + let verify = h_verify(&secret_input); + + let computed_auth: DigestVal = { + use digest::Digest; + let mut auth = DigestWriter(Sha3_256::default()); + auth.write(&T_AUTH) + .and_then(|_| auth.write(&verify)) + .and_then(|_| auth.write(&state.node_id())) + .and_then(|_| auth.write(&state.node_pubkey().as_bytes())) + .and_then(|_| auth.write(&y_pk.as_bytes())) + .and_then(|_| auth.write(&my_public.as_bytes())) + .and_then(|_| auth.write(&state.msg_mac)) + .and_then(|_| auth.write(&Encap(encrypted_msg))) + .and_then(|_| auth.write(PROTOID)) + .and_then(|_| auth.write(&b"Server"[..])) + .map_err(into_internal!("error encoding ntor3 authentication input"))?; + auth.take().finalize().into() + }; + + let okay = computed_auth.ct_eq(&auth) + & ct::bool_to_choice(yx.was_contributory()) + & ct::bool_to_choice(state.shared_secret.was_contributory()); + + let (enc_key, keystream) = { + use digest::{ExtendableOutput, XofReader}; + let mut xof = DigestWriter(Shake256::default()); + xof.write(&T_FINAL) + .and_then(|_| xof.write(&ntor_key_seed)) + .map_err(into_internal!("error encoding ntor3 xof input"))?; + let mut r = xof.take().finalize_xof(); + let mut enc_key = Zeroizing::new([0_u8; ENC_KEY_LEN]); + r.read(&mut enc_key[..]); + (enc_key, r) + }; + let server_reply = decrypt(&enc_key, encrypted_msg); + + if okay.into() { + Ok((server_reply, NtorV3XofReader::new(keystream))) + } else { + Err(Error::BadCircHandshakeAuth) + } +} diff --git a/crates/o5/src/handshake/handshake_client.rs b/crates/o5/src/handshake/handshake_client.rs deleted file mode 100644 index 316bef6..0000000 --- a/crates/o5/src/handshake/handshake_client.rs +++ /dev/null @@ -1,335 +0,0 @@ -use super::*; -use crate::{ - common::{ - curve25519::{PublicKey, PublicRepresentative, REPRESENTATIVE_LENGTH}, - HmacSha256, - }, - framing::handshake::{ClientHandshakeMessage, ServerHandshakeMessage}, -}; - -use ptrs::trace; -use rand::Rng; - -/// materials required to initiate a handshake from the client role. -#[derive(Debug, Clone, PartialEq)] -pub(crate) struct HandshakeMaterials { - pub(crate) node_pubkey: O5NtorPublicKey, - pub(crate) pad_len: usize, - pub(crate) session_id: String, -} - -impl HandshakeMaterials { - pub(crate) fn new(node_pubkey: O5NtorPublicKey, session_id: String) -> Self { - HandshakeMaterials { - node_pubkey, - session_id, - pad_len: rand::thread_rng().gen_range(CLIENT_MIN_PAD_LENGTH..CLIENT_MAX_PAD_LENGTH), - } - } -} - - -/// Client state for the o5 (ntor v3) handshake. -/// -/// The client needs to hold this state between when it sends its part -/// of the handshake and when it receives the relay's reply. -#[derive(Clone)] -pub(crate) struct O5NtorHandshakeState { - /// The temporary curve25519 secret (x) that we've generated for - /// this handshake. - // We'd like to EphemeralSecret here, but we can't since we need - // to use it twice. - my_sk: curve25519::StaticSecret, - - /// handshake materials - materials: HandshakeMaterials, - - /// the computed hour at which the initial portion of the handshake was sent. - epoch_hr: String, - - /// The shared secret generated as Bx or Xb. - shared_secret: curve25519::SharedSecret, // Bx - - /// The MAC of our original encrypted message. - msg_mac: MacVal, // msg_mac -} - -/// Client-side Ntor version 3 handshake, part one. -/// -/// Given a secure `rng`, a relay's public key, a secret message to send, -/// and a shared verification string, generate a new handshake state -/// and a message to send to the relay. -pub(super) fn client_handshake_o5( - materials: &HandshakeMaterials, -) -> Result<(O5NtorHandshakeState, Vec)> { - let rng = rand::thread_rng(); - let my_sk = Representable::static_from_rng(rng); - client_handshake_o5_no_keygen(my_sk, materials.clone()) -} -// fn client_handshake_o5( -// relay_public: &NtorV3PublicKey, -// client_msg: &[u8], -// verification: &[u8], -// ) -> EncodeResult<(NtorV3HandshakeState, Vec)> { -// let mut rng = rand::thread_rng(); -// let my_sk = curve25519::StaticSecret::random_from_rng(rng); -// client_handshake_ntor_v3_no_keygen(relay_public, client_msg, verification, my_sk) -// } - -/// As `client_handshake_ntor_v3`, but don't generate an ephemeral DH -/// key: instead take that key an arguments `my_sk`. -// fn client_handshake_ntor_o5_keygen( -// relay_public: &NtorV3PublicKey, -// client_msg: &[u8], -// verification: &[u8], -// my_sk: curve25519::StaticSecret, -// ) -> EncodeResult<(NtorV3HandshakeState, Vec)> { -pub(super) fn client_handshake_o5_no_keygen( - my_sk: curve25519::StaticSecret, - materials: HandshakeMaterials, -) -> Result<(O5NtorHandshakeState, Vec)> { - let my_public = curve25519::PublicKey::from(&my_sk); - let bx = my_sk.diffie_hellman(&materials.node_pubkey.pk); - - let (enc_key, mut mac) = kdf_msgkdf(&bx, materials.node_pubkey, &my_public, verification)?; - - //encrypted_msg = ENC(ENC_K1, CM) - // msg_mac = MAC_msgmac(MAC_K1, ID | B | X | encrypted_msg) - let encrypted_msg = encrypt(&enc_key, client_msg); - let msg_mac: DigestVal = { - use digest::Digest; - mac.write(&encrypted_msg)?; - mac.take().finalize().into() - }; - - let mut message = Vec::new(); - message.write(&relay_public.id)?; - message.write(&relay_public.pk)?; - message.write(&my_public)?; - message.write(&encrypted_msg)?; - message.write(&msg_mac)?; - - let state = O5NtorHandshakeState { - relay_public: relay_public.clone(), - my_sk, - my_public, - shared_secret: bx, - msg_mac, - }; - - Ok((state, message)) -} - -/// Helper: client handshake _without_ generating new keys. -pub(crate) fn client_handshake_obfs4_no_keygen( - ephem: StaticSecret, - materials: HandshakeMaterials, -) -> Result<(O5NtorHandshakeState, Vec)> { - let repres: Option = (&ephem).into(); - - // build client handshake message - let mut ch_msg = ClientHandshakeMessage::new( - repres.unwrap(), - materials.pad_len, - materials.session_id.clone(), - ); - - let mut buf = BytesMut::with_capacity(MAX_HANDSHAKE_LENGTH); - let mut key = materials.node_pubkey.pk.as_bytes().to_vec(); - key.append(&mut materials.node_pubkey.id.as_bytes().to_vec()); - let h = HmacSha256::new_from_slice(&key[..]).unwrap(); - ch_msg.marshall(&mut buf, h)?; - - let state = O5NtorHandshakeState { - my_sk: ephem, - materials, - epoch_hr: ch_msg.epoch_hour, - }; - - Ok((state, buf.to_vec())) -} - -/// Complete a client handshake, returning a key generator on success. -/// -/// Called after we've received a message from the relay: try to -/// complete the handshake and verify its correctness. -/// -/// On success, return the server's reply to our original encrypted message, -/// and an `XofReader` to use in generating circuit keys. -// fn client_handshake_ntor_v3_part2( -// state: &NtorV3HandshakeState, -// relay_handshake: &[u8], -// verification: &[u8], -// ) -> Result<(Vec, NtorV3XofReader)> { -pub(super) fn client_handshake_o5_part2( - msg: T, - state: &O5NtorHandshakeState, -) -> Result<(O5NtorKeyGenerator, Vec)> -where - T: AsRef<[u8]>, -{ - let mut reader = Reader::from_slice(relay_handshake); - let y_pk: curve25519::PublicKey = reader - .extract() - .map_err(|e| Error::from_bytes_err(e, "v3 ntor handshake"))?; - let auth: DigestVal = reader - .extract() - .map_err(|e| Error::from_bytes_err(e, "v3 ntor handshake"))?; - let encrypted_msg = reader.into_rest(); - - // TODO: Some of this code is duplicated from the server handshake code! It - // would be better to factor it out. - let yx = state.my_sk.diffie_hellman(&y_pk); - let secret_input = { - let mut si = SecretBuf::new(); - si.write(&yx) - .and_then(|_| si.write(&state.shared_secret)) - .and_then(|_| si.write(&state.relay_public.id)) - .and_then(|_| si.write(&state.relay_public.pk)) - .and_then(|_| si.write(&state.my_public)) - .and_then(|_| si.write(&y_pk)) - .and_then(|_| si.write(PROTOID)) - .and_then(|_| si.write(&Encap(verification))) - .map_err(into_internal!("error encoding ntor3 secret_input"))?; - si - }; - let ntor_key_seed = h_key_seed(&secret_input); - let verify = h_verify(&secret_input); - - let computed_auth: DigestVal = { - use digest::Digest; - let mut auth = DigestWriter(Sha3_256::default()); - auth.write(&T_AUTH) - .and_then(|_| auth.write(&verify)) - .and_then(|_| auth.write(&state.relay_public.id)) - .and_then(|_| auth.write(&state.relay_public.pk)) - .and_then(|_| auth.write(&y_pk)) - .and_then(|_| auth.write(&state.my_public)) - .and_then(|_| auth.write(&state.msg_mac)) - .and_then(|_| auth.write(&Encap(encrypted_msg))) - .and_then(|_| auth.write(PROTOID)) - .and_then(|_| auth.write(&b"Server"[..])) - .map_err(into_internal!("error encoding ntor3 authentication input"))?; - auth.take().finalize().into() - }; - - let okay = computed_auth.ct_eq(&auth) - & ct::bool_to_choice(yx.was_contributory()) - & ct::bool_to_choice(state.shared_secret.was_contributory()); - - let (enc_key, keystream) = { - use digest::{ExtendableOutput, XofReader}; - let mut xof = DigestWriter(Shake256::default()); - xof.write(&T_FINAL) - .and_then(|_| xof.write(&ntor_key_seed)) - .map_err(into_internal!("error encoding ntor3 xof input"))?; - let mut r = xof.take().finalize_xof(); - let mut enc_key = Zeroizing::new([0_u8; ENC_KEY_LEN]); - r.read(&mut enc_key[..]); - (enc_key, r) - }; - let server_reply = decrypt(&enc_key, encrypted_msg); - - if okay.into() { - Ok((server_reply, NtorV3XofReader(keystream))) - } else { - Err(Error::BadCircHandshakeAuth) - } -} - -#[cfg(test)] -pub(crate) fn client_handshake2_no_auth_check_obfs4( - msg: T, - state: &O5NtorHandshakeState, -) -> Result<(O5NtorKeyGenerator, Authcode)> -where - T: AsRef<[u8]>, -{ - // try to parse the message as an incoming server handshake. - let (mut shs_msg, _) = try_parse(&msg, state)?; - - let their_pk = shs_msg.server_pubkey(); - // let auth: Authcode = shs_msg.server_auth(); - - let node_pubkey = &state.materials.node_pubkey; - let my_public: PublicKey = (&state.my_sk).into(); - - let xy = state.my_sk.diffie_hellman(&their_pk); - let xb = state.my_sk.diffie_hellman(&node_pubkey.pk); - - let (key_seed, authcode) = ntor_derive(&xy, &xb, node_pubkey, &my_public, &their_pk) - .map_err(into_internal!("Error deriving keys"))?; - - let keygen = O5NtorKeyGenerator::new(key_seed, true); - - Ok((keygen, authcode)) -} - -fn try_parse( - buf: impl AsRef<[u8]>, - state: &O5NtorHandshakeState, -) -> Result<(ServerHandshakeMessage, usize)> { - let buf = buf.as_ref(); - trace!( - "{} parsing server handshake {}", - state.materials.session_id, - buf.len() - ); - - if buf.len() < SERVER_MIN_HANDSHAKE_LENGTH { - Err(RelayHandshakeError::EAgain)? - } - - // derive the server mark - let mut key = state.materials.node_pubkey.pk.as_bytes().to_vec(); - key.append(&mut state.materials.node_pubkey.id.as_bytes().to_vec()); - let mut h = HmacSha256::new_from_slice(&key[..]).unwrap(); - h.reset(); // disambiguate reset() implementations Mac v digest - - let mut r_bytes: [u8; 32] = buf[0..REPRESENTATIVE_LENGTH].try_into().unwrap(); - h.update(&r_bytes); - - // clear the inconsistent elligator2 bits of the representative after - // using the wire format for deriving the mark - r_bytes[31] &= 0x3f; - let server_repres = PublicRepresentative::from(r_bytes); - let server_auth: [u8; AUTHCODE_LENGTH] = - buf[REPRESENTATIVE_LENGTH..REPRESENTATIVE_LENGTH + AUTHCODE_LENGTH].try_into()?; - - let server_mark = h.finalize_reset().into_bytes()[..MARK_LENGTH].try_into()?; - - //attempt to find the mark + MAC - let start_pos = REPRESENTATIVE_LENGTH + AUTHCODE_LENGTH + SERVER_MIN_PAD_LENGTH; - let pos = match find_mac_mark(server_mark, buf, start_pos, MAX_HANDSHAKE_LENGTH, false) { - Some(p) => p, - None => { - if buf.len() > MAX_HANDSHAKE_LENGTH { - Err(RelayHandshakeError::BadServerHandshake)? - } - Err(RelayHandshakeError::EAgain)? - } - }; - - // validate the MAC - h.reset(); // disambiguate `reset()` implementations Mac v digest - h.update(&buf[..pos + MARK_LENGTH]); - h.update(state.epoch_hr.as_bytes()); - let mac_calculated = &h.finalize_reset().into_bytes()[..MAC_LENGTH]; - let mac_received = &buf[pos + MARK_LENGTH..pos + MARK_LENGTH + MAC_LENGTH]; - trace!( - "client mac check {}-{}", - hex::encode(mac_calculated), - hex::encode(mac_received) - ); - if mac_calculated.ct_eq(mac_received).into() { - let mut r_bytes = server_repres.to_bytes(); - r_bytes[31] &= 0x3f; - return Ok(( - ServerHandshakeMessage::new(server_repres, server_auth, state.epoch_hr.clone()), - pos + MARK_LENGTH + MAC_LENGTH, - )); - } - - // received the incorrect mac - Err(RelayHandshakeError::BadServerHandshake.into()) -} diff --git a/crates/o5/src/handshake/handshake_server.rs b/crates/o5/src/handshake/handshake_server.rs deleted file mode 100644 index 3cdfb06..0000000 --- a/crates/o5/src/handshake/handshake_server.rs +++ /dev/null @@ -1,284 +0,0 @@ -use super::*; -use crate::{ - common::{ - curve25519::{PublicRepresentative, REPRESENTATIVE_LENGTH}, - HmacSha256, - }, - framing::{build_and_marshall, ClientHandshakeMessage, MessageTypes, ServerHandshakeMessage}, -}; - -use ptrs::{debug, trace}; -use rand::thread_rng; -use tokio_util::codec::Encoder; - -use std::time::Instant; - -#[derive(Clone)] -pub(crate) struct HandshakeMaterials { - pub(crate) identity_keys: O5NtorSecretKey, - pub(crate) session_id: String, - pub(crate) len_seed: [u8; SEED_LENGTH], -} - -impl<'a> HandshakeMaterials { - pub fn get_hmac(&self) -> HmacSha256 { - let mut key = self.identity_keys.pk.pk.as_bytes().to_vec(); - key.append(&mut self.identity_keys.pk.id.as_bytes().to_vec()); - HmacSha256::new_from_slice(&key[..]).unwrap() - } - - pub fn new<'b>( - identity_keys: &'b O5NtorSecretKey, - session_id: String, - len_seed: [u8; SEED_LENGTH], - ) -> Self - where - 'b: 'a, - { - HandshakeMaterials { - identity_keys: identity_keys.clone(), - session_id, - len_seed, - } - } -} - -impl Server { - /// Perform a server-side ntor handshake. - /// - /// On success returns a key generator and a server onionskin. - pub(super) fn server_handshake_obfs4( - &self, - msg: T, - materials: HandshakeMaterials, - ) -> RelayHandshakeResult<(NtorHkdfKeyGenerator, Vec)> - where - T: AsRef<[u8]>, - { - let rng = thread_rng(); - let session_sk = Representable::ephemeral_from_rng(rng); - - self.server_handshake_obfs4_no_keygen(session_sk, msg, materials) - } - - /// Helper: perform a server handshake without generating any new keys. - pub(crate) fn server_handshake_obfs4_no_keygen( - &self, - session_sk: EphemeralSecret, - msg: T, - mut materials: HandshakeMaterials, - ) -> RelayHandshakeResult<(NtorHkdfKeyGenerator, Vec)> - where - T: AsRef<[u8]>, - { - if CLIENT_MIN_HANDSHAKE_LENGTH > msg.as_ref().len() { - Err(RelayHandshakeError::EAgain)?; - } - - let mut client_hs = match self.try_parse_client_handshake(msg, &mut materials) { - Ok(chs) => chs, - Err(Error::HandshakeErr(RelayHandshakeError::EAgain)) => { - return Err(RelayHandshakeError::EAgain); - } - Err(_e) => { - debug!( - "{} failed to parse client handshake: {_e}", - materials.session_id - ); - return Err(RelayHandshakeError::BadClientHandshake); - } - }; - - debug!( - "{} successfully parsed client handshake", - materials.session_id - ); - let their_pk = client_hs.get_public(); - let ephem_pub = PublicKey::from(&session_sk); - let session_repres: Option = (&session_sk).into(); - - let xy = session_sk.diffie_hellman(&their_pk); - let xb = materials.identity_keys.sk.diffie_hellman(&their_pk); - - // Ensure that none of the keys are broken (i.e. equal to zero). - let okay = - ct::bool_to_choice(xy.was_contributory()) & ct::bool_to_choice(xb.was_contributory()); - trace!("x {} y {}", hex::encode(their_pk), hex::encode(ephem_pub)); - - let (key_seed, authcode) = - ntor_derive(&xy, &xb, &materials.identity_keys.pk, &their_pk, &ephem_pub) - .map_err(into_internal!("Error deriving keys"))?; - trace!( - "seed: {} auth: {}", - hex::encode(key_seed.as_slice()), - hex::encode(authcode) - ); - - let mut keygen = NtorHkdfKeyGenerator::new(key_seed, false); - - let reply = self.complete_server_hs( - &client_hs, - materials, - session_repres.unwrap(), - &mut keygen, - authcode, - )?; - - if okay.into() { - Ok((keygen, reply)) - } else { - Err(RelayHandshakeError::BadClientHandshake) - } - } - - pub(crate) fn complete_server_hs( - &self, - client_hs: &ClientHandshakeMessage, - materials: HandshakeMaterials, - session_repres: PublicRepresentative, - keygen: &mut NtorHkdfKeyGenerator, - authcode: Authcode, - ) -> RelayHandshakeResult> { - let epoch_hr = client_hs.get_epoch_hr(); - - // Since the current and only implementation always sends a PRNG seed for - // the length obfuscation, this makes the amount of data received from the - // server inconsistent with the length sent from the client. - // - // Re-balance this by tweaking the client minimum padding/server maximum - // padding, and sending the PRNG seed unpadded (As in, treat the PRNG seed - // as part of the server response). See inlineSeedFrameLength in - // handshake_ntor.go. - - // Generate/send the response. - let mut sh_msg = ServerHandshakeMessage::new(session_repres, authcode, epoch_hr); - - let h = materials.get_hmac(); - let mut buf = BytesMut::with_capacity(MAX_HANDSHAKE_LENGTH); - sh_msg - .marshall(&mut buf, h) - .map_err(|e| RelayHandshakeError::FrameError(format!("{e}")))?; - trace!("adding encoded prng seed"); - - // Send the PRNG seed as part of the first packet. - let mut prng_pkt_buf = BytesMut::new(); - build_and_marshall( - &mut prng_pkt_buf, - MessageTypes::PrngSeed.into(), - materials.len_seed, - 0, - ) - .map_err(|e| RelayHandshakeError::FrameError(format!("{e}")))?; - - let codec = &mut keygen.codec; - codec - .encode(prng_pkt_buf.clone(), &mut buf) - .map_err(|e| RelayHandshakeError::FrameError(format!("{e}")))?; - - debug!( - "{} writing server handshake {}B ...{}", - materials.session_id, - buf.len(), - hex::encode(&buf[buf.len() - 10..]), - ); - - Ok(buf.to_vec()) - } - - fn try_parse_client_handshake( - &self, - buf: impl AsRef<[u8]>, - materials: &mut HandshakeMaterials, - ) -> Result { - let buf = buf.as_ref(); - let mut h = materials.get_hmac(); - - if CLIENT_MIN_HANDSHAKE_LENGTH > buf.len() { - Err(Error::HandshakeErr(RelayHandshakeError::EAgain))?; - } - - let mut r_bytes: [u8; 32] = buf[0..REPRESENTATIVE_LENGTH].try_into().unwrap(); - - // derive the mark based on the literal bytes on the wire - h.update(&r_bytes[..]); - - // clear the bits that are unreliable (and randomized) for elligator2 - r_bytes[31] &= 0x3f; - let repres = PublicRepresentative::from(&r_bytes); - - let m = h.finalize_reset().into_bytes(); - let mark: [u8; MARK_LENGTH] = m[..MARK_LENGTH].try_into()?; - - trace!("{} mark?:{}", materials.session_id, hex::encode(mark)); - - // find mark + mac position - let pos = match find_mac_mark( - mark, - buf, - REPRESENTATIVE_LENGTH + CLIENT_MIN_PAD_LENGTH, - MAX_HANDSHAKE_LENGTH, - true, - ) { - Some(p) => p, - None => { - trace!("{} didn't find mark", materials.session_id); - if buf.len() > MAX_HANDSHAKE_LENGTH { - Err(Error::HandshakeErr(RelayHandshakeError::BadClientHandshake))? - } - Err(Error::HandshakeErr(RelayHandshakeError::EAgain))? - } - }; - - // validate he MAC - let mut mac_found = false; - let mut epoch_hr = String::new(); - for offset in [0_i64, -1, 1] { - // Allow the epoch to be off by up to one hour in either direction - trace!("server trying offset: {offset}"); - let eh = format!("{}", offset + get_epoch_hour() as i64); - - h.reset(); - h.update(&buf[..pos + MARK_LENGTH]); - h.update(eh.as_bytes()); - let mac_calculated = &h.finalize_reset().into_bytes()[..MAC_LENGTH]; - let mac_received = &buf[pos + MARK_LENGTH..pos + MARK_LENGTH + MAC_LENGTH]; - trace!( - "server {}-{}", - hex::encode(mac_calculated), - hex::encode(mac_received) - ); - if mac_calculated.ct_eq(mac_received).into() { - trace!("correct mac"); - // Ensure that this handshake has not been seen previously. - if self - .replay_filter - .test_and_set(Instant::now(), mac_received) - { - // The client either happened to generate exactly the same - // session key and padding, or someone is replaying a previous - // handshake. In either case, fuck them. - Err(Error::HandshakeErr(RelayHandshakeError::ReplayedHandshake))? - } - - epoch_hr = eh; - mac_found = true; - // we could break here, but in the name of reducing timing - // variance, we just evaluate all three MACs. - } - } - if !mac_found { - // This could be a [`RelayHandshakeError::TagMismatch`] :shrug: - Err(Error::HandshakeErr(RelayHandshakeError::BadClientHandshake))? - } - - // client should never send any appended padding at the end. - if buf.len() != pos + MARK_LENGTH + MAC_LENGTH { - Err(Error::HandshakeErr(RelayHandshakeError::BadClientHandshake))? - } - - Ok(ClientHandshakeMessage::new( - repres, 0, // pad_len doesn't matter when we are reading client handshake msg - epoch_hr, - )) - } -} diff --git a/crates/o5/src/handshake/keys.rs b/crates/o5/src/handshake/keys.rs new file mode 100644 index 0000000..5d71f9e --- /dev/null +++ b/crates/o5/src/handshake/keys.rs @@ -0,0 +1,321 @@ +use super::*; +use crate::{ + common::{ + // kdf::{Kdf, Ntor1Kdf}, + mlkem1024_x25519::{self, Ciphertext, PublicKey, SharedSecret, StaticSecret}, + ntor_arti::{KeyGenerator, SessionID, SessionIdentifier}, + }, + constants::*, + framing::{O5Codec, KEY_MATERIAL_LENGTH}, + Error, Result, +}; + +use base64::{ + engine::general_purpose::{STANDARD, STANDARD_NO_PAD}, + Engine, +}; +use kem::Encapsulate; +use subtle::{Choice, ConstantTimeEq}; +use tor_bytes::{Readable, SecretBuf}; +use tor_llcrypto::{d::Shake256Reader, pk::ed25519::Ed25519Identity}; + +use rand::{CryptoRng, RngCore}; + +/// Key information about a relay used for the ntor v3 handshake. +/// +/// Contains a single curve25519 ntor onion key, and the relay's ed25519 +/// identity. +#[derive(Clone, Debug, PartialEq)] +pub struct IdentityPublicKey { + /// The relay's identity. + pub(crate) id: Ed25519Identity, + /// The relay's onion key. + pub(crate) pk: PublicKey, +} + +impl From<&IdentitySecretKey> for IdentityPublicKey { + fn from(value: &IdentitySecretKey) -> Self { + value.pk.clone() + } +} + +impl IdentityPublicKey { + const CERT_LENGTH: usize = mlkem1024_x25519::PUBKEY_LEN; + const CERT_SUFFIX: &'static str = "=="; + /// Construct a new IdentityPublicKey from its components. + #[allow(unused)] + pub(crate) fn new( + pk: [u8; mlkem1024_x25519::PUBKEY_LEN], + id: [u8; NODE_ID_LENGTH], + ) -> Result { + Ok(Self { + pk: pk.try_into()?, + id: id.into(), + }) + } +} + +impl std::str::FromStr for IdentityPublicKey { + type Err = Error; + fn from_str(s: &str) -> std::prelude::v1::Result { + let mut cert = String::from(s); + cert.push_str(Self::CERT_SUFFIX); + let decoded = STANDARD + .decode(cert.as_bytes()) + .map_err(|e| format!("failed to decode cert: {e}"))?; + if decoded.len() != Self::CERT_LENGTH { + return Err(format!("cert length {} is invalid", decoded.len()).into()); + } + let id: [u8; NODE_ID_LENGTH] = decoded[..NODE_ID_LENGTH].try_into()?; + let pk: [u8; NODE_PUBKEY_LENGTH] = decoded[NODE_ID_LENGTH..].try_into()?; + IdentityPublicKey::new(pk, id) + } +} + +#[allow(clippy::to_string_trait_impl)] +impl std::string::ToString for IdentityPublicKey { + fn to_string(&self) -> String { + let mut s = Vec::from(self.id.as_bytes()); + s.extend(self.pk.as_bytes()); + STANDARD_NO_PAD.encode(s) + } +} + +impl Readable for IdentityPublicKey { + fn take_from(_b: &mut tor_bytes::Reader<'_>) -> tor_bytes::Result { + todo!("IdentityPublicKey Reader needs implemented"); + } +} + +/// Secret key information used by a relay for the ntor v3 handshake. +pub struct IdentitySecretKey { + /// The relay's public key information + pub(crate) pk: IdentityPublicKey, + /// The secret onion key. + pub(super) sk: StaticSecret, +} + +impl IdentitySecretKey { + /// Construct a new IdentitySecretKey from its components. + #[allow(unused)] + pub(crate) fn new(sk: StaticSecret, id: Ed25519Identity) -> Self { + Self { + pk: IdentityPublicKey { + id, + pk: PublicKey::from(&sk), + }, + sk, + } + } + + pub fn try_from_bytes(bytes: impl AsRef<[u8]>) -> Result { + let buf = bytes.as_ref(); + if buf.len() < mlkem1024_x25519::PRIVKEY_LEN + NODE_ID_LENGTH { + return Err(Error::new("bad station identity cert provided")); + } + + let mut id = [0u8; NODE_ID_LENGTH]; + id.copy_from_slice(&buf[..NODE_ID_LENGTH]); + let sk = StaticSecret::try_from_bytes(&buf[NODE_ID_LENGTH..])?; + Ok(Self::new(sk, id.into())) + } + + /// Generate a key using the given `rng`, suitable for testing. + pub(crate) fn random_from_rng(rng: &mut R) -> Self { + let mut id = [0_u8; NODE_ID_LENGTH]; + // Random bytes will work for testing, but aren't necessarily actually a valid id. + rng.fill_bytes(&mut id); + let sk = StaticSecret::random_from_rng(rng); + Self::new(sk, id.into()) + } + + /// Checks whether `id` and `pk` match this secret key. + /// + /// Used to perform a constant-time secret key lookup. + pub(crate) fn matches(&self, id: Ed25519Identity, pk: PublicKey) -> Choice { + id.as_bytes().ct_eq(self.pk.id.as_bytes()) & pk.as_bytes().ct_eq(self.pk.pk.as_bytes()) + } + + /// Hybrid Public Key Encryption (HPKE) handshake for ML-KEM1024 + X25519 + /// + /// This is a custom interface for now as there isn't an example interface that I am aware of. + /// (Read - this will likely change in the future) + pub fn hpke( + &self, + rng: &mut R, + pubkey: &IdentityPublicKey, + ) -> Result<(Ciphertext, SharedSecret)> { + self.sk + .with_pub(&pubkey.pk) + .encapsulate(rng) + .map_err(|e| Error::Crypto(e.to_string())) + } +} + +impl TryFrom<&[u8]> for IdentitySecretKey { + type Error = Error; + fn try_from(value: &[u8]) -> std::result::Result { + Self::try_from_bytes(value) + } +} + +pub trait NtorV3KeyGen: KeyGenerator + SessionIdentifier + Into {} + +/// Opaque wrapper type for NtorV3's hash reader. +pub(crate) struct NtorV3XofReader(Shake256Reader); + +impl NtorV3XofReader { + pub(crate) fn new(reader: Shake256Reader) -> Self { + Self(reader) + } +} + +impl digest::XofReader for NtorV3XofReader { + fn read(&mut self, buffer: &mut [u8]) { + self.0.read(buffer); + } +} + +/// A key generator returned from an ntor v3 handshake. +pub(crate) struct NtorV3KeyGenerator { + /// The underlying `digest::XofReader`. + reader: NtorV3XofReader, + session_id: SessionID, + codec: O5Codec, +} + +impl KeyGenerator for NtorV3KeyGenerator { + fn expand(mut self, keylen: usize) -> Result { + let mut ret: SecretBuf = vec![0; keylen].into(); + self.reader.read(ret.as_mut()); + Ok(ret) + } +} + +impl NtorV3KeyGen for NtorV3KeyGenerator {} + +impl NtorV3KeyGenerator { + pub(crate) fn new(mut reader: NtorV3XofReader) -> Self { + // let okm = Self::kdf(&seed[..], KEY_MATERIAL_LENGTH * 2 + SESSION_ID_LEN) + // .expect("bug: failed to derive key material from seed"); + + // use the seed value to bootstrap Read / Write crypto codec and session ID. + let mut ekm = [0u8; KEY_MATERIAL_LENGTH]; + reader.read(&mut ekm); + let mut dkm = [0u8; KEY_MATERIAL_LENGTH]; + reader.read(&mut dkm); + + let mut id = [0u8; SESSION_ID_LEN]; + reader.read(&mut id); + + // server ekm == client dkm and vice-versa + let codec = match R::is_client() { + false => O5Codec::new(ekm, dkm), + true => O5Codec::new(dkm, ekm), + }; + + Self { + reader, + codec, + session_id: id.into(), + } + } +} + +impl SessionIdentifier for NtorV3KeyGenerator { + type ID = SessionID; + fn session_id(&mut self) -> Self::ID { + self.session_id + } +} + +impl KeyGenerator for NtorV3XofReader { + fn expand(mut self, keylen: usize) -> Result { + // let ntor1_key = &T_KEY_SEED[..]; + // let ntor1_expand = &M_EXPAND[..]; + // Ntor1Kdf::new(ntor1_key, ntor1_expand).derive(&self.seed[..], keylen) + let mut ret: SecretBuf = vec![0; keylen].into(); + self.0.read(ret.as_mut()); + Ok(ret) + } +} + +impl From for O5Codec { + fn from(keygen: NtorV3KeyGenerator) -> Self { + keygen.codec + } +} + +/// Alias for an HMAC output, used to validate correctness of a handshake. +pub(crate) type Authcode = [u8; 32]; +pub(crate) const AUTHCODE_LENGTH: usize = 32; + +// /// helper: compute a key generator and an authentication code from a set +// /// of ntor parameters. +// /// +// /// These parameter names are as described in tor-spec.txt +// fn ntor_derive( +// xy: &SharedSecret, +// xb: &SharedSecret, +// server_pk: &IdentityPublicKey, +// x: &PublicKey, +// y: &PublicKey, +// ) -> EncodeResult<(SecretBuf, Authcode)> { +// // ) -> EncodeResult<(NtorHkdfKeyGenerator, Authcode)> { +// let server_string = &b"Server"[..]; +// +// // obfs4 uses a different order than Ntor V1 and accidentally writes the +// // server's identity public key bytes twice. +// let mut suffix = SecretBuf::new(); +// suffix.write(&server_pk.pk.as_bytes())?; // b +// suffix.write(&server_pk.pk.as_bytes())?; // b +// suffix.write(x.as_bytes())?; // x +// suffix.write(y.as_bytes())?; // y +// suffix.write(PROTOID)?; // PROTOID +// suffix.write(&server_pk.id)?; // ID +// +// // secret_input = EXP(X,y) | EXP(X,b) OR = EXP(Y,x) | EXP(B,x) +// // ^ these are the equivalent x25519 shared secrets concatenated +// // +// // message = (secret_input) | b | b | x | y | PROTOID | ID +// let mut message = SecretBuf::new(); +// message.write(xy.as_bytes())?; // EXP(X,y) +// message.write(xb.as_bytes())?; // EXP(X,b) +// message.write(&suffix[..])?; // b | b | x | y | PROTOID | ID +// +// // verify = HMAC_SHA256(msg, T_VERIFY) +// let verify = { +// let mut m = Hmac::::new_from_slice(T_VERIFY).expect("Hmac allows keys of any size"); +// m.update(&message[..]); +// m.finalize() +// }; +// +// // auth_input = verify | (suffix) | "Server" +// // auth_input = verify | b | b | y | x | PROTOID | ID | "Server" +// // +// // Again obfs4 uses all of the same fields (with the servers identity public +// // key duplicated), but in a different order than Ntor V1. +// let mut auth_input = Vec::new(); +// auth_input.write_and_consume(verify)?; // verify +// auth_input.write(&suffix[..])?; // b | b | x | y | PROTOID | ID +// auth_input.write(server_string)?; // "Server" +// +// // auth = HMAC_SHA256(auth_input, T_MAC) +// let auth_mac = { +// let mut m = Hmac::::new_from_slice(T_MAC).expect("Hmac allows keys of any size"); +// m.update(&auth_input[..]); +// m.finalize() +// }; +// let auth: [u8; 32] = auth_mac.into_bytes()[..].try_into().unwrap(); +// +// // key_seed = HMAC_SHA256(message, T_KEY) +// let key_seed_bytes = { +// let mut m = Hmac::::new_from_slice(T_KEY).expect("Hmac allows keys of any size"); +// m.update(&message[..]); +// m.finalize() +// }; +// let mut key_seed = SecretBuf::new(); +// key_seed.write_and_consume(key_seed_bytes)?; +// +// Ok((key_seed, auth)) +// } diff --git a/crates/o5/src/handshake/kyber.rs b/crates/o5/src/handshake/kyber.rs deleted file mode 100644 index 080dfbd..0000000 --- a/crates/o5/src/handshake/kyber.rs +++ /dev/null @@ -1,355 +0,0 @@ -//! ## KyberX25519 Ntor Handshake -//! -//! ### As Described in draft-tls-westerbaan-xyber768d00-03 -//! -//! ``` -//! 3. Construction -//! -//! We instantiate draft-ietf-tls-hybrid-design-06 with X25519 [rfc7748] -//! and Kyber768Draft00 [kyber]. The latter is Kyber as submitted to -//! round 3 of the NIST PQC process [KyberV302]. -//! -//! For the client's share, the key_exchange value contains the -//! concatenation of the client's X25519 ephemeral share (32 bytes) and -//! the client's Kyber768Draft00 public key (1184 bytes). The resulting -//! key_exchange value is 1216 bytes in length. -//! -//! For the server's share, the key_exchange value contains the -//! concatenation of the server's X25519 ephemeral share (32 bytes) and -//! the Kyber768Draft00 ciphertext (1088 bytes) returned from -//! encapsulation for the client's public key. The resulting -//! key_exchange value is 1120 bytes in length. -//! -//! The shared secret is calculated as the concatenation of the X25519 -//! shared secret (32 bytes) and the Kyber768Draft00 shared secret (32 -//! bytes). The resulting shared secret value is 64 bytes in length. -//! -//! 4. Security Considerations -//! -//! For TLS 1.3, this concatenation approach provides a secure key -//! exchange if either component key exchange methods (X25519 or -//! Kyber768Draft00) are secure [hybrid]. -//! ``` - -use crate::{ - common::ntor::{ - derive_ntor_shared, Auth, HandshakeResult, IdentityKeyPair, KeySeed, NtorError, PublicKey, - SessionKeyPair, ID, - }, - Error, Result, -}; - -use bytes::BytesMut; -use pqc_kyber::*; -use subtle::{Choice, ConstantTimeEq, CtOption}; - -use super::{AUTH_LENGTH, KEY_SEED_LENGTH}; - -const _ZERO_EXP: [u8; 32] = [0_u8; 32]; -const X25519_PUBKEY_LEN: usize = 32; -pub const KYBERX_PUBKEY_LEN: usize = KYBER_PUBLICKEYBYTES + X25519_PUBKEY_LEN; - -pub struct KyberXPublicKey { - pub kyber: pqc_kyber::PublicKey, - pub x25519: PublicKey, - contiguous: [u8; KYBERX_PUBKEY_LEN], -} - -impl KyberXPublicKey { - pub fn from_parts(x25519: PublicKey, kyber: pqc_kyber::PublicKey) -> Self { - let mut contiguous = [0_u8; KYBERX_PUBKEY_LEN]; - contiguous[..X25519_PUBKEY_LEN].copy_from_slice(&x25519.to_bytes()); - contiguous[X25519_PUBKEY_LEN..].copy_from_slice(&kyber); - - KyberXPublicKey { - kyber, - x25519, - contiguous, - } - } - - pub fn from_bytes(bytes: impl AsRef<[u8]>) -> std::result::Result { - let value = bytes.as_ref(); - if value.len() != KYBERX_PUBKEY_LEN { - return Err(NtorError::ParseError(String::from( - "failed to parse kyberx25519 public key, incorrect length", - ))); - } - - let mut x25519 = [0_u8; X25519_PUBKEY_LEN]; - x25519[..].copy_from_slice(&value[..X25519_PUBKEY_LEN]); - - let mut kyber = [0_u8; KYBER_PUBLICKEYBYTES]; - kyber[..].copy_from_slice(&value[X25519_PUBKEY_LEN..]); - - let mut contiguous = [0_u8; KYBERX_PUBKEY_LEN]; - contiguous[..].copy_from_slice(&value); - - Ok(KyberXPublicKey { - x25519: PublicKey::from(x25519), - kyber, - contiguous, - }) - } -} - -impl From<&KyberXSessionKeys> for KyberXPublicKey { - fn from(value: &KyberXSessionKeys) -> Self { - value.get_public() - } -} - -impl From<&KyberXIdentityKeys> for KyberXPublicKey { - fn from(value: &KyberXIdentityKeys) -> Self { - value.get_public() - } -} - -impl AsRef<[u8]> for KyberXPublicKey { - fn as_ref(&self) -> &[u8] { - &self.contiguous - } -} - -pub struct KyberXSessionKeys { - pub kyber: pqc_kyber::Keypair, - pub x25519: SessionKeyPair, -} - -impl KyberXSessionKeys { - fn new() -> Self { - let mut rng = rand::thread_rng(); - - KyberXSessionKeys { - x25519: SessionKeyPair::new(true), - kyber: pqc_kyber::keypair(&mut rng).expect("kyber key generation failed"), - } - } - - pub fn from_random(rng: &mut R) -> Self { - KyberXSessionKeys { - x25519: SessionKeyPair::new(true), - kyber: pqc_kyber::keypair(rng).expect("kyber key generation failed"), - } - } - - /// Allow downgrade of key pair to x25519 only. - pub fn to_x25519(self) -> SessionKeyPair { - self.x25519 - } - - pub fn get_public(&self) -> KyberXPublicKey { - let mut contiguous = [0_u8; KYBERX_PUBKEY_LEN]; - contiguous[..X25519_PUBKEY_LEN].copy_from_slice(&self.x25519.public.to_bytes()); - contiguous[X25519_PUBKEY_LEN..].copy_from_slice(&self.kyber.public); - - KyberXPublicKey { - kyber: self.kyber.public, - x25519: self.x25519.public, - contiguous, - } - } -} - -pub struct KyberXIdentityKeys { - pub kyber: pqc_kyber::Keypair, - pub x25519: IdentityKeyPair, -} - -impl KyberXIdentityKeys { - fn new() -> Self { - let mut rng = rand::thread_rng(); - - KyberXIdentityKeys { - x25519: IdentityKeyPair::new(), - kyber: pqc_kyber::keypair(&mut rng).expect("kyber key generation failed"), - } - } - - fn from_random(rng: &mut R) -> Self { - KyberXIdentityKeys { - x25519: IdentityKeyPair::new(), - kyber: pqc_kyber::keypair(rng).expect("kyber key generation failed"), - } - } - - /// Allow downgrade of key pair to x25519 only. - pub fn to_x25519(self) -> IdentityKeyPair { - self.x25519 - } - - pub fn get_public(&self) -> KyberXPublicKey { - let mut contiguous = [0_u8; KYBERX_PUBKEY_LEN]; - contiguous[..X25519_PUBKEY_LEN].copy_from_slice(&self.x25519.public.to_bytes()); - contiguous[X25519_PUBKEY_LEN..].copy_from_slice(&self.kyber.public); - - KyberXPublicKey { - kyber: self.kyber.public, - x25519: self.x25519.public, - contiguous, - } - } -} - -/// The client side uses the ntor derived shared secret based on the secret -/// input created by appending the shared secret derived between the client's -/// session keys and the server's sessions keys with the shared secret derived -/// between the clients session keys and the server's identity keys. -/// -/// secret input = X25519(Y, x) | Kyber(Y, x) | X25519(B, x) | Kyber(B, x) -pub fn client_handshake( - client_keys: &KyberXSessionKeys, - server_public: &KyberXPublicKey, - id_public: &KyberXPublicKey, - id: &ID, -) -> subtle::CtOption { - let mut not_ok = 0; - let mut secret_input: Vec = vec![]; - - // EXP(Y,x) - let exp = client_keys - .x25519 - .private - .diffie_hellman(&server_public.x25519); - - not_ok |= _ZERO_EXP[..].ct_eq(exp.as_bytes()).unwrap_u8(); - secret_input.append(&mut exp.as_bytes().to_vec()); - - // EXP(B,x) - let exp = client_keys.x25519.private.diffie_hellman(&id_public.x25519); - not_ok |= _ZERO_EXP[..].ct_eq(exp.as_bytes()).unwrap_u8(); - secret_input.append(&mut exp.as_bytes().to_vec()); - - let (key_seed, auth) = derive_ntor_shared( - secret_input, - id, - id_public, - &client_keys.get_public(), - server_public, - ); - - // failed if not_ok != 0 - // if not_ok != 0 then scalar operations failed - subtle::CtOption::new(HandshakeResult { key_seed, auth }, not_ok.ct_eq(&0_u8)) -} - -/// The server side uses the ntor derived shared secret based on the secret -/// input created by appending the shared secret derived between the server's -/// session keys and the client's sessions keys with the shared secret derived -/// between the server's identity keys and the clients session keys. -/// -/// secret input = X25519(X, y) | Kyber(X, y) | X25519(X, b) | Kyber(X, b) -pub fn server_handshake( - server_keys: &KyberXSessionKeys, - client_public: &KyberXPublicKey, - id_keys: &KyberXIdentityKeys, - id: &ID, -) -> subtle::CtOption { - let mut not_ok = 0; - let mut secret_input: Vec = vec![]; - - // EXP(X,y) - let exp = server_keys - .x25519 - .private - .diffie_hellman(&client_public.x25519); - not_ok |= _ZERO_EXP[..].ct_eq(exp.as_bytes()).unwrap_u8(); - secret_input.append(&mut exp.as_bytes().to_vec()); - - // EXP(X,b) - let exp = id_keys.x25519.private.diffie_hellman(&client_public.x25519); - not_ok |= _ZERO_EXP[..].ct_eq(exp.as_bytes()).unwrap_u8(); - secret_input.append(&mut exp.as_bytes().to_vec()); - - let (key_seed, auth) = derive_ntor_shared( - secret_input, - id, - &id_keys.get_public(), - client_public, - &server_keys.get_public(), - ); - - // failed if not_ok != 0 - // if not_ok != 0 then scalar operations failed - subtle::CtOption::new(HandshakeResult { key_seed, auth }, not_ok.ct_eq(&0_u8)) -} - -#[cfg(test)] -#[allow(unused)] -mod tests { - use crate::common::ntor::compare_auth; - - use super::*; - use x25519_dalek::EphemeralSecret; - - #[test] - fn kyberx25519_handshake_flow() { - // long-term server id and keys - let server_id_keys = KyberXIdentityKeys::new(); - let server_id_pub = server_id_keys.get_public(); - let server_id = ID::new(); - - // client open session, generating the associated ephemeral keys - let client_session = KyberXSessionKeys::new(); - - // client sends kyber25519 session pubkey(s) - let cpk = client_session.get_public(); - - // server computes kyberx25519 combined shared secret - let server_session = KyberXSessionKeys::new(); - let server_hs_res = server_handshake(&server_session, &cpk, &server_id_keys, &server_id); - - // server sends kyberx25519 session pubkey(s) - let spk = client_session.get_public(); - - // client computes kyberx25519 combined shared secret - let client_hs_res = client_handshake(&client_session, &spk, &server_id_pub, &server_id); - - assert_ne!(client_hs_res.is_some().unwrap_u8(), 0); - assert_ne!(server_hs_res.is_some().unwrap_u8(), 0); - - let chsres = client_hs_res.unwrap(); - let shsres = server_hs_res.unwrap(); - assert_eq!(chsres.key_seed, shsres.key_seed); - assert_eq!(&chsres.auth, &shsres.auth); - } - - #[test] - fn kyber_handshake_supplement_flow() { - // long-term server id and keys - let server_id_keys = KyberXIdentityKeys::new(); - let server_id_pub = server_id_keys.get_public(); - let server_id = ID::new(); - - // client open session, generating the associated ephemeral keys - let client_session = KyberXSessionKeys::new(); - - // client sends ed25519 session pubkey elligator2 encoded and includes - // session Kyber1024Supplement CryptoOffer. - let c_ed_pk = client_session.x25519.public; - let c_ky_pk = client_session.kyber.public; - let cpk = KyberXPublicKey::from_parts(c_ed_pk, c_ky_pk); - - // server computes KyberX25519 combined shared secret - let server_session = KyberXSessionKeys::new(); - let server_hs_res = server_handshake(&server_session, &cpk, &server_id_keys, &server_id); - - // server sends ed25519 session pubkey elligator2 encoded and includes - // session Kyber1024Supplement CryptoAccept. - let s_ed_pk = client_session.x25519.public; - let s_ky_pk = client_session.kyber.public; - let spk = KyberXPublicKey::from_parts(c_ed_pk, c_ky_pk); - - // client computes KyberX25519 combined shared secret - let client_hs_res = client_handshake(&client_session, &spk, &server_id_pub, &server_id); - - assert_ne!(client_hs_res.is_some().unwrap_u8(), 0); - assert_ne!(server_hs_res.is_some().unwrap_u8(), 0); - - let chsres = client_hs_res.unwrap(); - let shsres = server_hs_res.unwrap(); - assert_eq!(chsres.key_seed, shsres.key_seed); - assert_eq!(&chsres.auth, &shsres.auth); - } -} - diff --git a/crates/o5/src/handshake/mod.rs b/crates/o5/src/handshake/mod.rs deleted file mode 100644 index 3eddb59..0000000 --- a/crates/o5/src/handshake/mod.rs +++ /dev/null @@ -1,757 +0,0 @@ -//! Implements the ntor v3 key exchange, as described in proposal 332. -//! -//! The main difference between the ntor v3r handshake and the -//! original ntor handshake is that this this one allows each party to -//! encrypt data (without forward secrecy) after it sends the first -//! message. - -use crate::{ - common::{ - ct, - curve25519::{Representable, StaticSecret}, - ntor_arti::{ - AuxDataReply, ClientHandshake, KeyGenerator, RelayHandshakeError, RelayHandshakeResult, - ServerHandshake, - }, - }, - constants::*, - framing::{O5Codec, KEY_MATERIAL_LENGTH}, - Error, Result, Server, -}; - -use tor_bytes::{EncodeResult, Reader, SecretBuf, Writeable, Writer}; -use tor_error::into_internal; -use tor_llcrypto::d::{Sha3_256, Shake256, Shake256Reader}; -use tor_llcrypto::pk::{curve25519, ed25519::Ed25519Identity}; -use tor_llcrypto::util::ct::ct_lookup; - -use cipher::{KeyIvInit, StreamCipher}; - -#[cfg(test)] -use rand_core::{CryptoRng, RngCore}; - -use subtle::{Choice, ConstantTimeEq}; -use tor_cell::relaycell::extend::NtorV3Extension; -use tor_llcrypto::cipher::aes::Aes256Ctr; -use zeroize::Zeroizing; - -use std::borrow::Borrow; - -mod handshake_client; -// mod handshake_server; -mod utils; - -pub(crate) mod kyber; - -pub(crate) use utils::*; - -pub(crate) use handshake_client::HandshakeMaterials as CHSMaterials; -#[cfg(test)] -pub(crate) use handshake_client::{ - client_handshake2_no_auth_check_o5, client_handshake_o5_no_keygen, -}; - -use handshake_client::{client_handshake2_o5, client_handshake_o5, O5NtorHandshakeState}; -pub(crate) use handshake_server::HandshakeMaterials as SHSMaterials; - -/// The verification string to be used for circuit extension. -const NTOR3_CIRC_VERIFICATION: &[u8] = b"circuit extend"; - -/// The size of an encryption key in bytes. -const ENC_KEY_LEN: usize = 32; -/// The size of a MAC key in bytes. -const MAC_KEY_LEN: usize = 32; -/// The size of a curve25519 public key in bytes. -const PUB_KEY_LEN: usize = 32; -/// The size of a digest output in bytes. -const DIGEST_LEN: usize = 32; -/// The length of a MAC output in bytes. -const MAC_LEN: usize = 32; -/// The length of a node identity in bytes. -const ID_LEN: usize = 32; - -/// Alias for an HMAC output, used to validate correctness of a handshake. -pub(crate) type Authcode = [u8; 32]; -pub(crate) const AUTHCODE_LENGTH: usize = 32; - -/// The output of the digest, as an array. -type DigestVal = [u8; DIGEST_LEN]; -/// The output of the MAC. -type MacVal = [u8; MAC_LEN]; -/// A key for symmetric encryption or decryption. -// -// TODO: Any move operations applied to this key could subvert the zeroizing. -type EncKey = Zeroizing<[u8; ENC_KEY_LEN]>; -/// A key for message authentication codes. -type MacKey = [u8; MAC_KEY_LEN]; - -/// Opaque wrapper type for NtorV3's hash reader. -struct NtorV3XofReader(Shake256Reader); - -impl digest::XofReader for NtorV3XofReader { - fn read(&mut self, buffer: &mut [u8]) { - self.0.read(buffer); - } -} - -/// An encapsulated value for passing as input to a MAC, digest, or -/// KDF algorithm. -/// -/// This corresponds to the ENCAP() function in proposal 332. -struct Encap<'a>(&'a [u8]); - -impl<'a> Writeable for Encap<'a> { - fn write_onto(&self, b: &mut B) -> EncodeResult<()> { - b.write_u64(self.0.len() as u64); - b.write(self.0) - } -} - -impl<'a> Encap<'a> { - /// Return the length of the underlying data in bytes. - fn len(&self) -> usize { - self.0.len() - } - /// Return the underlying data - fn data(&self) -> &'a [u8] { - } -} - -/// Helper to define a set of tweak values as instances of `Encap`. -macro_rules! define_tweaks { - { - $(#[$pid_meta:meta])* - PROTOID = $protoid:expr; - $( $(#[$meta:meta])* $name:ident <= $suffix:expr ; )* - } => { - $(#[$pid_meta])* - const PROTOID: &'static [u8] = $protoid.as_bytes(); - $( - $(#[$meta])* - const $name : Encap<'static> = - Encap(concat!($protoid, ":", $suffix).as_bytes()); - )* - } -} - -define_tweaks! { - /// Protocol ID: concatenated with other things in the protocol to - /// prevent hash confusion. - PROTOID = "ntor3-curve25519-sha3_256-1"; - - /// Message MAC tweak: used to compute the MAC of an encrypted client - /// message. - T_MSGMAC <= "msg_mac"; - /// Message KDF tweak: used when deriving keys for encrypting and MACing - /// client message. - T_MSGKDF <= "kdf_phase1"; - /// Key seeding tweak: used to derive final KDF input from secret_input. - T_KEY_SEED <= "key_seed"; - /// Verifying tweak: used to derive 'verify' value from secret_input. - T_VERIFY <= "verify"; - /// Final KDF tweak: used to derive keys for encrypting relay message - /// and for the actual tor circuit. - T_FINAL <= "kdf_final"; - /// Authentication tweak: used to derive the final authentication - /// value for the handshake. - T_AUTH <= "auth_final"; -} - -/// Compute a tweaked hash. -fn hash(t: &Encap<'_>, data: &[u8]) -> DigestVal { - use digest::Digest; - let mut d = Sha3_256::new(); - d.update((t.len() as u64).to_be_bytes()); - d.update(t.data()); - d.update(data); - d.finalize().into() -} - -/// Perform a symmetric encryption operation and return the encrypted data. -/// -/// (This isn't safe to do more than once with the same key, but we never -/// do that in this protocol.) -fn encrypt(key: &EncKey, m: &[u8]) -> Vec { - let mut d = m.to_vec(); - let zero_iv = Default::default(); - let mut cipher = Aes256Ctr::new(key.as_ref().into(), &zero_iv); - cipher.apply_keystream(&mut d); - d -} -/// Perform a symmetric decryption operation and return the encrypted data. -fn decrypt(key: &EncKey, m: &[u8]) -> Vec { - encrypt(key, m) -} - -/// Wrapper around a Digest or ExtendedOutput object that lets us use it -/// as a tor_bytes::Writer. -struct DigestWriter(U); -impl tor_bytes::Writer for DigestWriter { - fn write_all(&mut self, bytes: &[u8]) { - self.0.update(bytes); - } -} -impl DigestWriter { - /// Consume this wrapper and return the underlying object. - fn take(self) -> U { - self.0 - } -} - -/// Hash tweaked with T_KEY_SEED -fn h_key_seed(d: &[u8]) -> DigestVal { - hash(&T_KEY_SEED, d) -} -/// Hash tweaked with T_VERIFY -fn h_verify(d: &[u8]) -> DigestVal { - hash(&T_VERIFY, d) -} - -/// Helper: compute the encryption key and mac_key for the client's -/// encrypted message. -/// -/// Takes as inputs `xb` (the shared secret derived from -/// diffie-hellman as Bx or Xb), the relay's public key information, -/// the client's public key (B), and the shared verification string. -fn kdf_msgkdf( - xb: &curve25519::SharedSecret, - relay_public: &O5NtorPublicKey, - client_public: &curve25519::PublicKey, - verification: &[u8], -) -> EncodeResult<(EncKey, DigestWriter)> { - // secret_input_phase1 = Bx | ID | X | B | PROTOID | ENCAP(VER) - // phase1_keys = KDF_msgkdf(secret_input_phase1) - // (ENC_K1, MAC_K1) = PARTITION(phase1_keys, ENC_KEY_LEN, MAC_KEY_LEN - use digest::{ExtendableOutput, XofReader}; - let mut msg_kdf = DigestWriter(Shake256::default()); - msg_kdf.write(&T_MSGKDF)?; - msg_kdf.write(xb)?; - msg_kdf.write(&materials.node_pubkey.id)?; - msg_kdf.write(client_public)?; - msg_kdf.write(&materials.node_pubkey.pk)?; - msg_kdf.write(PROTOID)?; - msg_kdf.write(&Encap(verification))?; - let mut r = msg_kdf.take().finalize_xof(); - let mut enc_key = Zeroizing::new([0; ENC_KEY_LEN]); - let mut mac_key = Zeroizing::new([0; MAC_KEY_LEN]); - - r.read(&mut enc_key[..]); - r.read(&mut mac_key[..]); - let mut mac = DigestWriter(Sha3_256::default()); - { - mac.write(&T_MSGMAC)?; - mac.write(&Encap(&mac_key[..]))?; - mac.write(&materials.node_pubkey.id)?; - mac.write(&materials.node_pubkey.pk)?; - mac.write(client_public)?; - } - - Ok((enc_key, mac)) -} - -/// Client side of the ntor v3 handshake. -pub(crate) struct O5Client; - -impl ClientHandshake for O5Client { - type KeyType = O5NtorPublicKey; - type StateType = O5NtorHandshakeState; - type KeyGen = O5NtorKeyGenerator; - type ClientAuxData = [NtorV3Extension]; - type ServerAuxData = Vec; - - /// Generate a new client onionskin for a relay with a given onion key. - /// If any `extensions` are provided, encode them into to the onionskin. - /// - /// On success, return a state object that will be used to complete the handshake, along - /// with the message to send. - fn client1>( - key: &Self::KeyType, - client_aux_data: &M, - ) -> Result<(Self::StateType, Vec)> { - let mut message = Vec::new(); - // // TODO: Add extensions back in - // NtorV3Extension::write_many_onto(extensions.borrow(), &mut message) - // .map_err(|e| Error::from_bytes_enc(e, "ntor3 handshake extensions"))?; - Ok( - client_handshake_o5(key, &message, NTOR3_CIRC_VERIFICATION) - .map_err(into_internal!("Can't encode ntor3 client handshake."))?, - ) - } - - /// Handle an onionskin from a relay, and produce a key generator. - /// - /// The state object must match the one that was used to make the - /// client onionskin that the server is replying to. - fn client2>( - state: Self::StateType, - msg: T, - ) -> Result<(Self::ServerAuxData, Self::KeyGen)> { - let (message, xofreader) = - client_handshake_o5_part2(&state, msg.as_ref(), NTOR3_CIRC_VERIFICATION)?; - let extensions = NtorV3Extension::decode(&message).map_err(|err| Error::CellDecodeErr { - object: "ntor v3 extensions", - err, - })?; - let keygen = O5NtorKeyGenerator { reader: xofreader }; - - Ok((extensions, keygen)) - } -} - -/// Server side of the ntor v3 handshake. -pub(crate) struct O5Server; - -impl ServerHandshake for O5Server { - type KeyType = O5NtorSecretKey; - type KeyGen = O5NtorKeyGenerator; - type ClientAuxData = [NtorV3Extension]; - type ServerAuxData = Vec; - - fn server, T: AsRef<[u8]>>( - &self, - reply_fn: &mut REPLY, - key: &[Self::KeyType], - msg: T, - ) -> RelayHandshakeResult<(Self::KeyGen, Vec)> { - let mut bytes_reply_fn = |bytes: &[u8]| -> Option> { - let client_exts = NtorV3Extension::decode(bytes).ok()?; - let reply_exts = reply_fn.reply(&client_exts)?; - let mut out = vec![]; - NtorV3Extension::write_many_onto(&reply_exts, &mut out).ok()?; - Some(out) - }; - - let (res, reader) = server_handshake_o5( - &mut bytes_reply_fn, - msg.as_ref(), - key, - NTOR3_CIRC_VERIFICATION, - )?; - Ok((O5NtorKeyGenerator { reader }, res)) - } -} - -/// Key information about a relay used for the ntor v3 handshake. -/// -/// Contains a single curve25519 ntor onion key, and the relay's ed25519 -/// identity. -#[derive(Clone, Debug)] -pub(crate) struct O5NtorPublicKey { - /// The relay's identity. - pub(crate) id: Ed25519Identity, - /// The relay's onion key. - pub(crate) pk: curve25519::PublicKey, -} - -/// Secret key information used by a relay for the ntor v3 handshake. -pub(crate) struct O5NtorSecretKey { - /// The relay's public key information - pk: O5NtorPublicKey, - /// The secret onion key. - sk: curve25519::StaticSecret, -} - -impl O5NtorSecretKey { - /// Construct a new O5NtorSecretKey from its components. - #[allow(unused)] - pub(crate) fn new( - sk: curve25519::StaticSecret, - pk: curve25519::PublicKey, - id: Ed25519Identity, - ) -> Self { - Self { - pk: O5NtorPublicKey { id, pk }, - sk, - } - } - - /// Generate a key using the given `rng`, suitable for testing. - #[cfg(test)] - pub(crate) fn generate_for_test(rng: &mut R) -> Self { - let mut id = [0_u8; 32]; - // Random bytes will work for testing, but aren't necessarily actually a valid id. - rng.fill_bytes(&mut id); - - let sk = curve25519::StaticSecret::random_from_rng(rng); - - let pk = O5NtorPublicKey { - pk: (&sk).into(), - id: id.into(), - }; - Self { pk, sk } - } - - /// Checks whether `id` and `pk` match this secret key. - /// - /// Used to perform a constant-time secret key lookup. - fn matches(&self, id: Ed25519Identity, pk: curve25519::PublicKey) -> Choice { - // TODO: use similar pattern in ntor_v1! - id.as_bytes().ct_eq(self.pk.id.as_bytes()) & pk.as_bytes().ct_eq(self.pk.pk.as_bytes()) - } -} - -/// A key generator returned from an ntor v3 handshake. -pub(crate) struct O5NtorKeyGenerator { - /// The underlying `digest::XofReader`. - reader: NtorV3XofReader, -} - - -impl KeyGenerator for O5NtorKeyGenerator { - fn expand(mut self, keylen: usize) -> Result { - use digest::XofReader; - let mut ret: SecretBuf = vec![0; keylen].into(); - self.reader.read(ret.as_mut()); - Ok(ret) - } -} - - -/// Trait for an object that handle and incoming client message and -/// return a server's reply. -/// -/// This is implemented for `FnMut(&[u8]) -> Option>` automatically. -pub(crate) trait MsgReply { - /// Given a message received from a client, parse it and decide - /// how (and whether) to reply. - /// - /// Return None if the handshake should fail. - fn reply(&mut self, msg: &[u8]) -> Option>; -} - -impl MsgReply for F -where - F: FnMut(&[u8]) -> Option>, -{ - fn reply(&mut self, msg: &[u8]) -> Option> { - self(msg) - } -} - -/// Complete an ntor v3 handshake as a server. -/// -/// Use the provided `rng` to generate keys; use the provided -/// `reply_fn` to handle incoming client secret message and decide how -/// to reply. The client's handshake is in `message`. Our private -/// key(s) are in `keys`. The `verification` string must match the -/// string provided by the client. -/// -/// On success, return the server handshake message to send, and an XofReader -/// to use in generating circuit keys. -fn server_handshake_o5( - reply_fn: &mut REPLY, - message: &[u8], - keys: &[O5NtorSecretKey], - verification: &[u8], -) -> RelayHandshakeResult<(Vec, NtorV3XofReader)> { - let mut rng = rand::thread_rng(); - let secret_key_y = curve25519::StaticSecret::random_from_rng(rng); - server_handshake_o5_no_keygen(reply_fn, &secret_key_y, message, keys, verification) -} - -/// As `server_handshake_o5`, but take a secret key instead of an RNG. -fn server_handshake_o5_no_keygen( - reply_fn: &mut REPLY, - secret_key_y: &curve25519::StaticSecret, - message: &[u8], - keys: &[O5NtorSecretKey], - verification: &[u8], -) -> RelayHandshakeResult<(Vec, NtorV3XofReader)> { - // Decode the message. - let mut r = Reader::from_slice(message); - let id: Ed25519Identity = r.extract()?; - let requested_pk: curve25519::PublicKey = r.extract()?; - let client_pk: curve25519::PublicKey = r.extract()?; - let client_msg = if let Some(msg_len) = r.remaining().checked_sub(MAC_LEN) { - r.take(msg_len)? - } else { - return Err(tor_bytes::Error::Truncated.into()); - }; - let msg_mac: MacVal = r.extract()?; - r.should_be_exhausted()?; - - // See if we recognize the provided (id,requested_pk) pair. - let keypair = ct_lookup(keys, |key| key.matches(id, requested_pk)); - let keypair = match keypair { - Some(k) => k, - None => return Err(RelayHandshakeError::MissingKey), - }; - - let xb = keypair.sk.diffie_hellman(&client_pk); - let (enc_key, mut mac) = kdf_msgkdf(&xb, &keypair.pk, &client_pk, verification) - .map_err(into_internal!("Can't apply ntor3 kdf."))?; - // Verify the message we received. - let computed_mac: DigestVal = { - use digest::Digest; - mac.write(client_msg) - .map_err(into_internal!("Can't compute MAC input."))?; - mac.take().finalize().into() - }; - let y_pk: curve25519::PublicKey = (secret_key_y).into(); - let xy = secret_key_y.diffie_hellman(&client_pk); - - let mut okay = computed_mac.ct_eq(&msg_mac) - & ct::bool_to_choice(xy.was_contributory()) - & ct::bool_to_choice(xb.was_contributory()); - - let plaintext_msg = decrypt(&enc_key, client_msg); - - // Handle the message and decide how to reply. - let reply = reply_fn.reply(&plaintext_msg); - - // It's not exactly constant time to use is_some() and - // unwrap_or_else() here, but that should be somewhat - // hidden by the rest of the computation. - okay &= ct::bool_to_choice(reply.is_some()); - let reply = reply.unwrap_or_default(); - - // If we reach this point, we are actually replying, or pretending - // that we're going to reply. - - let secret_input = { - let mut si = SecretBuf::new(); - si.write(&xy) - .and_then(|_| si.write(&xb)) - .and_then(|_| si.write(&keypair.pk.id)) - .and_then(|_| si.write(&keypair.pk.pk)) - .and_then(|_| si.write(&client_pk)) - .and_then(|_| si.write(&y_pk)) - .and_then(|_| si.write(PROTOID)) - .and_then(|_| si.write(&Encap(verification))) - .map_err(into_internal!("can't derive ntor3 secret_input"))?; - si - }; - let ntor_key_seed = h_key_seed(&secret_input); - let verify = h_verify(&secret_input); - - let (enc_key, keystream) = { - use digest::{ExtendableOutput, XofReader}; - let mut xof = DigestWriter(Shake256::default()); - xof.write(&T_FINAL) - .and_then(|_| xof.write(&ntor_key_seed)) - .map_err(into_internal!("can't generate ntor3 xof."))?; - let mut r = xof.take().finalize_xof(); - let mut enc_key = Zeroizing::new([0_u8; ENC_KEY_LEN]); - r.read(&mut enc_key[..]); - (enc_key, r) - }; - let encrypted_reply = encrypt(&enc_key, &reply); - let auth: DigestVal = { - use digest::Digest; - let mut auth = DigestWriter(Sha3_256::default()); - auth.write(&T_AUTH) - .and_then(|_| auth.write(&verify)) - .and_then(|_| auth.write(&keypair.pk.id)) - .and_then(|_| auth.write(&keypair.pk.pk)) - .and_then(|_| auth.write(&y_pk)) - .and_then(|_| auth.write(&client_pk)) - .and_then(|_| auth.write(&msg_mac)) - .and_then(|_| auth.write(&Encap(&encrypted_reply))) - .and_then(|_| auth.write(PROTOID)) - .and_then(|_| auth.write(&b"Server"[..])) - .map_err(into_internal!("can't derive ntor3 authentication"))?; - auth.take().finalize().into() - }; - - let reply = { - let mut reply = Vec::new(); - reply - .write(&y_pk) - .and_then(|_| reply.write(&auth)) - .and_then(|_| reply.write(&encrypted_reply)) - .map_err(into_internal!("can't encode ntor3 reply."))?; - reply - }; - - if okay.into() { - Ok((reply, NtorV3XofReader(keystream))) - } else { - Err(RelayHandshakeError::BadClientHandshake) - } -} - - - -#[cfg(test)] -#[allow(non_snake_case)] // to enable variable names matching the spec. -#[allow(clippy::many_single_char_names)] // ibid -mod test { - // @@ begin test lint list maintained by maint/add_warning @@ - #![allow(clippy::bool_assert_comparison)] - #![allow(clippy::clone_on_copy)] - #![allow(clippy::dbg_macro)] - #![allow(clippy::mixed_attributes_style)] - #![allow(clippy::print_stderr)] - #![allow(clippy::print_stdout)] - #![allow(clippy::single_char_pattern)] - #![allow(clippy::unwrap_used)] - #![allow(clippy::unchecked_duration_subtraction)] - #![allow(clippy::useless_vec)] - #![allow(clippy::needless_pass_by_value)] - //! - use super::*; - use hex_literal::hex; - use tor_basic_utils::test_rng::testing_rng; - - #[test] - fn test_ntor3_roundtrip() { - let mut rng = rand::thread_rng(); - let relay_private = O5NtorSecretKey::generate_for_test(&mut testing_rng()); - - let verification = &b"shared secret"[..]; - let client_message = &b"Hello. I am a client. Let's be friends!"[..]; - let relay_message = &b"Greetings, client. I am a robot. Beep boop."[..]; - - let (c_state, c_handshake) = - client_handshake_o5(&relay_private.pk, client_message, verification).unwrap(); - - struct Rep(Vec, Vec); - impl MsgReply for Rep { - fn reply(&mut self, msg: &[u8]) -> Option> { - self.0 = msg.to_vec(); - Some(self.1.clone()) - } - } - let mut rep = Rep(Vec::new(), relay_message.to_vec()); - - let (s_handshake, mut s_keygen) = - server_handshake_o5(&mut rep, &c_handshake, &[relay_private], verification) - .unwrap(); - - let (s_msg, mut c_keygen) = - client_handshake_o5_part2(&c_state, &s_handshake, verification).unwrap(); - - assert_eq!(rep.0[..], client_message[..]); - assert_eq!(s_msg[..], relay_message[..]); - use digest::XofReader; - let mut s_keys = [0_u8; 100]; - let mut c_keys = [0_u8; 1000]; - s_keygen.read(&mut s_keys); - c_keygen.read(&mut c_keys); - assert_eq!(s_keys[..], c_keys[..100]); - } - - // Same as previous test, but use the higher-level APIs instead. - #[test] - fn test_ntor3_roundtrip_highlevel() { - let mut rng = rand::thread_rng(); - let relay_private = O5NtorSecretKey::generate_for_test(&mut testing_rng()); - - let (c_state, c_handshake) = O5Client::client1(&relay_private.pk, &[]).unwrap(); - - let mut rep = |_: &[NtorV3Extension]| Some(vec![]); - - let mut s = O5Server {}; - let (s_keygen, s_handshake) = s.server(&mut rep, &[relay_private], &c_handshake).unwrap(); - - let (extensions, keygen) = O5Client::client2(c_state, s_handshake).unwrap(); - - assert!(extensions.is_empty()); - let c_keys = keygen.expand(1000).unwrap(); - let s_keys = s_keygen.expand(100).unwrap(); - assert_eq!(s_keys[..], c_keys[..100]); - } - - // Same as previous test, but encode some congestion control extensions. - #[test] - fn test_ntor3_roundtrip_highlevel_cc() { - let mut rng = rand::thread_rng(); - let relay_private = O5NtorSecretKey::generate_for_test(&mut testing_rng()); - - let client_exts = vec![NtorV3Extension::RequestCongestionControl]; - let reply_exts = vec![NtorV3Extension::AckCongestionControl { sendme_inc: 42 }]; - - let (c_state, c_handshake) = O5Client::client1( - &relay_private.pk, - &[NtorV3Extension::RequestCongestionControl], - ) - .unwrap(); - - let mut rep = |msg: &[NtorV3Extension]| -> Option> { - assert_eq!(msg, client_exts); - Some(reply_exts.clone()) - }; - - let (s_keygen, s_handshake) = - O5Server::server(&mut rng, &mut rep, &[relay_private], &c_handshake).unwrap(); - - let (extensions, keygen) = O5Client::client2(c_state, s_handshake).unwrap(); - - assert_eq!(extensions, reply_exts); - let c_keys = keygen.expand(1000).unwrap(); - let s_keys = s_keygen.expand(100).unwrap(); - assert_eq!(s_keys[..], c_keys[..100]); - } - - #[test] - fn test_ntor3_testvec() { - let b = hex!("4051daa5921cfa2a1c27b08451324919538e79e788a81b38cbed097a5dff454a"); - let id = hex!("9fad2af287ef942632833d21f946c6260c33fae6172b60006e86e4a6911753a2"); - let x = hex!("b825a3719147bcbe5fb1d0b0fcb9c09e51948048e2e3283d2ab7b45b5ef38b49"); - let y = hex!("4865a5b7689dafd978f529291c7171bc159be076b92186405d13220b80e2a053"); - let b: curve25519::StaticSecret = b.into(); - let B: curve25519::PublicKey = (&b).into(); - let id: Ed25519Identity = id.into(); - let x: curve25519::StaticSecret = x.into(); - //let X = (&x).into(); - let y: curve25519::StaticSecret = y.into(); - - let client_message = hex!("68656c6c6f20776f726c64"); - let verification = hex!("78797a7a79"); - let server_message = hex!("486f6c61204d756e646f"); - - let materials = CHSMaterials{ - node_pubkey: O5NtorPublicKey { pk: B, id }, - }; - let relay_private = O5NtorSecretKey { - sk: b, - pk: materials.node_pubkey.clone(), - }; - - let (state, client_handshake) = - client_handshake_o5_no_keygen(&materials.node_pubkey, &client_message, &verification, x) - .unwrap(); - - assert_eq!(client_handshake[..], hex!("9fad2af287ef942632833d21f946c6260c33fae6172b60006e86e4a6911753a2f8307a2bc1870b00b828bb74dbb8fd88e632a6375ab3bcd1ae706aaa8b6cdd1d252fe9ae91264c91d4ecb8501f79d0387e34ad8ca0f7c995184f7d11d5da4f463bebd9151fd3b47c180abc9e044d53565f04d82bbb3bebed3d06cea65db8be9c72b68cd461942088502f67")[..]); - - struct Replier(Vec, Vec, bool); - impl MsgReply for Replier { - fn reply(&mut self, msg: &[u8]) -> Option> { - assert_eq!(msg, &self.0); - self.2 = true; - Some(self.1.clone()) - } - } - let mut rep = Replier(client_message.to_vec(), server_message.to_vec(), false); - - let (server_handshake, mut server_keygen) = server_handshake_o5_no_keygen( - &mut rep, - &y, - &client_handshake, - &[relay_private], - &verification, - ) - .unwrap(); - assert!(rep.2); - - assert_eq!(server_handshake[..], hex!("4bf4814326fdab45ad5184f5518bd7fae25dc59374062698201a50a22954246d2fc5f8773ca824542bc6cf6f57c7c29bbf4e5476461ab130c5b18ab0a91276651202c3e1e87c0d32054c")[..]); - - let (server_msg_received, mut client_keygen) = - client_handshake_o5_part2(&state, &server_handshake, &verification).unwrap(); - assert_eq!(&server_msg_received, &server_message); - - let (c_keys, s_keys) = { - use digest::XofReader; - let mut c = [0_u8; 256]; - let mut s = [0_u8; 256]; - client_keygen.read(&mut c); - server_keygen.read(&mut s); - (c, s) - }; - assert_eq!(c_keys, s_keys); - assert_eq!(c_keys[..], hex!("9c19b631fd94ed86a817e01f6c80b0743a43f5faebd39cfaa8b00fa8bcc65c3bfeaa403d91acbd68a821bf6ee8504602b094a254392a07737d5662768c7a9fb1b2814bb34780eaee6e867c773e28c212ead563e98a1cd5d5b4576f5ee61c59bde025ff2851bb19b721421694f263818e3531e43a9e4e3e2c661e2ad547d8984caa28ebecd3e4525452299be26b9185a20a90ce1eac20a91f2832d731b54502b09749b5a2a2949292f8cfcbeffb790c7790ed935a9d251e7e336148ea83b063a5618fcff674a44581585fd22077ca0e52c59a24347a38d1a1ceebddbf238541f226b8f88d0fb9c07a1bcd2ea764bbbb5dacdaf5312a14c0b9e4f06309b0333b4a")[..]); - } -} - -#[cfg(test)] -mod integration; diff --git a/crates/o5/src/handshake/ntor_obfs4.rs b/crates/o5/src/handshake/ntor_obfs4.rs deleted file mode 100644 index 4feeb56..0000000 --- a/crates/o5/src/handshake/ntor_obfs4.rs +++ /dev/null @@ -1,352 +0,0 @@ -//! Implements the ntor handshake, as used in modern Tor. - -use crate::{ - common::{ - ct, - curve25519::{EphemeralSecret, PublicKey, Representable, SharedSecret, StaticSecret}, - kdf::{Kdf, Ntor1Kdf}, - ntor_arti::{ - AuxDataReply, ClientHandshake, KeyGenerator, RelayHandshakeError, RelayHandshakeResult, - ServerHandshake, - }, - }, - constants::*, - framing::{O5Codec, KEY_MATERIAL_LENGTH}, - Error, Result, Server, -}; - -use std::borrow::Borrow; - -use base64::{ - engine::general_purpose::{STANDARD, STANDARD_NO_PAD}, - Engine as _, -}; -use bytes::BytesMut; -use digest::Mac; -use hmac::Hmac; -use ptrs::warn; -use subtle::ConstantTimeEq; -use tor_bytes::{EncodeResult, SecretBuf, Writer}; -use tor_error::into_internal; -use tor_llcrypto::d::Sha256; -use tor_llcrypto::pk::rsa::RsaIdentity; - -#[cfg(test)] -use rand::{CryptoRng, RngCore}; - -mod handshake_client; -mod handshake_server; -mod utils; - -pub(crate) use utils::*; - -pub(crate) use handshake_client::HandshakeMaterials as CHSMaterials; -#[cfg(test)] -pub(crate) use handshake_client::{ - client_handshake2_no_auth_check_obfs4, client_handshake_obfs4_no_keygen, -}; -use handshake_client::{client_handshake2_obfs4, client_handshake_obfs4, NtorHandshakeState}; -pub(crate) use handshake_server::HandshakeMaterials as SHSMaterials; - -pub(crate) const PROTO_ID: &[u8; 24] = b"ntor-curve25519-sha256-1"; -pub(crate) const T_MAC: &[u8; 28] = b"ntor-curve25519-sha256-1:mac"; -pub(crate) const T_VERIFY: &[u8; 35] = b"ntor-curve25519-sha256-1:key_verify"; -pub(crate) const T_KEY: &[u8; 36] = b"ntor-curve25519-sha256-1:key_extract"; -pub(crate) const M_EXPAND: &[u8; 35] = b"ntor-curve25519-sha256-1:key_expand"; - -/// Struct containing associated function for the obfs4 Ntor handshake. -pub(crate) struct O5NtorHandshake; - -impl ClientHandshake for O5NtorHandshake { - type KeyType = CHSMaterials; - type StateType = NtorHandshakeState; - type KeyGen = NtorHkdfKeyGenerator; - type ClientAuxData = (); - type ServerAuxData = BytesMut; - - fn client1>( - key: &Self::KeyType, - _client_aux_data: &M, - ) -> Result<(Self::StateType, Vec)> { - client_handshake_obfs4(key) - } - - fn client2>( - state: Self::StateType, - msg: T, - ) -> Result<(Self::ServerAuxData, Self::KeyGen)> { - let (keygen, remainder) = client_handshake2_obfs4(msg, &state)?; - Ok((BytesMut::from(&remainder[..]), keygen)) - } -} - -impl ServerHandshake for Server { - type KeyType = SHSMaterials; - type KeyGen = NtorHkdfKeyGenerator; - type ClientAuxData = (); - type ServerAuxData = (); - - fn server, T: AsRef<[u8]>>( - &self, - reply_fn: &mut REPLY, - key: &[Self::KeyType], - msg: T, - ) -> RelayHandshakeResult<(Self::KeyGen, Vec)> { - reply_fn - .reply(&()) - .ok_or(RelayHandshakeError::BadClientHandshake)?; - - if key.is_empty() { - return Err(RelayHandshakeError::MissingKey); - } - - if key.len() > 1 { - warn!("Multiple keys provided, but only the first key will be used"); - } - - let shs_materials = key[0].clone(); - - self.server_handshake_obfs4(msg, shs_materials) - } -} - -/// Key information about a relay used for the ntor v3 handshake. -/// -/// Contains a single curve25519 ntor onion key, and the relay's ed25519 -/// identity. -#[derive(Clone, Debug, Copy, PartialEq, Eq, Hash)] -pub(crate) struct O5NtorPublicKey { - /// Public RSA identity fingerprint for the relay; used in authentication - /// calculation. - pub(crate) id: RsaIdentity, - /// The Bridge's identity key. - pub(crate) pk: PublicKey, -} - -impl O5NtorPublicKey { - const CERT_LENGTH: usize = NODE_ID_LENGTH + NODE_PUBKEY_LENGTH; - const CERT_SUFFIX: &'static str = "=="; - /// Construct a new O5NtorPublicKey from its components. - #[allow(unused)] - pub(crate) fn new(pk: [u8; NODE_PUBKEY_LENGTH], id: [u8; NODE_ID_LENGTH]) -> Self { - Self { - pk: pk.into(), - id: id.into(), - } - } -} - -impl std::str::FromStr for O5NtorPublicKey { - type Err = Error; - fn from_str(s: &str) -> std::prelude::v1::Result { - let mut cert = String::from(s); - cert.push_str(Self::CERT_SUFFIX); - let decoded = STANDARD - .decode(cert.as_bytes()) - .map_err(|e| format!("failed to decode cert: {e}"))?; - if decoded.len() != Self::CERT_LENGTH { - return Err(format!("cert length {} is invalid", decoded.len()).into()); - } - let id: [u8; NODE_ID_LENGTH] = decoded[..NODE_ID_LENGTH].try_into().unwrap(); - let pk: [u8; NODE_PUBKEY_LENGTH] = decoded[NODE_ID_LENGTH..].try_into().unwrap(); - Ok(O5NtorPublicKey::new(pk, id)) - } -} - -#[allow(clippy::to_string_trait_impl)] -impl std::string::ToString for O5NtorPublicKey { - fn to_string(&self) -> String { - let mut s = Vec::from(self.id.as_bytes()); - s.extend(self.pk.as_bytes()); - STANDARD_NO_PAD.encode(s) - } -} - -/// Secret key information used by a relay for the ntor v3 handshake. -#[derive(Clone)] -pub(crate) struct O5NtorSecretKey { - /// The relay's public key information - pub(crate) pk: O5NtorPublicKey, - /// The secret onion key. - pub(crate) sk: StaticSecret, -} - -impl O5NtorSecretKey { - /// Construct a new O5NtorSecretKey from its components. - #[allow(unused)] - pub(crate) fn new(sk: StaticSecret, id: RsaIdentity) -> Self { - let pk = PublicKey::from(&sk); - Self { - pk: O5NtorPublicKey { id, pk }, - sk, - } - } - - /// Construct a new ['O5NtorSecretKey'] from a CSPRNG. - pub(crate) fn getrandom() -> Self { - let sk = Representable::random_static(); - let mut id = [0_u8; NODE_ID_LENGTH]; - getrandom::getrandom(&mut id).expect("internal randomness error"); - Self::new(sk, RsaIdentity::from(id)) - } - - /// Generate a key using the given `rng`, suitable for testing. - #[cfg(test)] - pub(crate) fn generate_for_test(rng: &mut R) -> Self { - let mut id = [0_u8; 20]; - // Random bytes will work for testing, but aren't necessarily actually a valid id. - rng.fill_bytes(&mut id); - - let sk = Representable::static_from_rng(rng); - - let pk = O5NtorPublicKey { - pk: (&sk).into(), - id: id.into(), - }; - Self { pk, sk } - } -} - -/// KeyGenerator for use with ntor circuit handshake. -pub(crate) struct NtorHkdfKeyGenerator { - /// Secret key information derived from the handshake, used as input - /// to HKDF - seed: SecretBuf, - codec: O5Codec, - session_id: [u8; SESSION_ID_LEN], -} - -impl NtorHkdfKeyGenerator { - /// Create a new key generator to expand a given seed - pub(crate) fn new(seed: SecretBuf, is_client: bool) -> Self { - // use the seed value to bootstrap Read / Write crypto codec. - let okm = Self::kdf(&seed[..], KEY_MATERIAL_LENGTH * 2 + SESSION_ID_LEN) - .expect("bug: failed to derive key material from seed"); - - let ekm: [u8; KEY_MATERIAL_LENGTH] = okm[KEY_MATERIAL_LENGTH..KEY_MATERIAL_LENGTH * 2] - .try_into() - .unwrap(); - let dkm: [u8; KEY_MATERIAL_LENGTH] = okm[..KEY_MATERIAL_LENGTH].try_into().unwrap(); - - let session_id = okm[KEY_MATERIAL_LENGTH * 2..].try_into().unwrap(); - - // server ekm == client dkm and vice-versa - let codec = match is_client { - false => O5Codec::new(ekm, dkm), - true => O5Codec::new(dkm, ekm), - }; - - NtorHkdfKeyGenerator { - seed, - codec, - session_id, - } - } - - fn kdf(seed: impl AsRef<[u8]>, keylen: usize) -> Result { - Ntor1Kdf::new(&T_KEY[..], &M_EXPAND[..]).derive(seed.as_ref(), keylen) - } -} - -impl KeyGenerator for NtorHkdfKeyGenerator { - fn expand(self, keylen: usize) -> Result { - let ntor1_key = &T_KEY[..]; - let ntor1_expand = &M_EXPAND[..]; - Ntor1Kdf::new(ntor1_key, ntor1_expand).derive(&self.seed[..], keylen) - } -} - -/// Alias for an HMAC output, used to validate correctness of a handshake. -pub(crate) type Authcode = [u8; 32]; -pub(crate) const AUTHCODE_LENGTH: usize = 32; - -/// helper: compute a key generator and an authentication code from a set -/// of ntor parameters. -/// -/// These parameter names are as described in tor-spec.txt -fn ntor_derive( - xy: &SharedSecret, - xb: &SharedSecret, - server_pk: &O5NtorPublicKey, - x: &PublicKey, - y: &PublicKey, -) -> EncodeResult<(SecretBuf, Authcode)> { - // ) -> EncodeResult<(NtorHkdfKeyGenerator, Authcode)> { - let server_string = &b"Server"[..]; - - // obfs4 uses a different order than Ntor V1 and accidentally writes the - // server's identity public key bytes twice. - let mut suffix = SecretBuf::new(); - suffix.write(&server_pk.pk.as_bytes())?; // b - suffix.write(&server_pk.pk.as_bytes())?; // b - suffix.write(x.as_bytes())?; // x - suffix.write(y.as_bytes())?; // y - suffix.write(PROTO_ID)?; // PROTOID - suffix.write(&server_pk.id)?; // ID - - // secret_input = EXP(X,y) | EXP(X,b) OR = EXP(Y,x) | EXP(B,x) - // ^ these are the equivalent x25519 shared secrets concatenated - // - // message = (secret_input) | b | b | x | y | PROTOID | ID - let mut message = SecretBuf::new(); - message.write(xy.as_bytes())?; // EXP(X,y) - message.write(xb.as_bytes())?; // EXP(X,b) - message.write(&suffix[..])?; // b | b | x | y | PROTOID | ID - - // verify = HMAC_SHA256(msg, T_VERIFY) - let verify = { - let mut m = Hmac::::new_from_slice(T_VERIFY).expect("Hmac allows keys of any size"); - m.update(&message[..]); - m.finalize() - }; - - // auth_input = verify | (suffix) | "Server" - // auth_input = verify | b | b | y | x | PROTOID | ID | "Server" - // - // Again obfs4 uses all of the same fields (with the servers identity public - // key duplicated), but in a different order than Ntor V1. - let mut auth_input = Vec::new(); - auth_input.write_and_consume(verify)?; // verify - auth_input.write(&suffix[..])?; // b | b | x | y | PROTOID | ID - auth_input.write(server_string)?; // "Server" - - // auth = HMAC_SHA256(auth_input, T_MAC) - let auth_mac = { - let mut m = Hmac::::new_from_slice(T_MAC).expect("Hmac allows keys of any size"); - m.update(&auth_input[..]); - m.finalize() - }; - let auth: [u8; 32] = auth_mac.into_bytes()[..].try_into().unwrap(); - - // key_seed = HMAC_SHA256(message, T_KEY) - let key_seed_bytes = { - let mut m = Hmac::::new_from_slice(T_KEY).expect("Hmac allows keys of any size"); - m.update(&message[..]); - m.finalize() - }; - let mut key_seed = SecretBuf::new(); - key_seed.write_and_consume(key_seed_bytes)?; - - Ok((key_seed, auth)) -} - -/// O5 helper trait to ensure that a returned key generator can be used -/// to create a usable codec and retrieve a session id. -pub trait O5Keygen: KeyGenerator + Into { - fn session_id(&mut self) -> [u8; SESSION_ID_LEN]; -} - -impl O5Keygen for NtorHkdfKeyGenerator { - fn session_id(&mut self) -> [u8; SESSION_ID_LEN] { - self.session_id - } -} - -impl From for O5Codec { - fn from(keygen: NtorHkdfKeyGenerator) -> Self { - keygen.codec - } -} - -#[cfg(test)] -mod integration; diff --git a/crates/o5/src/handshake/server.rs b/crates/o5/src/handshake/server.rs new file mode 100644 index 0000000..e5a6cf3 --- /dev/null +++ b/crates/o5/src/handshake/server.rs @@ -0,0 +1,225 @@ +use crate::{ + common::{ + ct, + drbg::SEED_LENGTH, + ntor_arti::{AuxDataReply, RelayHandshakeError, RelayHandshakeResult, ServerHandshake}, + }, + handshake::*, + sessions::SessionSecretKey, + Error, Server, +}; + +// use cipher::KeyIvInit; +use digest::{Digest, ExtendableOutput, XofReader}; +use hmac::{Hmac, Mac}; +use keys::NtorV3KeyGenerator; +use rand_core::{CryptoRng, RngCore}; +use sha2::Sha256; +use subtle::ConstantTimeEq; +use tor_bytes::{Reader, SecretBuf, Writer}; +use tor_cell::relaycell::extend::NtorV3Extension; +use tor_error::into_internal; +use tor_llcrypto::d::{Sha3_256, Shake256}; +use tor_llcrypto::pk::ed25519::Ed25519Identity; +use zeroize::Zeroizing; + +/// Server Materials needed for completing a handshake +pub(crate) struct HandshakeMaterials { + pub(crate) session_id: String, + pub(crate) len_seed: [u8; SEED_LENGTH], +} + +impl<'a> HandshakeMaterials { + pub fn get_hmac<'b>(&self, identity_keys: &'b IdentitySecretKey) -> Hmac { + let mut key = identity_keys.pk.pk.as_bytes().to_vec(); + key.append(&mut identity_keys.pk.id.as_bytes().to_vec()); + Hmac::::new_from_slice(&key[..]).unwrap() + } + + pub fn new<'b>(session_id: String, len_seed: [u8; SEED_LENGTH]) -> Self + where + 'b: 'a, + { + HandshakeMaterials { + session_id, + len_seed, + } + } +} + +impl ServerHandshake for Server { + type HandshakeParams = SHSMaterials; + type KeyGen = NtorV3KeyGenerator; + type ClientAuxData = [NtorV3Extension]; + type ServerAuxData = Vec; + + fn server, T: AsRef<[u8]>>( + &self, + reply_fn: &mut REPLY, + _materials: &Self::HandshakeParams, // TODO: do we need materials during server handshake? + msg: T, + ) -> RelayHandshakeResult<(Self::KeyGen, Vec)> { + let mut bytes_reply_fn = |bytes: &[u8]| -> Option> { + let client_exts = NtorV3Extension::decode(bytes).ok()?; + let reply_exts = reply_fn.reply(&client_exts)?; + let mut out = vec![]; + NtorV3Extension::write_many_onto(&reply_exts, &mut out).ok()?; + Some(out) + }; + let mut rng = rand::thread_rng(); + + let (res, reader) = server_handshake_ntor_v3( + &mut rng, + &mut bytes_reply_fn, + msg.as_ref(), + &self.identity_keys, + NTOR3_CIRC_VERIFICATION, + )?; + Ok((NtorV3KeyGenerator::new::(reader), res)) + } +} + +/// Complete an ntor v3 handshake as a server. +/// +/// Use the provided `rng` to generate keys; use the provided +/// `reply_fn` to handle incoming client secret message and decide how +/// to reply. The client's handshake is in `message`. Our private +/// key(s) are in `keys`. The `verification` string must match the +/// string provided by the client. +/// +/// On success, return the server handshake message to send, and an XofReader +/// to use in generating circuit keys. +pub(crate) fn server_handshake_ntor_v3( + rng: &mut R, + reply_fn: &mut REPLY, + message: &[u8], + keys: &IdentitySecretKey, + verification: &[u8], +) -> RelayHandshakeResult<(Vec, NtorV3XofReader)> { + let secret_key_y = SessionSecretKey::random_from_rng(rng); + server_handshake_ntor_v3_no_keygen(rng, reply_fn, &secret_key_y, message, keys, verification) +} + +/// As `server_handshake_ntor_v3`, but take a secret key instead of an RNG. +pub(crate) fn server_handshake_ntor_v3_no_keygen( + rng: &mut R, + reply_fn: &mut REPLY, + secret_key_y: &SessionSecretKey, + message: &[u8], + keys: &IdentitySecretKey, + verification: &[u8], +) -> RelayHandshakeResult<(Vec, NtorV3XofReader)> { + // Decode the message. + let mut r = Reader::from_slice(message); + let id: Ed25519Identity = r.extract()?; + let requested_pk: IdentityPublicKey = r.extract()?; + let client_pk: SessionPublicKey = r.extract()?; + let client_msg = if let Some(msg_len) = r.remaining().checked_sub(MAC_LEN) { + r.take(msg_len)? + } else { + let deficit = (MAC_LEN - r.remaining()) + .try_into() + .expect("miscalculated!"); + return Err(Error::incomplete_error(deficit).into()); + }; + + let msg_mac: MessageMac = r.extract()?; + r.should_be_exhausted()?; + + // See if we recognize the provided (id,requested_pk) pair. + let keypair = match keys.matches(id, requested_pk.pk).into() { + Some(k) => keys, + None => return Err(RelayHandshakeError::MissingKey), + }; + + let xb = keypair + .hpke(rng, &client_pk) + .map_err(|e| Error::Crypto(e.into()))?; + let (enc_key, mut mac) = kdf_msgkdf(&xb, &keypair.pk, &client_pk, verification) + .map_err(into_internal!("Can't apply ntor3 kdf."))?; + // Verify the message we received. + let computed_mac: DigestVal = { + mac.write(client_msg) + .map_err(into_internal!("Can't compute MAC input."))?; + mac.take().finalize().into() + }; + let y_pk = SessionPublicKey::from(secret_key_y); + let xy = secret_key_y.hpke(rng, &client_pk)?; + + let mut okay = computed_mac.ct_eq(&msg_mac) + & ct::bool_to_choice(xy.was_contributory()) + & ct::bool_to_choice(xb.was_contributory()); + + let plaintext_msg = decrypt(&enc_key, client_msg); + + // Handle the message and decide how to reply. + let reply = reply_fn.reply(&plaintext_msg); + + // It's not exactly constant time to use is_some() and + // unwrap_or_else() here, but that should be somewhat + // hidden by the rest of the computation. + okay &= ct::bool_to_choice(reply.is_some()); + let reply = reply.unwrap_or_default(); + + // If we reach this point, we are actually replying, or pretending + // that we're going to reply. + + let secret_input = { + let mut si = SecretBuf::new(); + si.write(&xy.as_bytes()) + .and_then(|_| si.write(&xb.as_bytes())) + .and_then(|_| si.write(&keypair.pk.id)) + .and_then(|_| si.write(&keypair.pk.pk.as_bytes())) + .and_then(|_| si.write(&client_pk.as_bytes())) + .and_then(|_| si.write(&y_pk.as_bytes())) + .and_then(|_| si.write(PROTOID)) + .and_then(|_| si.write(&Encap(verification))) + .map_err(into_internal!("can't derive ntor3 secret_input"))?; + si + }; + let ntor_key_seed = h_key_seed(&secret_input); + let verify = h_verify(&secret_input); + + let (enc_key, keystream) = { + let mut xof = DigestWriter(Shake256::default()); + xof.write(&T_FINAL) + .and_then(|_| xof.write(&ntor_key_seed)) + .map_err(into_internal!("can't generate ntor3 xof."))?; + let mut r = xof.take().finalize_xof(); + let mut enc_key = Zeroizing::new([0_u8; ENC_KEY_LEN]); + r.read(&mut enc_key[..]); + (enc_key, r) + }; + let encrypted_reply = encrypt(&enc_key, &reply); + let auth: DigestVal = { + let mut auth = DigestWriter(Sha3_256::default()); + auth.write(&T_AUTH) + .and_then(|_| auth.write(&verify)) + .and_then(|_| auth.write(&keypair.pk.id)) + .and_then(|_| auth.write(&keypair.pk.pk.as_bytes())) + .and_then(|_| auth.write(&y_pk.as_bytes())) + .and_then(|_| auth.write(&client_pk.as_bytes())) + .and_then(|_| auth.write(&msg_mac)) + .and_then(|_| auth.write(&Encap(&encrypted_reply))) + .and_then(|_| auth.write(PROTOID)) + .and_then(|_| auth.write(&b"Server"[..])) + .map_err(into_internal!("can't derive ntor3 authentication"))?; + auth.take().finalize().into() + }; + + let reply = { + let mut reply = Vec::new(); + reply + .write(&y_pk.as_bytes()) + .and_then(|_| reply.write(&auth)) + .and_then(|_| reply.write(&encrypted_reply)) + .map_err(into_internal!("can't encode ntor3 reply."))?; + reply + }; + + if okay.into() { + Ok((reply, NtorV3XofReader::new(keystream))) + } else { + Err(RelayHandshakeError::BadClientHandshake) + } +} diff --git a/crates/o5/src/handshake_old/integration.rs b/crates/o5/src/handshake_old/integration.rs deleted file mode 100644 index 6dc00f5..0000000 --- a/crates/o5/src/handshake_old/integration.rs +++ /dev/null @@ -1,297 +0,0 @@ -#![allow(non_snake_case)] // to enable variable names matching the spec. -#![allow(clippy::many_single_char_names)] // ibid - -// @@ begin test lint list maintained by maint/add_warning @@ -#![allow(clippy::bool_assert_comparison)] -#![allow(clippy::clone_on_copy)] -#![allow(clippy::dbg_macro)] -#![allow(clippy::print_stderr)] -#![allow(clippy::print_stdout)] -#![allow(clippy::single_char_pattern)] -#![allow(clippy::unwrap_used)] -#![allow(clippy::unchecked_duration_subtraction)] -#![allow(clippy::useless_vec)] -#![allow(clippy::needless_pass_by_value)] -//! - -use super::*; -use crate::common::ntor_arti::{ClientHandshake, ServerHandshake}; - -use hex_literal::hex; -use tor_basic_utils::test_rng::testing_rng; -use digest::XofReader; - - - -#[test] -fn test_obfs4_roundtrip() { - let mut rng = rand::thread_rng(); - let relay_private = O5NtorSecretKey::generate_for_test(&mut testing_rng()); - - let verification = &b"shared secret"[..]; - let client_message = &b"Hello. I am a client. Let's be friends!"[..]; - let relay_message = &b"Greetings, client. I am a robot. Beep boop."[..]; - - let (c_state, c_handshake) = - client_handshake_obfs4(&mut rng, &relay_private.pk, client_message, verification) - .unwrap(); - - struct Rep(Vec, Vec); - impl MsgReply for Rep { - fn reply(&mut self, msg: &[u8]) -> Option> { - self.0 = msg.to_vec(); - Some(self.1.clone()) - } - } - let mut rep = Rep(Vec::new(), relay_message.to_vec()); - - let (s_handshake, mut s_keygen) = server_handshake_obfs4( - &mut rng, - &mut rep, - &c_handshake, - &[relay_private], - verification, - ) - .unwrap(); - - let (s_msg, mut c_keygen) = - client_handshake_obfs4_part2(&c_state, &s_handshake, verification).unwrap(); - - assert_eq!(rep.0[..], client_message[..]); - assert_eq!(s_msg[..], relay_message[..]); - let mut s_keys = [0_u8; 100]; - let mut c_keys = [0_u8; 1000]; - s_keygen.read(&mut s_keys); - c_keygen.read(&mut c_keys); - assert_eq!(s_keys[..], c_keys[..100]); -} - -// Same as previous test, but use the higher-level APIs instead. -#[test] -fn test_obfs4_roundtrip_highlevel() { - let mut rng = rand::thread_rng(); - let relay_private = O5NtorSecretKey::generate_for_test(&mut testing_rng()); - - let (c_state, c_handshake) = - Obfs4NtorClient::client1(&mut rng, &relay_private.pk, &[]).unwrap(); - - let mut rep = |_: &[NtorV3Extension]| Some(vec![]); - - let (s_keygen, s_handshake) = - Obfs4NtorServer::server(&mut rng, &mut rep, &[relay_private], &c_handshake).unwrap(); - - let (extensions, keygen) = Obfs4NtorClient::client2(c_state, s_handshake).unwrap(); - - assert!(extensions.is_empty()); - let c_keys = keygen.expand(1000).unwrap(); - let s_keys = s_keygen.expand(100).unwrap(); - assert_eq!(s_keys[..], c_keys[..100]); -} - -// Same as previous test, but encode some congestion control extensions. -#[test] -fn test_obfs4_roundtrip_highlevel_cc() { - let mut rng = rand::thread_rng(); - let relay_private = O5NtorSecretKey::generate_for_test(&mut testing_rng()); - - let client_exts = vec![NtorV3Extension::RequestCongestionControl]; - let reply_exts = vec![NtorV3Extension::AckCongestionControl { sendme_inc: 42 }]; - - let (c_state, c_handshake) = Obfs4NtorClient::client1( - &mut rng, - &relay_private.pk, - &[NtorV3Extension::RequestCongestionControl], - ) - .unwrap(); - - let mut rep = |msg: &[NtorV3Extension]| -> Option> { - assert_eq!(msg, client_exts); - Some(reply_exts.clone()) - }; - - let (s_keygen, s_handshake) = - Obfs4NtorServer::server(&mut rng, &mut rep, &[relay_private], &c_handshake).unwrap(); - - let (extensions, keygen) = Obfs4NtorClient::client2(c_state, s_handshake).unwrap(); - - assert_eq!(extensions, reply_exts); - let c_keys = keygen.expand(1000).unwrap(); - let s_keys = s_keygen.expand(100).unwrap(); - assert_eq!(s_keys[..], c_keys[..100]); -} - -#[test] -fn test_obfs4_testvec() { - let id = hex!("9fad2af287ef942632833d21f946c6260c33fae6172b60006e86e4a6911753a2"); - let b = hex!("a8649010896d3c05ab0e2ab75e3e9368695c8f72652e8aa73016756007054e59"); // identity key - let x = hex!("f886d140047a115b228a8f7f63cbc5a3ad74e9c970ad3cb4a7f7fd8067f0dd68"); // client session key - let y = hex!("403ec0927a8852bdff12129244fdb03cb3c94b8b8d15c863462fcda52b510d73"); // server session key - let b: curve25519::StaticSecret = b.into(); - let B: curve25519::PublicKey = (&b).into(); - let id: Ed25519Identity = id.into(); - let x: curve25519::StaticSecret = x.into(); - let y: curve25519::StaticSecret = y.into(); - - let client_message = hex!("68656c6c6f20776f726c64"); - let verification = hex!("78797a7a79"); - let server_message = hex!("486f6c61204d756e646f"); - - let identity_public = O5NtorPublicKey { pk: B, id, rp: None }; - let identity_private = O5NtorSecretKey { - sk: b, - pk: identity_public.clone(), - }; - - let (state, client_handshake) = - client_handshake_obfs4_no_keygen(&identity_public, &client_message, &verification, x) - .unwrap(); - - // assert_eq!(client_handshake[..], hex!("9fad2af287ef942632833d21f946c6260c33fae6172b60006e86e4a6911753a2f8307a2bc1870b00b828bb74dbb8fd88e632a6375ab3bcd1ae706aaa8b6cdd1d252fe9ae91264c91d4ecb8501f79d0387e34ad8ca0f7c995184f7d11d5da4f463bebd9151fd3b47c180abc9e044d53565f04d82bbb3bebed3d06cea65db8be9c72b68cd461942088502f67")[..]); - - struct Replier(Vec, Vec, bool); - impl MsgReply for Replier { - fn reply(&mut self, msg: &[u8]) -> Option> { - assert_eq!(msg, &self.0); - self.2 = true; - Some(self.1.clone()) - } - } - let mut rep = Replier(client_message.to_vec(), server_message.to_vec(), false); - - let (server_handshake, mut server_keygen) = server_handshake_obfs4_no_keygen( - &mut rep, - &y, - &client_handshake, - &[identity_private], - &verification, - ) - .unwrap(); - assert!(rep.2); - - // assert_eq!(server_handshake[..], hex!("4bf4814326fdab45ad5184f5518bd7fae25dc59374062698201a50a22954246d2fc5f8773ca824542bc6cf6f57c7c29bbf4e5476461ab130c5b18ab0a91276651202c3e1e87c0d32054c")[..]); - - let (server_msg_received, mut client_keygen) = - client_handshake_obfs4_part2(&state, &server_handshake, &verification).unwrap(); - assert_eq!(&server_msg_received, &server_message); - - let (c_keys, s_keys) = { - let mut c = [0_u8; 256]; - let mut s = [0_u8; 256]; - client_keygen.read(&mut c); - server_keygen.read(&mut s); - (c, s) - }; - assert_eq!(c_keys, s_keys); - assert_eq!(c_keys[..], hex!("05b858d18df21a01566c74d39a5b091b4415f103c05851e77e79b274132dc5b5")[..]); - // assert_eq!(c_keys[..], hex!("9c19b631fd94ed86a817e01f6c80b0743a43f5faebd39cfaa8b00fa8bcc65c3bfeaa403d91acbd68a821bf6ee8504602b094a254392a07737d5662768c7a9fb1b2814bb34780eaee6e867c773e28c212ead563e98a1cd5d5b4576f5ee61c59bde025ff2851bb19b721421694f263818e3531e43a9e4e3e2c661e2ad547d8984caa28ebecd3e4525452299be26b9185a20a90ce1eac20a91f2832d731b54502b09749b5a2a2949292f8cfcbeffb790c7790ed935a9d251e7e336148ea83b063a5618fcff674a44581585fd22077ca0e52c59a24347a38d1a1ceebddbf238541f226b8f88d0fb9c07a1bcd2ea764bbbb5dacdaf5312a14c0b9e4f06309b0333b4a")[..]); -} - -#[test] -fn about_half() -> Result<()> { - let mut rng = rand::thread_rng(); - - let mut success = 0; - let mut not_found = 0; - let mut not_match = 0; - for _ in 0..1_000 { - - let sk = curve25519::StaticSecret::random_from_rng(&mut rng); - let rp: Option= (&sk).into(); - let repres = match rp { - Some(r) => r, - None => { - not_found += 1; - continue; - } - }; - - let pk = curve25519::PublicKey::from(&sk); - - - let decoded_pk = curve25519::PublicKey::from(&repres); - if hex::encode(pk) != hex::encode(decoded_pk) { - not_match += 1; - continue; - } - success += 1; - } - - if not_match != 0 { - println!("{not_found}/{not_match}/{success}/10_000"); - assert_eq!(not_match, 0); - } - assert!(not_found < 600); - assert!(not_found > 400); - Ok(()) -} - -#[test] -fn keypair() -> Result<()> { - let mut rng = rand::thread_rng(); - for _ in 0..1_000 { - let kp = O5NtorSecretKey::generate_for_test(&mut rng); - - let pk = kp.pk.pk.to_bytes(); - let repres = kp.pk.rp; - - let pubkey = curve25519::PublicKey::from(&repres.unwrap()); - assert_eq!(hex::encode(pk), hex::encode(pubkey.to_bytes())); - } - Ok(()) -} - - -/* -// Benchmark Client/Server handshake. The actual time taken that will be -// observed on either the Client or Server is half the reported time per -// operation since the benchmark does both sides. -func BenchmarkHandshake(b *testing.B) { - // Generate the "long lasting" identity key and NodeId. - idKeypair, err := NewKeypair(false) - if err != nil || idKeypair == nil { - b.Fatal("Failed to generate identity keypair") - } - nodeID, err := NewNodeID([]byte("\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13")) - if err != nil { - b.Fatal("Failed to load NodeId:", err) - } - b.ResetTimer() - - // Start the actual benchmark. - for i := 0; i < b.N; i++ { - // Generate the keypairs. - serverKeypair, err := NewKeypair(true) - if err != nil || serverKeypair == nil { - b.Fatal("Failed to generate server keypair") - } - - clientKeypair, err := NewKeypair(true) - if err != nil || clientKeypair == nil { - b.Fatal("Failed to generate client keypair") - } - - // Server handshake. - clientPublic := clientKeypair.Representative().ToPublic() - ok, serverSeed, serverAuth := ServerHandshake(clientPublic, - serverKeypair, idKeypair, nodeID) - if !ok || serverSeed == nil || serverAuth == nil { - b.Fatal("ServerHandshake failed") - } - - // Client handshake. - serverPublic := serverKeypair.Representative().ToPublic() - ok, clientSeed, clientAuth := ClientHandshake(clientKeypair, - serverPublic, idKeypair.Public(), nodeID) - if !ok || clientSeed == nil || clientAuth == nil { - b.Fatal("ClientHandshake failed") - } - - // Validate the authenticator. Real code would pass the AUTH read off - // the network as a slice to CompareAuth here. - if !CompareAuth(clientAuth, serverAuth.Bytes()[:]) || - !CompareAuth(serverAuth, clientAuth.Bytes()[:]) { - b.Fatal("AUTH mismatched between client/server") - } - } -} -*/ diff --git a/crates/o5/src/handshake_old/mod.rs b/crates/o5/src/handshake_old/mod.rs deleted file mode 100644 index 30b2330..0000000 --- a/crates/o5/src/handshake_old/mod.rs +++ /dev/null @@ -1,774 +0,0 @@ -//! Implements the ntor v3 key exchange, as described in proposal 332. -//! -//! The main difference between the ntor v3r handshake and the -//! original ntor handshake is that this this one allows each party to -//! encrypt data (without forward secrecy) after it sends the first -//! message. - -// TODO: -// Remove the "allow" item for dead_code. -// Make terminology and variable names consistent with spec. - -// This module is still unused: so allow some dead code for now. -#![allow(dead_code)] - -use std::borrow::Borrow; - -use crate::common::ntor_arti::{KeyGenerator, RelayHandshakeError, RelayHandshakeResult}; -use crate::common::ct; -use crate::common::curve25519; -use crate::{Error, Result}; -use tor_bytes::{EncodeResult, Reader, SecretBuf, Writeable, Writer}; -use tor_error::into_internal; -use tor_llcrypto::d::{Sha256, Shake256, Shake256Reader}; -use tor_llcrypto::pk::ed25519::Ed25519Identity; -use tor_llcrypto::util::ct::ct_lookup; - -use cipher::{KeyIvInit, StreamCipher}; - -use rand_core::{CryptoRng, RngCore}; -use subtle::{Choice, ConstantTimeEq}; -use tor_cell::relaycell::extend::NtorV3Extension; -use tor_llcrypto::cipher::aes::Aes256Ctr; -use zeroize::Zeroizing; - -/// The verification string to be used for circuit extension. -const OBFS4_CIRC_VERIFICATION: &[u8] = b"circuit extend"; - -/// The size of an encryption key in bytes. -const ENC_KEY_LEN: usize = 32; -/// The size of a MAC key in bytes. -const MAC_KEY_LEN: usize = 32; -/// The size of a curve25519 public key in bytes. -const PUB_KEY_LEN: usize = 32; -/// The size of a digest output in bytes. -const DIGEST_LEN: usize = 32; -/// The length of a MAC output in bytes. -const MAC_LEN: usize = 32; -/// The length of a node identity in bytes. -const ID_LEN: usize = 32; - -/// The output of the digest, as an array. -type DigestVal = [u8; DIGEST_LEN]; -/// The output of the MAC. -type MacVal = [u8; MAC_LEN]; -/// A key for symmetric encryption or decryption. -// -// TODO (nickm): Any move operations applied to this key could subvert the zeroizing. -type EncKey = Zeroizing<[u8; ENC_KEY_LEN]>; -/// A key for message authentication codes. -type MacKey = [u8; MAC_KEY_LEN]; - -/// Opaque wrapper type for Obfs4Ntor's hash reader. -struct Obfs4NtorXofReader(Shake256Reader); - -impl digest::XofReader for Obfs4NtorXofReader { - fn read(&mut self, buffer: &mut [u8]) { - self.0.read(buffer); - } -} - -/// An encapsulated value for passing as input to a MAC, digest, or -/// KDF algorithm. -/// -/// This corresponds to the ENCAP() function in proposal 332. -struct Encap<'a>(&'a [u8]); - -impl<'a> Writeable for Encap<'a> { - fn write_onto(&self, b: &mut B) -> EncodeResult<()> { - b.write_u64(self.0.len() as u64); - b.write(self.0) - } -} - -impl<'a> Encap<'a> { - /// Return the length of the underlying data in bytes. - fn len(&self) -> usize { - self.0.len() - } - /// Return the underlying data - fn data(&self) -> &'a [u8] { - self.0 - } -} - -/// Helper to define a set of tweak values as instances of `Encap`. -macro_rules! define_tweaks { - { - $(#[$pid_meta:meta])* - PROTOID = $protoid:expr; - $( $(#[$meta:meta])* $name:ident <= $suffix:expr ; )* - } => { - $(#[$pid_meta])* - const PROTOID: &'static [u8] = $protoid.as_bytes(); - $( - $(#[$meta])* - const $name : Encap<'static> = - Encap(concat!($protoid, ":", $suffix).as_bytes()); - )* - } -} - -define_tweaks! { - - pub(crate) const PROTO_ID: &[u8; 24] = b"ntor-curve25519-sha256-1"; - - pub(crate) const T_MAC: &[u8; 28] = b"ntor-curve25519-sha256-1:mac"; - - pub(crate) const T_VERIFY: &[u8; 35] = b"ntor-curve25519-sha256-1:key_verify"; - - pub(crate) const T_KEY: &[u8; 36] = b"ntor-curve25519-sha256-1:key_extract"; - - - /// Protocol ID: concatenated with other things in the protocol to - /// prevent hash confusion. - PROTOID = "ntor3-curve25519-sha3_256-1"; - - /// Message MAC tweak: used to compute the MAC of an encrypted client - /// message. - T_MSGMAC <= "msg_mac"; - /// Message KDF tweak: used when deriving keys for encrypting and MACing - /// client message. - T_MSGKDF <= "kdf_phase1"; - /// Key seeding tweak: used to derive final KDF input from secret_input. - T_KEY_SEED <= "key_seed"; - /// Verifying tweak: used to derive 'verify' value from secret_input. - T_VERIFY <= "verify"; - /// Final KDF tweak: used to derive keys for encrypting relay message - /// and for the actual tor circuit. - T_FINAL <= "kdf_final"; - /// Authentication tweak: used to derive the final authentication - /// value for the handshake. - T_AUTH <= "auth_final"; -} - -/// Compute a tweaked hash. -fn hash(t: &Encap<'_>, data: &[u8]) -> DigestVal { - use digest::Digest; - let mut d = Sha256::new(); - d.update((t.len() as u64).to_be_bytes()); - d.update(t.data()); - d.update(data); - d.finalize().into() -} - -/// Perform a symmetric encryption operation and return the encrypted data. -/// -/// (This isn't safe to do more than once with the same key, but we never -/// do that in this protocol.) -fn encrypt(key: &EncKey, m: &[u8]) -> Vec { - let mut d = m.to_vec(); - let zero_iv = Default::default(); - let mut cipher = Aes256Ctr::new(key.as_ref().into(), &zero_iv); - cipher.apply_keystream(&mut d); - d -} -/// Perform a symmetric decryption operation and return the encrypted data. -fn decrypt(key: &EncKey, m: &[u8]) -> Vec { - encrypt(key, m) -} - -/// Wrapper around a Digest or ExtendedOutput object that lets us use it -/// as a tor_bytes::Writer. -struct DigestWriter(U); -impl tor_bytes::Writer for DigestWriter { - fn write_all(&mut self, bytes: &[u8]) { - self.0.update(bytes); - } -} -impl DigestWriter { - /// Consume this wrapper and return the underlying object. - fn take(self) -> U { - self.0 - } -} - -/// Hash tweaked with T_KEY_SEED -fn h_key_seed(d: &[u8]) -> DigestVal { - hash(&T_KEY_SEED, d) -} -/// Hash tweaked with T_VERIFY -fn h_verify(d: &[u8]) -> DigestVal { - hash(&T_VERIFY, d) -} - -/// Helper: compute the encryption key and mac_key for the client's -/// encrypted message. -/// -/// Takes as inputs `xb` (the shared secret derived from -/// diffie-hellman as Bx or Xb), the relay's public key information, -/// the client's public key (B), and the shared verification string. -fn kdf_msgkdf( - xb: &curve25519::SharedSecret, - relay_public: &O5NtorPublicKey, - client_public: &curve25519::PublicKey, - verification: &[u8], -) -> EncodeResult<(EncKey, DigestWriter)> { - // secret_input_phase1 = Bx | ID | X | B | PROTOID | ENCAP(VER) - // phase1_keys = KDF_msgkdf(secret_input_phase1) - // (ENC_K1, MAC_K1) = PARTITION(phase1_keys, ENC_KEY_LEN, MAC_KEY_LEN - use digest::{ExtendableOutput, XofReader}; - let mut msg_kdf = DigestWriter(Shake256::default()); - msg_kdf.write(&T_MSGKDF)?; - msg_kdf.write(xb.as_bytes())?; - msg_kdf.write(&relay_public.id)?; - msg_kdf.write(client_public.as_bytes())?; - msg_kdf.write(&relay_public.pk.as_bytes())?; - msg_kdf.write(PROTOID)?; - msg_kdf.write(&Encap(verification))?; - let mut r = msg_kdf.take().finalize_xof(); - let mut enc_key = Zeroizing::new([0; ENC_KEY_LEN]); - let mut mac_key = Zeroizing::new([0; MAC_KEY_LEN]); - - r.read(&mut enc_key[..]); - r.read(&mut mac_key[..]); - let mut mac = DigestWriter(Sha256::default()); - { - mac.write(&T_MSGMAC)?; - mac.write(&Encap(&mac_key[..]))?; - mac.write(&relay_public.id)?; - mac.write(&relay_public.pk.as_bytes())?; - mac.write(client_public.as_bytes())?; - } - - Ok((enc_key, mac)) -} - -/// Client side of the ntor v3 handshake. -pub(crate) struct Obfs4NtorClient; - -impl crate::common::ntor_arti::ClientHandshake for Obfs4NtorClient { - type KeyType = O5NtorPublicKey; - type StateType = O5NtorHandshakeState; - type KeyGen = Obfs4NtorKeyGenerator; - type ClientAuxData = [NtorV3Extension]; - type ServerAuxData = Vec; - - /// Generate a new client onionskin for a relay with a given onion key. - /// If any `extensions` are provided, encode them into to the onionskin. - /// - /// On success, return a state object that will be used to complete the handshake, along - /// with the message to send. - fn client1>( - rng: &mut R, - key: &O5NtorPublicKey, - extensions: &M, - ) -> Result<(Self::StateType, Vec)> { - let mut message = Vec::new(); - NtorV3Extension::write_many_onto(extensions.borrow(), &mut message) - .map_err(|e| Error::from_bytes_enc(e, "ntor3 handshake extensions"))?; - Ok( - client_handshake_obfs4(rng, key, &message, OBFS4_CIRC_VERIFICATION) - .map_err(into_internal!("Can't encode obfs4 client handshake."))?, - ) - } - - /// Handle an onionskin from a relay, and produce a key generator. - /// - /// The state object must match the one that was used to make the - /// client onionskin that the server is replying to. - fn client2>( - state: Self::StateType, - msg: T, - ) -> Result<(Vec, Self::KeyGen)> { - let (message, xofreader) = - client_handshake_obfs4_part2(&state, msg.as_ref(), OBFS4_CIRC_VERIFICATION)?; - let extensions = NtorV3Extension::decode(&message).map_err(|err| Error::CellDecodeErr { - object: "ntor v3 extensions", - err, - })?; - let keygen = Obfs4NtorKeyGenerator { reader: xofreader }; - - Ok((extensions, keygen)) - } -} - -/// Server side of the ntor v3 handshake. -pub(crate) struct Obfs4NtorServer; - -impl crate::common::ntor_arti::ServerHandshake for Obfs4NtorServer { - type KeyType = O5NtorSecretKey; - type KeyGen = Obfs4NtorKeyGenerator; - type ClientAuxData = [NtorV3Extension]; - type ServerAuxData = Vec; - - fn server, T: AsRef<[u8]>>( - rng: &mut R, - reply_fn: &mut REPLY, - key: &[Self::KeyType], - msg: T, - ) -> RelayHandshakeResult<(Self::KeyGen, Vec)> { - let mut bytes_reply_fn = |bytes: &[u8]| -> Option> { - let client_exts = NtorV3Extension::decode(bytes).ok()?; - let reply_exts = reply_fn.reply(&client_exts)?; - let mut out = vec![]; - NtorV3Extension::write_many_onto(&reply_exts, &mut out).ok()?; - Some(out) - }; - - let (res, reader) = server_handshake_obfs4( - rng, - &mut bytes_reply_fn, - msg.as_ref(), - key, - OBFS4_CIRC_VERIFICATION, - )?; - Ok((Obfs4NtorKeyGenerator { reader }, res)) - } -} - -/// Key information about a relay used for the ntor v3 handshake. -/// -/// Contains a single curve25519 ntor onion key, and the relay's ed25519 -/// identity. -#[derive(Clone, Debug)] -pub(crate) struct O5NtorPublicKey { - /// The relay's identity. - pub(crate) id: Ed25519Identity, - /// The Bridge's identity key. - pub(crate) pk: curve25519::PublicKey, - /// The Elligator2 representative for the public key - pub(crate) rp: Option, -} - -/// Secret key information used by a relay for the ntor v3 handshake. -pub(crate) struct O5NtorSecretKey { - /// The relay's public key information - pk: O5NtorPublicKey, - /// The secret onion key. - sk: curve25519::StaticSecret, -} - -impl O5NtorSecretKey { - /// Construct a new O5NtorSecretKey from its components. - #[allow(unused)] - pub(crate) fn new( - sk: curve25519::StaticSecret, - pk: curve25519::PublicKey, - rp: Option, - id: Ed25519Identity, - ) -> Self { - Self { - pk: O5NtorPublicKey { id, pk, rp }, - sk, - } - } - - /// Generate a key using the given `rng`, suitable for testing. - #[cfg(test)] - pub(crate) fn generate_for_test(mut rng: R) -> Self { - let mut id = [0_u8; 32]; - // Random bytes will work for testing, but aren't necessarily actually a valid id. - rng.fill_bytes(&mut id); - - let mut sk: curve25519::StaticSecret = [0u8;32].into(); - let mut pk1: curve25519::PublicKey = [0u8;32].into(); - let mut rp: Option = None; - - for _ in 0..64 { // artificial ceil of 64 so this can't infinite loop - - // approx 50% of keys do not have valid representatives so we just - // iterate until we find a key where it is valid. This should take - // a low number of iteratations and always succeed eventually. - sk = curve25519::StaticSecret::random_from_rng(&mut rng); - rp = (&sk).into(); - if rp.is_none() { - continue - } - pk1 = (&sk).into(); - break - } - - let pk = O5NtorPublicKey { - pk: pk1, - id: id.into(), - rp, - }; - Self { pk, sk } - } - - /// Checks whether `id` and `pk` match this secret key. - /// - /// Used to perform a constant-time secret key lookup. - fn matches(&self, id: Ed25519Identity, pk: curve25519::PublicKey) -> Choice { - // TODO: use similar pattern in ntor_v1! - id.as_bytes().ct_eq(self.pk.id.as_bytes()) & pk.as_bytes().ct_eq(self.pk.pk.as_bytes()) - } -} - -/// Client state for the ntor v3 handshake. -/// -/// The client needs to hold this state between when it sends its part -/// of the handshake and when it receives the relay's reply. -pub(crate) struct O5NtorHandshakeState { - /// The public key of the relay we're communicating with. - relay_public: O5NtorPublicKey, // B, ID. - /// Our ephemeral secret key for this handshake. - my_sk: curve25519::StaticSecret, // x - /// Our ephemeral public key for this handshake. - my_public: curve25519::PublicKey, // X - - /// The shared secret generated as Bx or Xb. - shared_secret: curve25519::SharedSecret, // Bx - /// The MAC of our original encrypted message. - msg_mac: MacVal, // msg_mac -} - -/// A key generator returned from an ntor v3 handshake. -pub(crate) struct Obfs4NtorKeyGenerator { - /// The underlying `digest::XofReader`. - reader: Obfs4NtorXofReader, -} - -impl KeyGenerator for Obfs4NtorKeyGenerator { - fn expand(mut self, keylen: usize) -> Result { - use digest::XofReader; - let mut ret: SecretBuf = vec![0; keylen].into(); - self.reader.read(ret.as_mut()); - Ok(ret) - } -} - -/// Client-side Ntor version 3 handshake, part one. -/// -/// Given a secure `rng`, a relay's public key, a secret message to send, -/// and a shared verification string, generate a new handshake state -/// and a message to send to the relay. -fn client_handshake_obfs4( - rng: &mut R, - relay_public: &O5NtorPublicKey, - client_msg: &[u8], - verification: &[u8], -) -> EncodeResult<(O5NtorHandshakeState, Vec)> { - let my_sk = curve25519::StaticSecret::random_from_rng(rng); - client_handshake_obfs4_no_keygen(relay_public, client_msg, verification, my_sk) -} - -/// As `client_handshake_obfs4`, but don't generate an ephemeral DH -/// key: instead take that key an arguments `my_sk`. -fn client_handshake_obfs4_no_keygen( - relay_public: &O5NtorPublicKey, - client_msg: &[u8], - verification: &[u8], - my_sk: curve25519::StaticSecret, -) -> EncodeResult<(O5NtorHandshakeState, Vec)> { - let my_public = curve25519::PublicKey::from(&my_sk); - let bx = my_sk.diffie_hellman(&relay_public.pk); - - let (enc_key, mut mac) = kdf_msgkdf(&bx, relay_public, &my_public, verification)?; - - //encrypted_msg = ENC(ENC_K1, CM) - // msg_mac = MAC_msgmac(MAC_K1, ID | B | X | encrypted_msg) - let encrypted_msg = encrypt(&enc_key, client_msg); - let msg_mac: DigestVal = { - use digest::Digest; - mac.write(&encrypted_msg)?; - mac.take().finalize().into() - }; - - let mut message = Vec::new(); - message.write(&relay_public.id)?; - message.write(&relay_public.pk.as_bytes())?; - message.write(&my_public.as_bytes())?; - message.write(&encrypted_msg)?; - message.write(&msg_mac)?; - - let state = O5NtorHandshakeState { - relay_public: relay_public.clone(), - my_sk, - my_public, - shared_secret: bx, - msg_mac, - }; - - Ok((state, message)) -} - -/// Trait for an object that handle and incoming client message and -/// return a server's reply. -/// -/// This is implemented for `FnMut(&[u8]) -> Option>` automatically. -pub(crate) trait MsgReply { - /// Given a message received from a client, parse it and decide - /// how (and whether) to reply. - /// - /// Return None if the handshake should fail. - fn reply(&mut self, msg: &[u8]) -> Option>; -} - -impl MsgReply for F -where - F: FnMut(&[u8]) -> Option>, -{ - fn reply(&mut self, msg: &[u8]) -> Option> { - self(msg) - } -} - -/// Complete an ntor v3 handshake as a server. -/// -/// Use the provided `rng` to generate keys; use the provided -/// `reply_fn` to handle incoming client secret message and decide how -/// to reply. The client's handshake is in `message`. Our private -/// key(s) are in `keys`. The `verification` string must match the -/// string provided by the client. -/// -/// On success, return the server handshake message to send, and an XofReader -/// to use in generating circuit keys. -fn server_handshake_obfs4( - rng: &mut RNG, - reply_fn: &mut REPLY, - message: &[u8], - keys: &[O5NtorSecretKey], - verification: &[u8], -) -> RelayHandshakeResult<(Vec, Obfs4NtorXofReader)> { - let secret_key_y = curve25519::StaticSecret::random_from_rng(rng); - server_handshake_obfs4_no_keygen(reply_fn, &secret_key_y, message, keys, verification) -} - -/// As `server_handshake_obfs4`, but take a secret key instead of an RNG. -fn server_handshake_obfs4_no_keygen( - reply_fn: &mut REPLY, - secret_key_y: &curve25519::StaticSecret, - message: &[u8], - keys: &[O5NtorSecretKey], - verification: &[u8], -) -> RelayHandshakeResult<(Vec, Obfs4NtorXofReader)> { - // Decode the message. - let mut r = Reader::from_slice(message); - let id: Ed25519Identity = r.extract()?; - - let pk_buf: [u8;32] = r.extract()?; - let requested_pk = curve25519::PublicKey::from(pk_buf); - let pk_buf: [u8;32] = r.extract()?; - let client_pk = curve25519::PublicKey::from(pk_buf); - let client_msg = if let Some(msg_len) = r.remaining().checked_sub(MAC_LEN) { - r.take(msg_len)? - } else { - return Err(tor_bytes::Error::Truncated.into()); - }; - let msg_mac: MacVal = r.extract()?; - r.should_be_exhausted()?; - - // See if we recognize the provided (id,requested_pk) pair. - let keypair = ct_lookup(keys, |key| key.matches(id, requested_pk)); - let keypair = match keypair { - Some(k) => k, - None => return Err(RelayHandshakeError::MissingKey), - }; - - let xb = keypair.sk.diffie_hellman(&client_pk); - let (enc_key, mut mac) = kdf_msgkdf(&xb, &keypair.pk, &client_pk, verification) - .map_err(into_internal!("Can't apply obfs4 kdf."))?; - // Verify the message we received. - let computed_mac: DigestVal = { - use digest::Digest; - mac.write(client_msg) - .map_err(into_internal!("Can't compute MAC input."))?; - mac.take().finalize().into() - }; - let y_pk: curve25519::PublicKey = (secret_key_y).into(); - let xy = secret_key_y.diffie_hellman(&client_pk); - - let mut okay = computed_mac.ct_eq(&msg_mac) - & ct::bool_to_choice(xy.was_contributory()) - & ct::bool_to_choice(xb.was_contributory()); - - let plaintext_msg = decrypt(&enc_key, client_msg); - - // Handle the message and decide how to reply. - let reply = reply_fn.reply(&plaintext_msg); - - // It's not exactly constant time to use is_some() and - // unwrap_or_else() here, but that should be somewhat - // hidden by the rest of the computation. - okay &= ct::bool_to_choice(reply.is_some()); - let reply = reply.unwrap_or_default(); - - // If we reach this point, we are actually replying, or pretending - // that we're going to reply. - - let secret_input = { - let mut si = SecretBuf::new(); - si.write(&xy.as_bytes()) - .and_then(|_| si.write(&xb.as_bytes())) - .and_then(|_| si.write(&keypair.pk.id)) - .and_then(|_| si.write(&keypair.pk.pk.as_bytes())) - .and_then(|_| si.write(&client_pk.as_bytes())) - .and_then(|_| si.write(&y_pk.as_bytes())) - .and_then(|_| si.write(PROTOID)) - .and_then(|_| si.write(&Encap(verification))) - .map_err(into_internal!("can't derive obfs4 secret_input"))?; - si - }; - let ntor_key_seed = h_key_seed(&secret_input); - let verify = h_verify(&secret_input); - - let (enc_key, keystream) = { - use digest::{ExtendableOutput, XofReader}; - let mut xof = DigestWriter(Shake256::default()); - xof.write(&T_FINAL) - .and_then(|_| xof.write(&ntor_key_seed)) - .map_err(into_internal!("can't generate obfs4 xof."))?; - let mut r = xof.take().finalize_xof(); - let mut enc_key = Zeroizing::new([0_u8; ENC_KEY_LEN]); - r.read(&mut enc_key[..]); - (enc_key, r) - }; - let encrypted_reply = encrypt(&enc_key, &reply); - let auth: DigestVal = { - use digest::Digest; - let mut auth = DigestWriter(Sha256::default()); - auth.write(&T_AUTH) - .and_then(|_| auth.write(&verify)) - .and_then(|_| auth.write(&keypair.pk.id)) - .and_then(|_| auth.write(&keypair.pk.pk.as_bytes())) - .and_then(|_| auth.write(&y_pk.as_bytes())) - .and_then(|_| auth.write(&client_pk.as_bytes())) - .and_then(|_| auth.write(&msg_mac)) - .and_then(|_| auth.write(&Encap(&encrypted_reply))) - .and_then(|_| auth.write(PROTOID)) - .and_then(|_| auth.write(&b"Server"[..])) - .map_err(into_internal!("can't derive obfs4 authentication"))?; - auth.take().finalize().into() - }; - - let reply = { - let mut reply = Vec::new(); - reply - .write(&y_pk.as_bytes()) - .and_then(|_| reply.write(&auth)) - .and_then(|_| reply.write(&encrypted_reply)) - .map_err(into_internal!("can't encode obfs4 reply."))?; - reply - }; - - if okay.into() { - Ok((reply, Obfs4NtorXofReader(keystream))) - } else { - Err(RelayHandshakeError::BadClientHandshake) - } -} - -/// Finalize the handshake on the client side. -/// -/// Called after we've received a message from the relay: try to -/// complete the handshake and verify its correctness. -/// -/// On success, return the server's reply to our original encrypted message, -/// and an `XofReader` to use in generating circuit keys. -fn client_handshake_obfs4_part2( - state: &O5NtorHandshakeState, - relay_handshake: &[u8], - verification: &[u8], -) -> Result<(Vec, Obfs4NtorXofReader)> { - let mut reader = Reader::from_slice(relay_handshake); - let pk_buf: [u8;32] = reader - .extract() - .map_err(|e| Error::from_bytes_err(e, "v3 ntor handshake"))?; - let y_pk = curve25519::PublicKey::from(pk_buf); - let auth: DigestVal = reader - .extract() - .map_err(|e| Error::from_bytes_err(e, "v3 ntor handshake"))?; - let encrypted_msg = reader.into_rest(); - - // TODO: Some of this code is duplicated from the server handshake code! It - // would be better to factor it out. - let yx = state.my_sk.diffie_hellman(&y_pk); - let secret_input = { - let mut si = SecretBuf::new(); - si.write(&yx.as_bytes()) - .and_then(|_| si.write(&state.shared_secret.as_bytes())) - .and_then(|_| si.write(&state.relay_public.id)) - .and_then(|_| si.write(&state.relay_public.pk.as_bytes())) - .and_then(|_| si.write(&state.my_public.as_bytes())) - .and_then(|_| si.write(&y_pk.as_bytes())) - .and_then(|_| si.write(PROTOID)) - .and_then(|_| si.write(&Encap(verification))) - .map_err(into_internal!("error encoding obfs4 secret_input"))?; - si - }; - let ntor_key_seed = h_key_seed(&secret_input); - let verify = h_verify(&secret_input); - - let computed_auth: DigestVal = { - use digest::Digest; - let mut auth = DigestWriter(Sha256::default()); - auth.write(&T_AUTH) - .and_then(|_| auth.write(&verify)) - .and_then(|_| auth.write(&state.relay_public.id)) - .and_then(|_| auth.write(&state.relay_public.pk.as_bytes())) - .and_then(|_| auth.write(&y_pk.as_bytes())) - .and_then(|_| auth.write(&state.my_public.as_bytes())) - .and_then(|_| auth.write(&state.msg_mac)) - .and_then(|_| auth.write(&Encap(encrypted_msg))) - .and_then(|_| auth.write(PROTOID)) - .and_then(|_| auth.write(&b"Server"[..])) - .map_err(into_internal!("error encoding obfs4 authentication input"))?; - auth.take().finalize().into() - }; - - let okay = computed_auth.ct_eq(&auth) - & ct::bool_to_choice(yx.was_contributory()) - & ct::bool_to_choice(state.shared_secret.was_contributory()); - - let (enc_key, keystream) = { - use digest::{ExtendableOutput, XofReader}; - let mut xof = DigestWriter(Shake256::default()); - xof.write(&T_FINAL) - .and_then(|_| xof.write(&ntor_key_seed)) - .map_err(into_internal!("error encoding obfs4 xof input"))?; - let mut r = xof.take().finalize_xof(); - let mut enc_key = Zeroizing::new([0_u8; ENC_KEY_LEN]); - r.read(&mut enc_key[..]); - println!("{}", hex::encode(&enc_key)); - (enc_key, r) - }; - let server_reply = decrypt(&enc_key, encrypted_msg); - - if okay.into() { - Ok((server_reply, Obfs4NtorXofReader(keystream))) - } else { - Err(Error::BadCircHandshakeAuth) - } -} - -fn derive_ntor_shared( - secret_input: impl AsRef<[u8]>, - id: &ID, - b: &PublicKey, - x: &PublicKey, - y: &PublicKey, -) -> (KeySeed, Auth) { - let mut key_seed = KeySeed::default(); - let mut auth = Auth::default(); - - let mut message = secret_input.as_ref().to_vec(); - message.append(&mut b.to_bytes().to_vec()); - message.append(&mut x.to_bytes().to_vec()); - message.append(&mut y.to_bytes().to_vec()); - message.append(&mut PROTO_ID.to_vec()); - message.append(&mut id.to_bytes().to_vec()); - - let mut h = HmacSha256::new_from_slice(&T_KEY[..]).unwrap(); - h.update(message.as_ref()); - let tmp: &[u8] = &h.finalize().into_bytes()[..]; - key_seed.0 = tmp.try_into().expect("unable to write key_seed"); - - let mut h = HmacSha256::new_from_slice(&T_VERIFY[..]).unwrap(); - h.update(message.as_ref()); - let mut verify = h.finalize().into_bytes().to_vec(); - - // auth_input = verify | ID | B | Y | X | PROTOID | "Server" - verify.append(&mut message.to_vec()); - verify.append(&mut b"Server".to_vec()); - let mut h = HmacSha256::new_from_slice(&T_MAC[..]).unwrap(); - h.update(verify.as_ref()); - let mut tmp = &h.finalize().into_bytes()[..]; - auth.0 = tmp.try_into().expect("unable to write auth"); - - (key_seed, auth) -} - -#[cfg(test)] -mod integration; diff --git a/crates/o5/src/lib.rs b/crates/o5/src/lib.rs index ab7f616..c584223 100644 --- a/crates/o5/src/lib.rs +++ b/crates/o5/src/lib.rs @@ -2,10 +2,9 @@ pub mod client; pub mod common; -pub mod server; - pub mod framing; pub mod proto; +pub mod server; pub use client::{Client, ClientBuilder}; pub use server::{Server, ServerBuilder}; @@ -17,12 +16,12 @@ pub(crate) mod sessions; mod testing; mod pt; -pub use pt::{O5PT, Transport}; +pub use pt::{Transport, O5PT}; mod error; pub use error::{Error, Result}; -pub const OBFS4_NAME: &str = "obfs4"; +pub const TRANSPORT_NAME: &str = "o5"; #[cfg(test)] pub(crate) mod test_utils; @@ -34,12 +33,13 @@ pub mod dev { /// Client obfs4 arguments based on pre-generated dev key `DEV_PRIV_KEY`. pub const CLIENT_ARGS: &str = - "cert=AAAAAAAAAAAAAAAAAAAAAAAAAADTSFvsGKxNFPBcGdOCBSgpEtJInG9zCYZezBPVBuBWag;iat-mode=0"; + "cert=AAAAAAAAAAAAAAAAAAAAAAAAAADTSFvsGKxNFPBcGdOCBSgpEtJInG9zCYZezBPVBuBWag"; /// Server obfs4 arguments based on pre-generated dev key `DEV_PRIV_KEY`. - pub const SERVER_ARGS: &str = "drbg-seed=0a0b0c0d0e0f0a0b0c0d0e0f0a0b0c0d0e0f0a0b0c0d0e0f;node-id=0000000000000000000000000000000000000000;private-key=3031323334353637383961626364656666656463626139383736353433323130;iat-mode=0"; + pub const SERVER_ARGS: &str = "drbg-seed=0a0b0c0d0e0f0a0b0c0d0e0f0a0b0c0d0e0f0a0b0c0d0e0f;node-id=0000000000000000000000000000000000000000;private-key=3031323334353637383961626364656666656463626139383736353433323130"; } +/* #[cfg(test)] #[allow(unused)] mod ml_kem_tests { @@ -101,71 +101,4 @@ mod ml_kem_tests { Ok(()) } } - -/* -#[cfg(test)] -#[allow(unused)] -mod pqc_kyber_tests { - use pqc_kyber::*; - use x25519_dalek::{EphemeralSecret, PublicKey}; - - type Result = std::result::Result; - - #[derive(Debug)] - enum Error { - PQCError(pqc_kyber::KyberError), - Other(Box), - } - - impl From for Error { - fn from(e: pqc_kyber::KyberError) -> Self { - Error::PQCError(e) - } - } - - // impl From<&dyn std::error::Error> for Error { - // fn from(e: &dyn std::error::Error) -> Self { - // Error::Other(Box::new(e)) - // } - // } - - struct Kyber1024XKeypair {} - - impl Kyber1024XKeypair { - fn new() -> Result { - todo!() - } - } - - #[test] - fn it_works() -> Result<()> { - let mut rng = rand::thread_rng(); - - // Generate Keypair - let alice_secret = EphemeralSecret::random_from_rng(&mut rng); - let alice_public = PublicKey::from(&alice_secret); - let keys_alice = keypair(&mut rng)?; - // alice -> bob public keys - let mut kyber1024x_pubkey = alice_public.as_bytes().to_vec(); - kyber1024x_pubkey.extend_from_slice(&keys_alice.public); - - assert_eq!(kyber1024x_pubkey.len(), 1600); - - let bob_secret = EphemeralSecret::random_from_rng(&mut rng); - let bob_public = PublicKey::from(&bob_secret); - - // Bob encapsulates a shared secret using Alice's public key - let (ciphertext, shared_secret_bob) = encapsulate(&keys_alice.public, &mut rng)?; - let bob_shared_secret = bob_secret.diffie_hellman(&alice_public); - - // // Alice decapsulates a shared secret using the ciphertext sent by Bob - let shared_secret_alice = decapsulate(&ciphertext, &keys_alice.secret)?; - let alice_shared_secret = alice_secret.diffie_hellman(&bob_public); - - assert_eq!(alice_shared_secret.as_bytes(), bob_shared_secret.as_bytes()); - assert_eq!(shared_secret_bob, shared_secret_alice); - - Ok(()) - } -} */ diff --git a/crates/o5/src/proto.rs b/crates/o5/src/proto.rs index ae1a2f5..86f02ec 100644 --- a/crates/o5/src/proto.rs +++ b/crates/o5/src/proto.rs @@ -6,7 +6,7 @@ use crate::{ constants::*, framing, sessions::Session, - Error, Result, + Result, }; use bytes::{Buf, BytesMut}; @@ -27,15 +27,6 @@ use std::{ use super::framing::{FrameError, Messages}; -#[allow(dead_code, unused)] -#[derive(Default, Debug, Clone, Copy, PartialEq)] -pub enum IAT { - #[default] - Off, - Enabled, - Paranoid, -} - #[derive(Debug, Clone)] pub(crate) enum MaybeTimeout { Default_, @@ -44,29 +35,6 @@ pub(crate) enum MaybeTimeout { Unset, } -impl std::str::FromStr for IAT { - type Err = Error; - fn from_str(s: &str) -> StdResult { - match s { - "0" => Ok(IAT::Off), - "1" => Ok(IAT::Enabled), - "2" => Ok(IAT::Paranoid), - _ => Err(format!("invalid iat-mode '{s}'").into()), - } - } -} - -impl std::fmt::Display for IAT { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - IAT::Off => write!(f, "0")?, - IAT::Enabled => write!(f, "1")?, - IAT::Paranoid => write!(f, "2")?, - } - Ok(()) - } -} - impl MaybeTimeout { pub(crate) fn duration(&self) -> Option { match self { @@ -85,29 +53,35 @@ impl MaybeTimeout { } #[pin_project] +/// AsyncReadable and AsyncWritable Obfuscated stream +/// +/// Writing in plaintext gets turned into obfuscated bytes and reading obfuscated +/// ciphertext results in decrypted planitext. +/// +/// TODO: this needs significantly more documentation pub struct O5Stream where T: AsyncRead + AsyncWrite + Unpin, { // s: Arc>>, #[pin] - s: O4Stream, + s: ObfuscatedStream, } impl O5Stream where T: AsyncRead + AsyncWrite + Unpin, { - pub(crate) fn from_o4(o4: O4Stream) -> Self { + pub(crate) fn from_o4(os: ObfuscatedStream) -> Self { O5Stream { // s: Arc::new(Mutex::new(o4)), - s: o4, + s: os, } } } #[pin_project] -pub(crate) struct O4Stream +pub(crate) struct ObfuscatedStream where T: AsyncRead + AsyncWrite + Unpin, { @@ -115,12 +89,12 @@ where pub stream: Framed, pub length_dist: probdist::WeightedDist, - pub iat_dist: probdist::WeightedDist, + pub ipt_dist: probdist::WeightedDist, pub session: Session, } -impl O4Stream +impl ObfuscatedStream where T: AsyncRead + AsyncWrite + Unpin, { @@ -129,7 +103,7 @@ where inner: T, codec: framing::O5Codec, session: Session, - ) -> O4Stream { + ) -> Self { let stream = Framed::new(inner, codec); let len_seed = session.len_seed(); @@ -137,7 +111,7 @@ where hasher.update(len_seed.as_bytes()); // the result of a sha256 haash is 32 bytes (256 bits) so we will // always have enough for a seed here. - let iat_seed = drbg::Seed::try_from(&hasher.finalize()[..SEED_LENGTH]).unwrap(); + let ipt_seed = drbg::Seed::try_from(&hasher.finalize()[..SEED_LENGTH]).unwrap(); let length_dist = WeightedDist::new( len_seed, @@ -145,8 +119,8 @@ where framing::MAX_SEGMENT_LENGTH as i32, session.biased(), ); - let iat_dist = WeightedDist::new( - iat_seed, + let ipt_dist = WeightedDist::new( + ipt_seed, 0, framing::MAX_SEGMENT_LENGTH as i32, session.biased(), @@ -156,7 +130,7 @@ where stream, session, length_dist, - iat_dist, + ipt_dist, } } @@ -170,7 +144,7 @@ where } } - /*// TODO Apply pad_burst logic and IAT policy to packet assembly (probably as part of AsyncRead / AsyncWrite impl) + /*// TODO Apply pad_burst logic and Inter-packet timing policy to packet assembly (probably as part of AsyncRead / AsyncWrite impl) /// Attempts to pad a burst of data so that the last packet is of the length /// `to_pad_to`. This can involve creating multiple packets, making this /// slightly complex. @@ -213,7 +187,7 @@ where } */ } -impl AsyncWrite for O4Stream +impl AsyncWrite for ObfuscatedStream where T: AsyncRead + AsyncWrite + Unpin, { @@ -284,7 +258,7 @@ where } } -impl AsyncRead for O4Stream +impl AsyncRead for ObfuscatedStream where T: AsyncRead + AsyncWrite + Unpin, { diff --git a/crates/o5/src/pt.rs b/crates/o5/src/pt.rs index 9988807..15e0e33 100644 --- a/crates/o5/src/pt.rs +++ b/crates/o5/src/pt.rs @@ -1,16 +1,10 @@ -use crate::{ - constants::*, - handshake::O5NtorPublicKey, - proto::{O5Stream, IAT}, - Error, OBFS4_NAME, -}; +use crate::{constants::*, handshake::IdentityPublicKey, proto::O5Stream, Error, TRANSPORT_NAME}; use ptrs::{args::Args, FutureResult as F}; use std::{ marker::PhantomData, net::{SocketAddrV4, SocketAddrV6}, pin::Pin, - str::FromStr, time::Duration, }; @@ -28,7 +22,7 @@ pub struct Transport { _p: PhantomData, } impl Transport { - pub const NAME: &'static str = OBFS4_NAME; + pub const NAME: &'static str = TRANSPORT_NAME; } impl ptrs::PluggableTransport for Transport @@ -39,7 +33,7 @@ where type ServerBuilder = crate::ServerBuilder; fn name() -> String { - OBFS4_NAME.into() + TRANSPORT_NAME.into() } fn client_builder() -> >::ClientBuilder { @@ -64,7 +58,7 @@ where } fn method_name() -> String { - OBFS4_NAME.into() + TRANSPORT_NAME.into() } fn options(&mut self, opts: &Args) -> Result<&mut Self, Self::Error> { @@ -72,14 +66,12 @@ where let state = Self::parse_state(None::<&str>, opts)?; self.identity_keys = state.private_key; - self.iat_mode(state.iat_mode); // self.drbg = state.drbg_seed; // TODO apply seed from args to server trace!( - "node_pubkey: {}, node_id: {}, iat: {}", + "node_pubkey: {}, node_id: {}", hex::encode(self.identity_keys.pk.pk.as_bytes()), hex::encode(self.identity_keys.pk.id.as_bytes()), - self.iat_mode, ); Ok(self) } @@ -114,7 +106,7 @@ where type Transport = Transport; fn method_name() -> String { - OBFS4_NAME.into() + TRANSPORT_NAME.into() } /// Builds a new PtCommonParameters. @@ -136,10 +128,7 @@ where return Err(format!("missing argument '{NODE_ID_ARG}'").into()); } trace!("cert string: {}", &cert_strs); - let ntor_pk = O5NtorPublicKey::from_str(&cert_strs)?; - let pk: [u8; NODE_PUBKEY_LENGTH] = *ntor_pk.pk.as_bytes(); - let id: [u8; NODE_ID_LENGTH] = ntor_pk.id.as_bytes().try_into().unwrap(); - (pk, id) + IdentityPublicKey::from_str(&cert_strs)? } None => { // The "old" style (version <= 0.0.2) bridge lines use separate Node ID @@ -154,27 +143,17 @@ where .retrieve(PUBLIC_KEY_ARG) .ok_or(format!("missing argument '{PUBLIC_KEY_ARG}'"))?; - let pk = <[u8; 32]>::from_hex(public_key_strs) - .map_err(|e| format!("malformed public key: {e}"))?; - // O5NtorPublicKey::new(pk, node_id) - (pk, id) + IdentityPublicKey::from_str(&public_key_strs) + .map_err(|e| format!("malformed public key: {e}"))? } }; - // IAT config is common across the two bridge line formats. - let iat_strs = opts - .retrieve(IAT_ARG) - .ok_or(format!("missing argument '{IAT_ARG}'"))?; - let iat_mode = IAT::from_str(&iat_strs)?; - - self.with_node_pubkey(server_materials.0) - .with_node_id(server_materials.1) - .with_iat_mode(iat_mode); + self.with_node_pubkey(server_materials.pk.to_bytes()) + .with_node_id(server_materials.id.into()); trace!( - "node_pubkey: {}, node_id: {}, iat: {}", + "node_pubkey: {}, node_id: {}", hex::encode(self.station_pubkey), hex::encode(self.station_id), - iat_mode ); Ok(self) @@ -226,7 +205,7 @@ where } fn method_name() -> String { - OBFS4_NAME.into() + TRANSPORT_NAME.into() } } @@ -244,7 +223,7 @@ where } fn method_name() -> String { - OBFS4_NAME.into() + TRANSPORT_NAME.into() } } diff --git a/crates/o5/src/server.rs b/crates/o5/src/server.rs index 74287c3..1058d7d 100644 --- a/crates/o5/src/server.rs +++ b/crates/o5/src/server.rs @@ -4,22 +4,23 @@ use super::*; use crate::{ client::ClientBuilder, common::{ - colorize, - curve25519::{PublicKey, StaticSecret}, - drbg, + colorize, drbg, replay_filter::{self, ReplayFilter}, HmacSha256, }, constants::*, framing::{FrameError, Marshall, O5Codec, TryParse, KEY_LENGTH}, - handshake::{O5NtorPublicKey, O5NtorSecretKey}, - proto::{MaybeTimeout, O5Stream, IAT}, + handshake::{IdentityPublicKey, IdentitySecretKey}, + proto::{MaybeTimeout, O5Stream}, sessions::Session, Error, Result, }; use ptrs::args::Args; +use tor_cell::relaycell::extend::NtorV3Extension; -use std::{borrow::BorrowMut, marker::PhantomData, ops::Deref, str::FromStr, sync::Arc}; +use std::{ + borrow::BorrowMut, marker::PhantomData, ops::Deref, str::FromStr, string::ToString, sync::Arc, +}; use bytes::{Buf, BufMut, Bytes}; use hex::FromHex; @@ -30,14 +31,12 @@ use subtle::ConstantTimeEq; use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}; use tokio::time::{Duration, Instant}; use tokio_util::codec::Encoder; -use tor_llcrypto::pk::rsa::RsaIdentity; const STATE_FILENAME: &str = "obfs4_state.json"; pub struct ServerBuilder { - pub iat_mode: IAT, pub statefile_path: Option, - pub(crate) identity_keys: O5NtorSecretKey, + pub(crate) identity_keys: IdentitySecretKey, pub(crate) handshake_timeout: MaybeTimeout, // pub(crate) drbg: Drbg, // TODO: build in DRBG _stream_type: PhantomData, @@ -45,9 +44,8 @@ pub struct ServerBuilder { impl Default for ServerBuilder { fn default() -> Self { - let identity_keys = O5NtorSecretKey::getrandom(); + let identity_keys = IdentitySecretKey::random_from_rng(&mut rand::thread_rng()); Self { - iat_mode: IAT::Off, statefile_path: None, identity_keys, handshake_timeout: MaybeTimeout::Default_, @@ -59,12 +57,10 @@ impl Default for ServerBuilder { impl ServerBuilder { /// 64 byte combined representation of an x25519 public key, private key /// combination. - pub fn node_keys(&mut self, keys: [u8; KEY_LENGTH * 2]) -> &Self { - let sk: [u8; KEY_LENGTH] = keys[..KEY_LENGTH].try_into().unwrap(); - let pk: [u8; KEY_LENGTH] = keys[KEY_LENGTH..].try_into().unwrap(); - self.identity_keys.sk = sk.into(); - self.identity_keys.pk.pk = (&self.identity_keys.sk).into(); - self + pub fn node_keys(&mut self, keys: impl AsRef<[u8]>) -> Result<&Self> { + let sk = IdentitySecretKey::try_from(keys.as_ref())?; + self.identity_keys = sk; + Ok(self) } pub fn statefile_path(&mut self, path: &str) -> &Self { @@ -77,11 +73,6 @@ impl ServerBuilder { self } - pub fn iat_mode(&mut self, iat: IAT) -> &Self { - self.iat_mode = iat; - self - } - pub fn with_handshake_timeout(&mut self, d: Duration) -> &Self { self.handshake_timeout = MaybeTimeout::Length(d); self @@ -100,14 +91,12 @@ impl ServerBuilder { pub fn client_params(&self) -> String { let mut params = Args::new(); params.insert(CERT_ARG.into(), vec![self.identity_keys.pk.to_string()]); - params.insert(IAT_ARG.into(), vec![self.iat_mode.to_string()]); params.encode_smethod_args() } - pub fn build(&self) -> Server { + pub fn build(self) -> Server { Server(Arc::new(ServerInner { - identity_keys: self.identity_keys.clone(), - iat_mode: self.iat_mode, + identity_keys: self.identity_keys, biased: false, handshake_timeout: self.handshake_timeout.duration(), @@ -171,8 +160,6 @@ struct JsonServerState { public_key: Option, #[serde(rename = "drbg-seed")] drbg_seed: Option, - #[serde(rename = "iat-mode")] - iat_mode: Option, } impl JsonServerState { @@ -189,16 +176,12 @@ impl JsonServerState { if let Some(seed) = self.drbg_seed { args.add(SEED_ARG, &seed); } - if let Some(mode) = self.iat_mode { - args.add(IAT_ARG, &mode); - } } } pub(crate) struct RequiredServerState { - pub(crate) private_key: O5NtorSecretKey, + pub(crate) private_key: IdentitySecretKey, pub(crate) drbg_seed: drbg::Drbg, - pub(crate) iat_mode: IAT, } impl TryFrom<&Args> for RequiredServerState { @@ -219,18 +202,11 @@ impl TryFrom<&Args> for RequiredServerState { .ok_or("missing argument {NODE_ID_ARG}")?; let node_id = <[u8; NODE_ID_LENGTH]>::from_hex(node_id_str)?; - let iat_mode = match value.retrieve(IAT_ARG) { - Some(s) => IAT::from_str(&s)?, - None => IAT::default(), - }; - - let secret_key = StaticSecret::from(sk); - let private_key = O5NtorSecretKey::new(secret_key, RsaIdentity::from(node_id)); + let private_key = IdentitySecretKey::try_from_bytes(sk)?; Ok(RequiredServerState { private_key, drbg_seed: drbg::Drbg::new(Some(drbg_seed))?, - iat_mode, }) } } @@ -240,9 +216,8 @@ pub struct Server(Arc); pub struct ServerInner { pub(crate) handshake_timeout: Option, - pub(crate) iat_mode: IAT, pub(crate) biased: bool, - pub(crate) identity_keys: O5NtorSecretKey, + pub(crate) identity_keys: IdentitySecretKey, pub(crate) replay_filter: ReplayFilter, // pub(crate) metrics: Metrics, @@ -256,23 +231,14 @@ impl Deref for Server { } impl Server { - pub fn new(sec: [u8; KEY_LENGTH], id: [u8; NODE_ID_LENGTH]) -> Self { - let sk = StaticSecret::from(sec); - let pk = O5NtorPublicKey { - pk: PublicKey::from(&sk), - id: id.into(), - }; - - let identity_keys = O5NtorSecretKey { pk, sk }; - - Self::new_from_key(identity_keys) + pub fn new(identity: IdentitySecretKey) -> Self { + Self::new_from_key(identity) } - pub(crate) fn new_from_key(identity_keys: O5NtorSecretKey) -> Self { + pub(crate) fn new_from_key(identity_keys: IdentitySecretKey) -> Self { Self(Arc::new(ServerInner { handshake_timeout: Some(SERVER_HANDSHAKE_TIMEOUT), identity_keys, - iat_mode: IAT::Off, biased: false, // metrics: Arc::new(std::sync::Mutex::new(ServerMetrics {})), @@ -280,45 +246,31 @@ impl Server { })) } - pub fn new_from_random(mut rng: R) -> Self { + pub fn new_from_random(rng: &mut R) -> Self { let mut id = [0_u8; 20]; - // Random bytes will work for testing, but aren't necessarily actually a valid id. - rng.fill_bytes(&mut id); // Generated identity secret key does not need to be elligator2 representable // so we can use the regular dalek_x25519 key generation. - let sk = StaticSecret::random_from_rng(rng); - - let pk = O5NtorPublicKey { - pk: PublicKey::from(&sk), - id: id.into(), - }; + let identity_keys = IdentitySecretKey::random_from_rng(rng); - let identity_keys = O5NtorSecretKey { pk, sk }; + let pk = IdentityPublicKey::from(&identity_keys); Self::new_from_key(identity_keys) } - pub fn getrandom() -> Self { - let identity_keys = O5NtorSecretKey::getrandom(); - Self::new_from_key(identity_keys) - } - pub async fn wrap(self, stream: T) -> Result> where T: AsyncRead + AsyncWrite + Unpin, { let session = self.new_server_session()?; let deadline = self.handshake_timeout.map(|d| Instant::now() + d); + let mut null_extension_handler = |_: &[NtorV3Extension]| None; - session.handshake(&self, stream, deadline).await + session + .handshake(&self, stream, &mut null_extension_handler, deadline) + .await } - // pub fn set_iat_mode(&mut self, mode: IAT) -> &Self { - // self.iat_mode = mode; - // self - // } - pub fn set_args(&mut self, args: &dyn std::any::Any) -> Result<&Self> { Ok(self) } @@ -333,9 +285,10 @@ impl Server { pub fn client_params(&self) -> ClientBuilder { ClientBuilder { - station_pubkey: *self.identity_keys.pk.pk.as_bytes(), + // these unwraps should be safe as we are sure of the size of the source + station_pubkey: self.identity_keys.pk.pk.as_bytes().try_into().unwrap(), station_id: self.identity_keys.pk.id.as_bytes().try_into().unwrap(), - iat_mode: self.iat_mode, + statefile_path: None, handshake_timeout: MaybeTimeout::Default_, } @@ -348,13 +301,12 @@ impl Server { rand::thread_rng().fill_bytes(&mut session_id); Ok(sessions::ServerSession { // fixed by server - identity_keys: self.identity_keys.clone(), biased: self.biased, // generated per session - session_id, + session_id: session_id.into(), len_seed: drbg::Seed::new().unwrap(), - iat_seed: drbg::Seed::new().unwrap(), + ipt_seed: drbg::Seed::new().unwrap(), _state: sessions::Initialized {}, }) @@ -370,13 +322,15 @@ mod tests { use ptrs::trace; use tokio::net::TcpStream; + use crate::test_utils::init_subscriber; + #[test] fn parse_json_state() -> Result<()> { - crate::test_utils::init_subscriber(); + init_subscriber(); let mut args = Args::new(); let test_state = format!( - r#"{{"{NODE_ID_ARG}": "00112233445566778899", "{PRIVATE_KEY_ARG}":"0123456789abcdeffedcba9876543210", "{IAT_ARG}": "0", "{SEED_ARG}": "abcdefabcdefabcdefabcdef"}}"# + r#"{{"{NODE_ID_ARG}": "00112233445566778899", "{PRIVATE_KEY_ARG}":"0123456789abcdeffedcba9876543210", "{SEED_ARG}": "abcdefabcdefabcdefabcdef"}}"# ); ServerBuilder::::server_state_from_json(test_state.as_bytes(), &mut args)?; debug!("{:?}\n{}", args.encode_smethod_args(), test_state); diff --git a/crates/o5/src/sessions.rs b/crates/o5/src/sessions.rs index 694f944..b0af194 100644 --- a/crates/o5/src/sessions.rs +++ b/crates/o5/src/sessions.rs @@ -2,30 +2,29 @@ //! /// Session state management as a way to organize session establishment and /// steady state transfer. -use crate::{ - common::{ - colorize, discard, drbg, - ntor_arti::{ClientHandshake, RelayHandshakeError, ServerHandshake}, - }, - constants::*, - framing, - handshake::{ - CHSMaterials, O5Keygen, O5NtorHandshake, O5NtorPublicKey, O5NtorSecretKey, - SHSMaterials, - }, - proto::{O4Stream, O5Stream, IAT}, - server::Server, - Error, Result, -}; +use crate::common::{drbg, mlkem1024_x25519}; -use std::io::{Error as IoError, ErrorKind as IoErrorKind}; +use tor_bytes::Readable; + +mod client; +pub(crate) use client::{new_client_session, ClientSession}; + +mod server; +pub(crate) use server::ServerSession; + +/// Ephermeral single use session secret key type +pub type SessionSecretKey = mlkem1024_x25519::StaticSecret; + +/// Public key type associated with SessionSecretKey. +pub type SessionPublicKey = mlkem1024_x25519::PublicKey; + + +impl Readable for SessionPublicKey { + fn take_from(_b: &mut tor_bytes::Reader<'_>) -> tor_bytes::Result { + todo!("SessionPublicKey Reader needs implemented"); + } +} -use bytes::BytesMut; -use ptrs::{debug, info, trace}; -use rand_core::RngCore; -use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}; -use tokio::time::Instant; -use tokio_util::codec::Decoder; /// Initial state for a Session, created with any params. pub(crate) struct Initialized; @@ -52,446 +51,15 @@ impl Session { pub fn biased(&self) -> bool { match self { - Session::Client(cs) => cs.biased, + Session::Client(cs) => cs.biased(), Session::Server(ss) => ss.biased, //biased, } } pub fn len_seed(&self) -> drbg::Seed { match self { - Session::Client(cs) => cs.len_seed.clone(), - Session::Server(ss) => ss.len_seed.clone(), - } - } -} - -// ================================================================ // -// Client States // -// ================================================================ // - -pub(crate) struct ClientSession { - node_pubkey: O5NtorPublicKey, - session_id: [u8; SESSION_ID_LEN], - iat_mode: IAT, // TODO: add IAT normal / paranoid writing modes - epoch_hour: String, - - biased: bool, - - len_seed: drbg::Seed, - - _state: S, -} - -#[allow(unused)] -struct ClientHandshakeFailed { - details: String, -} - -struct ClientHandshaking {} - -pub(crate) trait ClientSessionState {} -impl ClientSessionState for Initialized {} -impl ClientSessionState for ClientHandshaking {} -impl ClientSessionState for Established {} - -impl ClientSessionState for ClientHandshakeFailed {} -impl Fault for ClientHandshakeFailed {} - -impl ClientSession { - pub fn session_id(&self) -> String { - String::from("c-") + &colorize(self.session_id) - } - - pub(crate) fn set_session_id(&mut self, id: [u8; SESSION_ID_LEN]) { - debug!( - "{} -> {} client updating session id", - colorize(self.session_id), - colorize(id) - ); - self.session_id = id; - } - - /// Helper function to perform state transitions. - fn transition(self, t: T) -> ClientSession { - ClientSession { - node_pubkey: self.node_pubkey, - session_id: self.session_id, - iat_mode: self.iat_mode, - epoch_hour: self.epoch_hour, - biased: self.biased, - - len_seed: self.len_seed, - _state: t, - } - } - - /// Helper function to perform state transitions. - fn fault(self, f: F) -> ClientSession { - ClientSession { - node_pubkey: self.node_pubkey, - session_id: self.session_id, - iat_mode: self.iat_mode, - epoch_hour: self.epoch_hour, - biased: self.biased, - - len_seed: self.len_seed, - _state: f, - } - } -} - -pub fn new_client_session( - station_pubkey: O5NtorPublicKey, - iat_mode: IAT, -) -> ClientSession { - let mut session_id = [0u8; SESSION_ID_LEN]; - rand::thread_rng().fill_bytes(&mut session_id); - ClientSession { - node_pubkey: station_pubkey, - session_id, - iat_mode, - epoch_hour: "".into(), - biased: false, - - len_seed: drbg::Seed::new().unwrap(), - _state: Initialized, - } -} - -impl ClientSession { - /// Perform a Handshake over the provided stream. - /// ``` - /// - /// ``` - /// - /// TODO: make sure failure modes align with golang obfs4 - /// - FIN/RST based on buffered data. - /// - etc. - pub async fn handshake( - self, - mut stream: T, - deadline: Option, - ) -> Result> - where - T: AsyncRead + AsyncWrite + Unpin, - { - // set up for handshake - let mut session = self.transition(ClientHandshaking {}); - - let materials = CHSMaterials::new(session.node_pubkey, session.session_id()); - - // default deadline - let d_def = Instant::now() + CLIENT_HANDSHAKE_TIMEOUT; - let handshake_fut = Self::complete_handshake(&mut stream, materials, deadline); - let (mut remainder, mut keygen) = - match tokio::time::timeout_at(deadline.unwrap_or(d_def), handshake_fut).await { - Ok(result) => match result { - Ok(handshake) => handshake, - Err(e) => { - // non-timeout error, - let id = session.session_id(); - let _ = session.fault(ClientHandshakeFailed { - details: format!("{id} handshake failed {e}"), - }); - return Err(e); - } - }, - Err(_) => { - let id = session.session_id(); - let _ = session.fault(ClientHandshakeFailed { - details: format!("{id} timed out"), - }); - return Err(Error::HandshakeTimeout); - } - }; - - // post-handshake state updates - session.set_session_id(keygen.session_id()); - let mut codec: framing::O5Codec = keygen.into(); - - let res = codec.decode(&mut remainder); - if let Ok(Some(framing::Messages::PrngSeed(seed))) = res { - // try to parse the remainder of the server hello packet as a - // PrngSeed since it should be there. - let len_seed = drbg::Seed::from(seed); - session.set_len_seed(len_seed); - } else { - debug!("NOPE {res:?}"); - } - - // mark session as Established - let session_state: ClientSession = session.transition(Established {}); - info!("{} handshake complete", session_state.session_id()); - - codec.handshake_complete(); - let o4 = O4Stream::new(stream, codec, Session::Client(session_state)); - - Ok(O5Stream::from_o4(o4)) - } - - async fn complete_handshake( - mut stream: T, - materials: CHSMaterials, - deadline: Option, - ) -> Result<(BytesMut, impl O5Keygen)> - where - T: AsyncRead + AsyncWrite + Unpin, - { - let (state, chs_message) = O5NtorHandshake::client1(&materials, &())?; - // let mut file = tokio::fs::File::create("message.hex").await?; - // file.write_all(&chs_message).await?; - stream.write_all(&chs_message).await?; - - debug!( - "{} handshake sent {}B, waiting for sever response", - materials.session_id, - chs_message.len() - ); - - let mut buf = [0u8; MAX_HANDSHAKE_LENGTH]; - loop { - let n = stream.read(&mut buf).await?; - if n == 0 { - Err(Error::IOError(IoError::new( - IoErrorKind::UnexpectedEof, - "read 0B in client handshake", - )))? - } - debug!( - "{} read {n}/{}B of server handshake", - materials.session_id, - buf.len() - ); - - match O5NtorHandshake::client2(state.clone(), &buf[..n]) { - Ok(r) => return Ok(r), - Err(Error::HandshakeErr(RelayHandshakeError::EAgain)) => continue, - Err(e) => { - // if a deadline was set and has not passed already, discard - // from the stream until the deadline, then close. - if deadline.is_some_and(|d| d > Instant::now()) { - debug!("{} discarding due to: {e}", materials.session_id); - discard(&mut stream, deadline.unwrap() - Instant::now()).await?; - } - stream.shutdown().await?; - return Err(e); - } - } - } - } -} - -impl ClientSession { - pub(crate) fn set_len_seed(&mut self, seed: drbg::Seed) { - debug!( - "{} setting length seed {}", - self.session_id(), - hex::encode(seed.as_bytes()) - ); - self.len_seed = seed; - } -} - -impl std::fmt::Debug for ClientSession { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!( - f, - "[ id:{}, ident_pk:{}, iat:{:?}, epoch_hr:{} ]", - hex::encode(self.node_pubkey.id.as_bytes()), - hex::encode(self.node_pubkey.pk.as_bytes()), - self.iat_mode, - self.epoch_hour, - ) - } -} - -// ================================================================ // -// Server Sessions States // -// ================================================================ // - -pub(crate) struct ServerSession { - // fixed by server - pub(crate) identity_keys: O5NtorSecretKey, - pub(crate) biased: bool, - // pub(crate) server: &'a Server, - - // generated per session - pub(crate) session_id: [u8; SESSION_ID_LEN], - pub(crate) len_seed: drbg::Seed, - pub(crate) iat_seed: drbg::Seed, - - pub(crate) _state: S, -} - -pub(crate) struct ServerHandshaking {} - -#[allow(unused)] -pub(crate) struct ServerHandshakeFailed { - details: String, -} - -pub(crate) trait ServerSessionState {} -impl ServerSessionState for Initialized {} -impl ServerSessionState for ServerHandshaking {} -impl ServerSessionState for Established {} - -impl ServerSessionState for ServerHandshakeFailed {} -impl Fault for ServerHandshakeFailed {} - -impl ServerSession { - pub fn session_id(&self) -> String { - String::from("s-") + &colorize(self.session_id) - } - - pub(crate) fn set_session_id(&mut self, id: [u8; SESSION_ID_LEN]) { - debug!( - "{} -> {} server updating session id", - colorize(self.session_id), - colorize(id) - ); - self.session_id = id; - } - - /// Helper function to perform state transitions. - fn transition(self, _state: T) -> ServerSession { - ServerSession { - // fixed by server - identity_keys: self.identity_keys, - biased: self.biased, - - // generated per session - session_id: self.session_id, - len_seed: self.len_seed, - iat_seed: self.iat_seed, - - _state, - } - } - - /// Helper function to perform state transition on error. - fn fault(self, f: F) -> ServerSession { - ServerSession { - // fixed by server - identity_keys: self.identity_keys, - biased: self.biased, - - // generated per session - session_id: self.session_id, - len_seed: self.len_seed, - iat_seed: self.iat_seed, - - _state: f, - } - } -} - -impl ServerSession { - /// Attempt to complete the handshake with a new client connection. - pub async fn handshake( - self, - server: &Server, - mut stream: T, - deadline: Option, - ) -> Result> - where - T: AsyncRead + AsyncWrite + Unpin, - { - // set up for handshake - let mut session = self.transition(ServerHandshaking {}); - - let materials = SHSMaterials::new( - &session.identity_keys, - session.session_id(), - session.len_seed.to_bytes(), - ); - - // default deadline - let d_def = Instant::now() + SERVER_HANDSHAKE_TIMEOUT; - let handshake_fut = server.complete_handshake(&mut stream, materials, deadline); - - let mut keygen = - match tokio::time::timeout_at(deadline.unwrap_or(d_def), handshake_fut).await { - Ok(result) => match result { - Ok(handshake) => handshake, - Err(e) => { - // non-timeout error, - let id = session.session_id(); - let _ = session.fault(ServerHandshakeFailed { - details: format!("{id} handshake failed {e}"), - }); - return Err(e); - } - }, - Err(_) => { - let id = session.session_id(); - let _ = session.fault(ServerHandshakeFailed { - details: format!("{id} timed out"), - }); - return Err(Error::HandshakeTimeout); - } - }; - - // post handshake state updates - session.set_session_id(keygen.session_id()); - let mut codec: framing::O5Codec = keygen.into(); - - // mark session as Established - let session_state: ServerSession = session.transition(Established {}); - - codec.handshake_complete(); - let o4 = O4Stream::new(stream, codec, Session::Server(session_state)); - - Ok(O5Stream::from_o4(o4)) - } -} - -impl Server { - /// Complete the handshake with the client. This function assumes that the - /// client has already sent a message and that we do not know yet if the - /// message is valid. - async fn complete_handshake( - &self, - mut stream: T, - materials: SHSMaterials, - deadline: Option, - ) -> Result - where - T: AsyncRead + AsyncWrite + Unpin, - { - let session_id = materials.session_id.clone(); - - // wait for and attempt to consume the client hello message - let mut buf = [0_u8; MAX_HANDSHAKE_LENGTH]; - loop { - let n = stream.read(&mut buf).await?; - if n == 0 { - stream.shutdown().await?; - return Err(IoError::from(IoErrorKind::UnexpectedEof).into()); - } - trace!("{} successful read {n}B", session_id); - - match self.server(&mut |_: &()| Some(()), &[materials.clone()], &buf[..n]) { - Ok((keygen, response)) => { - stream.write_all(&response).await?; - info!("{} handshake complete", session_id); - return Ok(keygen); - } - Err(RelayHandshakeError::EAgain) => { - trace!("{} reading more", session_id); - continue; - } - Err(e) => { - trace!("{} failed to parse client handshake: {e}", session_id); - // if a deadline was set and has not passed already, discard - // from the stream until the deadline, then close. - if deadline.is_some_and(|d| d > Instant::now()) { - debug!("{} discarding due to: {e}", session_id); - discard(&mut stream, deadline.unwrap() - Instant::now()).await? - } - stream.shutdown().await?; - return Err(e.into()); - } - }; + Session::Client(cs) => cs.len_seed(), + Session::Server(ss) => ss.len_seed(), } } } diff --git a/crates/o5/src/sessions/client.rs b/crates/o5/src/sessions/client.rs new file mode 100644 index 0000000..aa613cc --- /dev/null +++ b/crates/o5/src/sessions/client.rs @@ -0,0 +1,266 @@ +use crate::{ + common::{ + discard, drbg, + ntor_arti::{ClientHandshake, RelayHandshakeError, SessionID, SessionIdentifier}, + }, + constants::*, + framing, + handshake::{CHSMaterials, IdentityPublicKey, NtorV3Client, NtorV3KeyGen}, + proto::{O5Stream, ObfuscatedStream}, + sessions::{Established, Fault, Initialized, Session}, + Error, Result, +}; + +use std::io::{Error as IoError, ErrorKind as IoErrorKind}; + +use bytes::BytesMut; +use ptrs::{debug, info}; +use rand_core::RngCore; +use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}; +use tokio::time::Instant; +use tokio_util::codec::Decoder; + +// ================================================================ // +// Client States // +// ================================================================ // + +pub(crate) struct ClientSession { + node_pubkey: IdentityPublicKey, + session_id: SessionID, + epoch_hour: String, + + biased: bool, + + len_seed: drbg::Seed, + + _state: S, +} + +#[allow(unused)] +struct ClientHandshakeFailed { + details: String, +} + +struct ClientHandshaking {} + +pub(crate) trait ClientSessionState {} +impl ClientSessionState for Initialized {} +impl ClientSessionState for ClientHandshaking {} +impl ClientSessionState for Established {} + +impl ClientSessionState for ClientHandshakeFailed {} +impl Fault for ClientHandshakeFailed {} + +impl ClientSession { + pub fn session_id(&self) -> String { + String::from("c-") + &self.session_id.to_string() + } + + pub(crate) fn set_session_id(&mut self, id: SessionID) { + debug!("{} -> {} client updating session id", self.session_id, id); + self.session_id = id; + } + + pub(crate) fn biased(&self) -> bool { + self.biased + } + + pub fn len_seed(&self) -> drbg::Seed { + self.len_seed.clone() + } + + /// Helper function to perform state transitions. + fn transition(self, t: T) -> ClientSession { + ClientSession { + node_pubkey: self.node_pubkey, + session_id: self.session_id, + epoch_hour: self.epoch_hour, + biased: self.biased, + + len_seed: self.len_seed, + _state: t, + } + } + + /// Helper function to perform state transitions. + fn fault(self, f: F) -> ClientSession { + ClientSession { + node_pubkey: self.node_pubkey, + session_id: self.session_id, + epoch_hour: self.epoch_hour, + biased: self.biased, + + len_seed: self.len_seed, + _state: f, + } + } +} + +pub fn new_client_session(station_pubkey: IdentityPublicKey) -> ClientSession { + let mut session_id = [0u8; SESSION_ID_LEN]; + rand::thread_rng().fill_bytes(&mut session_id); + ClientSession { + node_pubkey: station_pubkey, + session_id: session_id.into(), + epoch_hour: "".into(), + biased: false, + + len_seed: drbg::Seed::new().unwrap(), + _state: Initialized, + } +} + +impl ClientSession { + /// Perform a Handshake over the provided stream. + /// + /// Completes the client handshake including sending the initial hello message + /// and processing the response (or lack thereof). On success this returns: + /// 1) The remaining bytes included in the server response not part of the + /// handshake packet. + /// TODO: should 1 &2 be combined? + /// 2) Any sever extensions sent as part of the handshake response + /// 3) An NtorV3-Like key generator used to bootstrap the codec that will + /// be used to obfuscate the stream data. + /// + /// Errors can be cause by: + /// - failing to connect to remote host (timeout) + /// - failing to write the handshake + /// - timeout / cancel while waiting for response + /// - failing to read response + /// - crypto error in response + /// - response fails server auth check + /// + /// TODO: make sure failure modes are understood (FIN/RST w/ and w/out buffered data, etc.) + pub async fn handshake(self, mut stream: T, deadline: Option) -> Result> + where + T: AsyncRead + AsyncWrite + Unpin, + { + // set up for handshake + let mut session = self.transition(ClientHandshaking {}); + + let materials = CHSMaterials::new(&session.node_pubkey, session.session_id()); + + // default deadline + let d_def = Instant::now() + CLIENT_HANDSHAKE_TIMEOUT; + let handshake_fut = Self::complete_handshake(&mut stream, materials, deadline); + let (mut remainder, mut keygen) = + match tokio::time::timeout_at(deadline.unwrap_or(d_def), handshake_fut).await { + Ok(result) => match result { + Ok(handshake) => handshake, + Err(e) => { + // non-timeout error, + let id = session.session_id(); + let _ = session.fault(ClientHandshakeFailed { + details: format!("{id} handshake failed {e}"), + }); + return Err(e); + } + }, + Err(_) => { + let id = session.session_id(); + let _ = session.fault(ClientHandshakeFailed { + details: format!("{id} timed out"), + }); + return Err(Error::HandshakeTimeout); + } + }; + + // post-handshake state updates + session.set_session_id(keygen.session_id()); + let mut codec: framing::O5Codec = keygen.into(); + + let res = codec.decode(&mut remainder); + if let Ok(Some(framing::Messages::PrngSeed(seed))) = res { + // try to parse the remainder of the server hello packet as a + // PrngSeed since it should be there. + let len_seed = drbg::Seed::from(seed); + session.set_len_seed(len_seed); + } else { + debug!("NOPE {res:?}"); + } + + // mark session as Established + let session_state: ClientSession = session.transition(Established {}); + info!("{} handshake complete", session_state.session_id()); + + codec.handshake_complete(); + let o4 = ObfuscatedStream::new(stream, codec, Session::Client(session_state)); + + Ok(O5Stream::from_o4(o4)) + } + + async fn complete_handshake( + mut stream: T, + materials: CHSMaterials, + deadline: Option, + ) -> Result<(BytesMut, impl NtorV3KeyGen)> + where + T: AsyncRead + AsyncWrite + Unpin, + { + // let session_id = materials.session_id; + let (state, chs_message) = NtorV3Client::client1(materials)?; + // let mut file = tokio::fs::File::create("message.hex").await?; + // file.write_all(&chs_message).await?; + stream.write_all(&chs_message).await?; + + debug!( + "{} handshake sent {}B, waiting for sever response", + materials.session_id, + chs_message.len() + ); + + let mut buf = [0u8; MAX_HANDSHAKE_LENGTH]; + loop { + let n = stream.read(&mut buf).await?; + if n == 0 { + Err(Error::IOError(IoError::new( + IoErrorKind::UnexpectedEof, + "read 0B in client handshake", + )))? + } + debug!( + "{} read {n}/{}B of server handshake", + materials.session_id, + buf.len() + ); + + match NtorV3Client::client2(state, &buf[..n]) { + Ok(r) => return Ok(r), + Err(Error::HandshakeErr(RelayHandshakeError::EAgain)) => continue, + Err(e) => { + // if a deadline was set and has not passed already, discard + // from the stream until the deadline, then close. + if deadline.is_some_and(|d| d > Instant::now()) { + debug!("{} discarding due to: {e}", materials.session_id); + discard(&mut stream, deadline.unwrap() - Instant::now()).await?; + } + stream.shutdown().await?; + return Err(e); + } + } + } + } +} + +impl ClientSession { + pub(crate) fn set_len_seed(&mut self, seed: drbg::Seed) { + debug!( + "{} setting length seed {}", + self.session_id(), + hex::encode(seed.as_bytes()) + ); + self.len_seed = seed; + } +} + +impl std::fmt::Debug for ClientSession { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!( + f, + "[ id:{}, ident_pk:{}, epoch_hr:{} ]", + hex::encode(self.node_pubkey.id.as_bytes()), + hex::encode(self.node_pubkey.pk.as_bytes()), + self.epoch_hour, + ) + } +} diff --git a/crates/o5/src/sessions/server.rs b/crates/o5/src/sessions/server.rs new file mode 100644 index 0000000..ee76e73 --- /dev/null +++ b/crates/o5/src/sessions/server.rs @@ -0,0 +1,224 @@ +use crate::{ + common::{ + discard, drbg, + ntor_arti::{ + AuxDataReply, RelayHandshakeError, ServerHandshake, SessionID, SessionIdentifier, + }, + }, + constants::*, + framing, + handshake::{NtorV3KeyGen, SHSMaterials}, + proto::{O5Stream, ObfuscatedStream}, + server::Server, + sessions::{Established, Fault, Initialized, Session}, + Error, Result, +}; + +use std::io::{Error as IoError, ErrorKind as IoErrorKind}; + +use ptrs::{debug, info, trace}; +use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}; +use tokio::time::Instant; + +// ================================================================ // +// Server Sessions States // +// ================================================================ // + +pub(crate) struct ServerSession { + // -------- fixed by server -------- + pub(crate) biased: bool, + + // pub(crate) server: &'a Server, + + // -------- generated per session -------- + /// Session Identifier + /// + /// Generated randomly to begin with then deterministically derived from the + /// shared secret once session is established such that the client and server + /// session_id values match. + pub(crate) session_id: SessionID, + /// Packet (padding) length seed + /// + /// Used when selecting lengths to add onto packets to obscure client data length. + pub(crate) len_seed: drbg::Seed, + /// Inter-packet timing seed + /// + /// Used when generating delays between packets. + pub(crate) ipt_seed: drbg::Seed, + + pub(crate) _state: S, +} + +pub(crate) struct ServerHandshaking {} + +#[allow(unused)] +pub(crate) struct ServerHandshakeFailed { + details: String, +} + +pub(crate) trait ServerSessionState {} +impl ServerSessionState for Initialized {} +impl ServerSessionState for ServerHandshaking {} +impl ServerSessionState for Established {} + +impl ServerSessionState for ServerHandshakeFailed {} +impl Fault for ServerHandshakeFailed {} + +impl ServerSession { + pub fn session_id(&self) -> String { + String::from("s-") + &self.session_id.to_string() + } + + pub(crate) fn biased(&self) -> bool { + self.biased + } + + pub fn len_seed(&self) -> drbg::Seed { + self.len_seed.clone() + } + + pub(crate) fn set_session_id(&mut self, id: SessionID) { + debug!("{} -> {} server updating session id", self.session_id, id); + self.session_id = id; + } + + /// Helper function to perform state transitions. + fn transition(self, _state: T) -> ServerSession { + ServerSession { + // fixed by server + biased: self.biased, + + // generated per session + session_id: self.session_id, + len_seed: self.len_seed, + ipt_seed: self.ipt_seed, + + _state, + } + } + + /// Helper function to perform state transition on error. + fn fault(self, f: F) -> ServerSession { + ServerSession { + // fixed by server + biased: self.biased, + + // generated per session + session_id: self.session_id, + len_seed: self.len_seed, + ipt_seed: self.ipt_seed, + + _state: f, + } + } +} + +impl ServerSession { + /// Attempt to complete the handshake with a new client connection. + pub async fn handshake, T>( + self, + server: &Server, + mut stream: T, + extensions_handler: &mut REPLY, + deadline: Option, + ) -> Result> + where + T: AsyncRead + AsyncWrite + Unpin, + { + // set up for handshake + let mut session = self.transition(ServerHandshaking {}); + + let materials = SHSMaterials::new(session.session_id(), session.len_seed.to_bytes()); + + // default deadline + let d_def = Instant::now() + SERVER_HANDSHAKE_TIMEOUT; + let handshake_fut = + server.complete_handshake(&mut stream, extensions_handler, materials, deadline); + + let mut keygen = + match tokio::time::timeout_at(deadline.unwrap_or(d_def), handshake_fut).await { + Ok(result) => match result { + Ok(handshake) => handshake, + Err(e) => { + // non-timeout error, + let id = session.session_id(); + let _ = session.fault(ServerHandshakeFailed { + details: format!("{id} handshake failed {e}"), + }); + return Err(e); + } + }, + Err(_) => { + let id = session.session_id(); + let _ = session.fault(ServerHandshakeFailed { + details: format!("{id} timed out"), + }); + return Err(Error::HandshakeTimeout); + } + }; + + // post handshake state updates + session.set_session_id(keygen.session_id()); + let mut codec: framing::O5Codec = keygen.into(); + + // mark session as Established + let session_state: ServerSession = session.transition(Established {}); + + codec.handshake_complete(); + let o4 = ObfuscatedStream::new(stream, codec, Session::Server(session_state)); + + Ok(O5Stream::from_o4(o4)) + } +} + +impl Server { + /// Complete the handshake with the client. This function assumes that the + /// client has already sent a message and that we do not know yet if the + /// message is valid. + async fn complete_handshake, T>( + &self, + mut stream: T, + reply_fn: &mut REPLY, + materials: SHSMaterials, + deadline: Option, + ) -> Result> + where + T: AsyncRead + AsyncWrite + Unpin, + { + let session_id = materials.session_id.clone(); + + // wait for and attempt to consume the client hello message + let mut buf = [0_u8; MAX_HANDSHAKE_LENGTH]; + loop { + let n = stream.read(&mut buf).await?; + if n == 0 { + stream.shutdown().await?; + return Err(IoError::from(IoErrorKind::UnexpectedEof).into()); + } + trace!("{} successful read {n}B", session_id); + + match self.server(reply_fn, &materials, &buf[..n]) { + Ok((keygen, response)) => { + stream.write_all(&response).await?; + info!("{} handshake complete", session_id); + return Ok(keygen); + } + Err(RelayHandshakeError::EAgain) => { + trace!("{} reading more", session_id); + continue; + } + Err(e) => { + trace!("{} failed to parse client handshake: {e}", session_id); + // if a deadline was set and has not passed already, discard + // from the stream until the deadline, then close. + if deadline.is_some_and(|d| d > Instant::now()) { + debug!("{} discarding due to: {e}", session_id); + discard(&mut stream, deadline.unwrap() - Instant::now()).await? + } + stream.shutdown().await?; + return Err(e.into()); + } + }; + } + } +} diff --git a/crates/o5/src/testing.rs b/crates/o5/src/testing.rs index 185aab1..71c9241 100644 --- a/crates/o5/src/testing.rs +++ b/crates/o5/src/testing.rs @@ -131,7 +131,8 @@ async fn transfer_10k_x3() -> Result<()> { let (c, mut s) = tokio::io::duplex(1024 * 1000); - let o4_server = Server::getrandom(); + let mut rng = rand::thread_rng(); + let o4_server = Server::new_from_random(&mut rng); let client_config = o4_server.client_params(); tokio::spawn(async move { diff --git a/crates/obfs4/src/handshake/handshake_client.rs b/crates/obfs4/src/handshake/handshake_client.rs index 0ac5345..d0ff22a 100644 --- a/crates/obfs4/src/handshake/handshake_client.rs +++ b/crates/obfs4/src/handshake/handshake_client.rs @@ -53,7 +53,7 @@ pub(super) fn client_handshake_obfs4( client_handshake_obfs4_no_keygen(my_sk, materials.clone()) } -/// Helper: client handshake _without_ generating new keys. +/// Helper: client handshake _without_ generating new keys. pub(crate) fn client_handshake_obfs4_no_keygen( ephem: EphemeralSecret, materials: HandshakeMaterials, diff --git a/doc/pq_obfs/obfs4.png b/doc/pq_obfs/obfs4.png new file mode 100644 index 0000000000000000000000000000000000000000..ee19b7c2dc71843d852f3a75097e174fdff13d7a GIT binary patch literal 352725 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

;E>XcZcsHQfy9fYqLqW7R!xK~@2SK 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

euW1>26q! z$TD+3i;h}WR?`IY@fT`ZNY8_K>J6vPzP(6T_W^c{;;Fxd?HqlLrkB4QaJS! zY_>&ojfL(W3OG2cY_ZKdoX`sHE4QsvvRt1C1@OdAM*W;ZC z(fAna>HH7yZI(033ku%H)v*y)i8&P zJQn%FbMk2SsLFbj=k9%)q}fCHV=k#XsJ`~;i8=c?Ki*Yd-I8@7mAmm+TVLAV>OzKG z_>}3B#~`!mcU`M6Y(Hr9lKG%LSMR#2*wl;b?HaT5~->)2K2mdBmACsA1t0GRtduBe(&cUVmoh+wU9l|9RTu z*m&ay@YMN4ScxOR^R#YPW+e4ybQVx#iLxIu^onFc8-ZKQYPY8a?scWc+i-6;(l^-F zQ;bW$m-JcIo*cfZBi;d`hA4_;Z?~<#`Ouq3{yjT)wboad-ddpcV)DJ~bzl)}r!8}O zDPM~q_;q7UWGBdKHE=%tPBX6`^97wyoBF<>dPgsz7#7ls=aRc(s2O&4*3)!nG|^iP z>!3at_?Q7w#2AhFFme@?IQ~iPYygP{E3SJg9h5q|+A)I?`Azum`v-e(#`Hd21v-AR zrsbQBQ*R?K=LeKbw7Xm+f~WLnEi}E778OP<%D?~^HvQIkpt6GG2X6e+{=HemHTH(W zg~O_o1AJ6)od}}`fp*I&3eKc`Uz0fwOuetyn_T6S6bBSGSkEV{=jTx5oSc3sFaXO^ z_maKy(q^*!I9+nR?@fiKRpnyIaRm;80v7iQJq+BE>9EGd<%vmlfrRTQDDYqlr8OmHY*#VN9 z@iLmLk!gMB)C?O^aGO%GLs6tWk$254h>q!tr@&n zik`=c8hlOnY0&$v{S)d)P4==pbzZrBP=?f@y7tYQybmcOjcdzy6)NzeRoWk*!rxHB zrP8J#>ciW&E0ja5A_xYOhv|AJbeU=A>#yMr$_c_2xnxp4jGAlNPLI0JeLIz_W*Re_ z5E8lT7meoS(@%X+LVaaY_6vlc>mH3#aiW6Vykwm(vJ@nWMXtJFt zyw>C zwu-O(u>iUC#(nzYoU;4bJ`vpsPrCAl;d(={WC-!-Bz&}M;hd7O(dCp%!hZc$!{YbM zJ&YZubR%l(di)XyACNkw`?GJtUYX;d4*K1L2Sy9h*J|o&YHHpyAdR2XQD^l(6T{sl z7QH8U-!3f<%;?Yz3Qh6JDA30=BI>8xp%bbW-0zy!P-@*ysHm%8$aKDS_~5kYaky1^ zrL34aRjk1JW_Ihvv^AsV2%IsFAV|203LaRh4!VnZR5kpw`VdNZbq@mzd=oS)8zo!m zR)IMm&Y8`}!rGq&mhha;4$)80QcE2M(g)2>6eVS2ELj}hhw*W_rdH#LWnV|i+TS%q z-wCOg<|o}XlcyFcH+W{_;l?C?n~RdvdB*uco-Vb!@iFM?*9nzrSDJ0NWHhx}SR&Aa z;?rlCrTUW=o>4tHo0now5sT@=eyCxd;$(xvULT8$R1M`^mZwT{>{YWxY!{QxF)ovC zor&(MJU_Z0O5{9MS_~&GHMaX^$Rbl@@~@>8`c1FC=P8vh=(ms&orc(d|b!P1j{zpuJb zFS`$W!m(K2yZ`l$^EC)YmFJ7M%WR25m`a3HUnSFwTx;X3DPWAe%z40`%LD~gel|YT z`ZbTkP%yQU7z&kAYeYO*X+s(uLwhvkd!~P)Am0axsv)uNZOH}O=-F@|yjy6FmTefX zpoZeUZmrF-xA`+$`CQa|#8=M#6l#@F_@=y=@0%BpZ+-vx6Z!V%>Ro>NvD&z>cco{f z@Qq(1gL9 z33-KkeJ5tpPtS%nD z{YvRfefRLNoV?`u2Q$cauKfExTzZY}p%3mTSR-v%6Nm-zwAdd6^D0YT9>^oQ)p$^v0kteNno&K2p6!X@;pCyU+Z(DO?lHM&1&3b znWRpW2f)j8r`syX81T(~twz!k69NHG`hEFfa;p`2C z>B`6lQMJkMN{wpJK6vcX=c~4Q6{l4z{Ad4T_GE=#JZFYK)2eOsJGKf*EGmL4v%%OX z{)lc=B!SEIZW!xG|3afGmK#Vd*xQMrIF zzk8Suf9?OYF_hIQ=JMq!l8ZFj{7nIlYt-8oKxLFZ81G~c2(QK~lj)}YKE}rmxObUaDKG6tq`0L$Js=d0z7$8A}-o9Xd@*}rafia&j{SlQIYb` zGQl?)>whtRLZuF%IV(kM%u9A}jtVdekOLQ6|?|NCr$ z^#(Ve)6<9Sjr5EGr`lxuHH+)zMKgmrG+2AFfIAFBhrd@m z>=wtdQ56h?ae&4s}eR^z38xLOLt?M~Fz*v(LHt0LXf3ec1aN4_s z>=^8oraevr09XUDxh&OxKr(9tUAlan`wM+=sgI-?v)@lu2&^WD?Ym<6?lwDbBL_9ZY&s_${XFZ|9`NEb3Gln^Zq=k>{qTKHflG z=F?(jdcWf#RjG_t5@@oxcpn(_E+f2xs!+>Ky*hv(t6oAAF{1D~zBv?q8f40{GYZ(7n>4GeHP5wgZv5E z3$3|P3C({q9&&crJ>o}nn#Nmp$}njBPW6VU=v}L$xtvceA@8ScNZH0>V#oM0IRDv6 z^lPQ`VS*)&g|p?wIQC&XuATtXQMT= zu?cH z{7zK1`WyMFaCqV*$jDf_UE;Uqt${EHkcFaM8o6?tEvch94ICsC8rKiJxWOeb+b5s6sBPypmQ|>OJ|SUrGLjzW4(--dy2B3b1b3~ZUy^c zxR|%b^=Aj}JlbFEV#yRf7Ay`z*5-U1;X+fnlkODIFGBBnzNPtd4LcwRTjS4MIvKD zLPFx=x6y2YOA`M1!p}FgR%28r(x}IXfw7%MG*nvDb(lh8x$+c1U61)nosiH_aJ#!5 z2&5hmd?svZ{5d{DiGouiDpS%)X5c|C(xuJCN-w)8Hx;6>?$h{sDW1g%Od@lRA1 zrx$HZd}{8$^u!!7Km=>3ocDXWlBMk&%RuczEUw~JVd?g`YpeN4|BoAl#5w*>hbm#5 zG5$-qGv==$SjWP@E)r`Su^OQ{%Rs}?_xQDL3a0++%Vor_H?Lqoe4w&`?OjT$r_;U+uwWy>$ zuJSW!NL%q`7DmFDzE(4eHhL6=7%cm*VOg3i4+=eTE{3H)E^rVUvgKQc6QQAO`Ev~o z9> zgpw<(b;{Ig2;nP;hx2|%_0U&k7P0&Zy54*QeWAckA_tTlN9{~~z=_lh6A+0tanJds zHXOS)MUv4jidbbBCtW12c#c-FDK_`RL-XsVPL9w2K#JzUW2^p?y@D{ko;`AnFPm129JA|4 zKM1oyM>O2pcv%NWui0>8azf91A~gmx3*Sms$6!OdjOidnjXK!#uVFjt<&*LZltE@0 z;mbcWWI7EgXtZ57-B4)yYceb%^85=UHWouW$h|`A+&L;vEbYSaND95!6N#H*_Li#u z-YnLE(B#sr;^K7R-Io)t-~h+&8H=Nxma56XpiiLH1{d(&C$=ej zb-v<|!@I|izQI*prmR@AY+rM0_z|XShYve*#pyn>D()M^&B-&|OdKVy3jzPjtz6Fy zaylgp{$;Iimb(D5$iahm6}^&viiB7Rb*<*UcnsTXN}q3)C^MQ#a*HSfo$l$`OJ?+g@B7wk>tfa@56JqpfG*l>#ajh0bStWO+dnCqU zwwe9TPoJ@KNX7rnKc7hlBgv56As*QYS)Zu9%fN`UppkKaX2^D6xpZP=WaKDhBZniI zONU3cU#*cCC(;ydOzC&*$@arX8e*BWmMSRA0CqFZ%ze({*TXo0E1piDXX#yUh)w)$ z&K=_yL#nQ7Vno(liPM)=Z4O9Kj#cTKn|8&nO*tV3mm>DBZT!tjk;zQB6l0pAogsZA;ovx+0y%ZH9&Zs^s@=Ppfd6hzazi zL~G8LG+nvD34#sdC;U?PGi!dw_bWOuiYV{JS9D>f!s^_h#YC9TuJvX8U5Tb#C%e&xi}-)AmBpr7m|0;;vvUCv#E=38EWKXsve#|TT>=G6N->`r|Ol`2|D>Xr?FvY(pb zO!5m@j;Hr_`rcYERFg?X;VT*3k^SuhKQ6Wz(tUI)}WAbFJZzuo^f`k5o4e5&f7t>0+D72;Elhb^DN)XX7?T;4NrMMT=5Q|7`J-9U8)xi8??_{U zO+DgWj^zKV@byZ5+OPS1ce5IV@bT}jAV7Zl@5P5lSXL%NIT#ZYlm4NhqB&bz&MzkL3`?5XAgAFbFc zTnH%=ANO#(KJ;ono4M&&$6FNBAQQ4#p1uA=@q+7H#Oy zlz$cW|L=>}tWXj7_h3YK{?~Cvd3B-VSmYHqW3H?=Vv4D>BI%{Ap~1m=&r`#v=Vw?( zt!h%GOdjtl!T;?|i`S-8G8!U!%c}5*PBkZDFovrA1&--L2CMcH-*;{M-@yl;Xb1@tGmd{A>3=)p0F8`Gbb7`-o3N7Am{d88Kv1eLxR+03Q~LIe zLtI?^2+|VQ>;UQVk^1_d$oHSeOA;vM?C%J%Tq=?=3hYcML!fwn?)e)i4AhUSVTVa$ zHyTWoCv^Uw_u!>OpD9arMs>TVn+3iMtUg+@!sYjx*MDQ0Ot|3G)vu>DV)Hy%v2N1c z*xYRMy*=sPnbyHexiabZ;rZGr{uQD2?QF_0WWIslx*=#EcL%it?1SkC$t(l$nby51 zcH@Z7F~8ZX05k&CivJjGBV9)3L~~DE8@$}lM<{Q8EwWXnojI;^q`_MHwpg8=VgIi8 zg*nNu@+*GY`D+xeyBxU~llS@VXG_%|q44dIwZp_f9mD*Omw3ubCvtn&XIeF}qup_f z3YDkeNELcqnvDeRk}(pZNAL$k$Fc+$A_YRiTjMrBlnjZ`_kpXOtLGYH4EmFv57Y#F zG#>s)thfA@ttewTYY~R?a0-j3FzJ(u^p;=kI1F}lhsh?VPLNaeYII%yO<0QCnKGgL z#*T8$gSWNTYRu>MZ@OvoGi{kH8A@^Bbn;SN&5Aj=CnxgGD8N{AZc5oB*o639V9f5B zwaCY3PBp8S)xksobE=)cb?NNmDqknDJ>Fm5=W*uT!)_F+C!?+kg=OhUmvlUz1$nQW z>tzPqSHW|>QPyu%w8RnH#tkO5i?hbbxb1M!oC8N58M?D?T^Ex)!lr=c)!yirU6a2gRb2xQBZu!%#$u@&#vq!fP2U*qu<0O``TCdl zgfvNxXMM3%W`8!sh&}eDwAkSV^Hnt z7KtCf>@JZW!b0W};Q3>>Xe>g~g|>MOU|**DpU^-&e)nmGwqcus13^RJP}Ggl7jLXL z=ZU?Y9Cphis7Gm4pt+G3Lrx_0)4bDTmZCu9pZx4clIgt(0UwepADAma|Msn;E2c3( zt6ydXW{x=c0#Y6LUbK@*YDo`?puzgq0H%6P7NRQH=7{fmvQr2?W73v1xd9o;+0b;l zZ5fx4#^jq0v8T`1i`C2Q@QA%m$NJS-f2+|K)$D>hGS(kuVRn#ilL<* zMu`_mY@RdqBZxhr3sd)jTX_+39iwTe*y0}vlySVcGcVj5);~P<$H^FBG`6jS$;S&y z!T1MZ$3s^Ae$K>^5*|D!Iov#ObymC1*Jo6b?sAWN%N1g!Gs{m|so8ufW)eej4xFj@^N`D>mM|e47W~Y zT?}neSH3(_1hkzo=m?W6%ML=(jJH-+wQ4 zY4<3pSy^?GAw?|e@T3RvPp)xacFNH)Dg9VV4hg_pZW5bN{BLqYelM&!4pQPP$Tz2k z5inm_m_Kw7@thcIaRLAV7-pk~!`O)DL+j@btaWwPF4v8*G5fST3PNgV%GMXRLAx0I zhAS;e7Y6(@T}eXRyW~B7-lEt9Vb$Mwzx{e#xy!7wJFll${_(M=K(eqBlKx|-kOhk1 zc5f)RW)Or0otjs07P_mxLJjcOE2O;f{3GlQV-kVXk(ht!qx|PxU7$&qJMjP*OR3p5 zp9R^P@&rcv#01^Qsa|^4)fz>`%IQeD5)+SS{((#cMqSr##CQc6JNQ~?5)B{qldyM( zV;6?>E5idSW3}m#MZpA-!!v4;y)80@me_pK%Sdh^P7FfA~_xI*$ zD+dr&Kt6begzrIM_9nt8Z!j1URY{Gk73*W~L(wt*mVcLNRrk2J|0zJ%iAx!U_{Jfa zzjZIYBJw38eetCD&kh{KEh#N6ztP>&J6qR1+(?#YVUe$oY%{rRrs7uGz`%B`)vwWm1C_LOgr$M^in=f?`5$MaLg5}yu`p}ih^X&`J8DENx zeEDN=xknQIB%AsIhCr={|L4^JSAvmU=tOZuRw<17a9gz7Bt%hg*NG~i+bLP0VJ%Gr zp-CMgo*)#awYcYVI4)Oaq6#dlkdDT5EcJaC{mPn>ia-Xu?{R162w)$Kr;>OVAMpGT z5iT$w8u%&!Ckq96Yg8VlVfh0gJx&%qSE2~GOn-l2Z92Ttx)i)b_48WkECq1tsx}q| zg&3eH)?NQ>L36#$2sxyD<29ituUwuzFIBx|MBnDi zfh*DWCgrUM2KHMO=h;$0rsc;pQ<(I!#hk3&l(NgIvgGIU6W;E`o27b%AySO#W@{wm zj%P{<0MYc5j7=J#rYS(HvyuH;=QFg|p!DrMJJXyU(t@qtBXN03DlO1;Dk}>e7Ivbe zG6D(!Ha<4x&>K}hm~pM%moNJ_(r9bFNuj>-EAo9wqv63aOTF7*Wyry6Znw1Ht^>U{ z*EY6T=2kgP&Lv-xh{&qp<69d@v?q^BM#`}H$>DE0{|V*Mmv8j|SNuq|L}E!;{*3{9 zxz3|8Lisd)KdR7%1#G3%`of^>wH7FSw|#>++%U)@>kZbv$@@CZ)@?X?txYd}P8}x& zbf|IMs8rkPjj5of#r2yUn|=g~FyTM*yST=xa19kB;R--B`-jL0*k@`{of zBMlv82xsO3XHwj!!Q4q+Ja=kr#Wlk$>tzMARmz5Ke8tL|V$Kq^lMWsaYs8*_ju2ZBDOiBA=TW%i|6%<;N z_A{i3Z=Iu)EKM!*wgf;^Y(a}b;lo;;%P5rHFU=xKOPn9&BNvbW+l6vlrl4?*@9pXX zfUp=vpPlmX;mu2yVt;X@GOjC3fosWXo65l=qHu`nBZYPyamPwKYG)=Z}pASNgo0}3S#V!(@j z40yWJ8v#~ISQNsF!SQUF@_vB3=k2Oti%2iML9 zuu^;!?RRf09=kWtDK(oI7;l(>lr~8V6m?=GlG@4&HIsB^W{I&fNSwoza%6aU;0+r| zypf{Q8fmWI`>AshF`R3ipx>1Pj83ACt2s&GKBuOb5~5@DD4eskcXVyR;*SH( z^UI^_DkeKyMNjW!G0iI-^q)Fh3{7OvL=KAIAc=n9TuXcD5*UCMC1%I?l>bGyG3+&H ztQNs0em-L0{5B;B3)C2*-_WZ{BK2mh-*49W`6#+dlmYw#W!;FcXcbNc&em+vGBK*N(+b%lEk@|&Z%a-*FK^~L7bl}XiISxydVxy9N2b=r1IB$l{`Q#WHT zZv^+xM1utB#NzvD+}G@bXyratE`>5bw)*|kO={|C%PnPSuR1U~!e;jMP0~hB8ZOKG<{PP2?u1gbaZYw>Vo#~dlS#LSb68>rvt=nK zoL;$@wvQ;3dasKq?fIOV^+Y@u13}Hmax@;$q|8^(hYUrZ-SYk1tEzOR73St7y$BDt zQ{E$X!P~fP!$$YxV!=G_S~hAn3jEF=v-b1X2r~QL>V`6}q|3}fUq0?q@s0*kcfXkV z<2D%Iu)__5!~+ZNr2dga9G|mJVic4CGs%A0qr<`?Y8BD1&Xii_ zVPuG;Pa^Hc%K5de&9u2r>y!3$K?zRpdgx-XxNUn6Hh-18LhuSIV@h{mQ|)Iqs6m;i9tU)f9zkSQ>8*vg0|`S#OfcPH*@5V5qCD zTgS@s-Id_8{e?S!?B8`rBy%p?yXxoAC0LV2!V6xga)S0}{#xgL?dCjo$uylyXIH-+ z(GTB-DT4kFdN@}wuHEOyB|ml93ebYiL5S#cfiBcHFv}e7%TIv~eMPHF11~#gz+wGZovSTQq^{-Z3VU zBj9a+d>M!EPIZQVJIb75Rbc9#1f0yMh886552^K;W>jA7=$~)HvF36UF*X^U>Q*g+ zsE%4R1W4as?Cx&t!@RVesnlPyWeOq`HQ*dyYeYcokWgen5q$p-V`mu?X|uI!oB;+H z+}+*XW^i|h#@*dzaCdiy!QI{68Qk67_4K><{<6R13C*7;6R;{|%bsP6% zULiVS(B?~qApLIa8s??|F(9!u{qq$D<9+=DL`>*34rI>>3ZL7f-uA#Ef7N|Q+nrN@ zbt1S(zX>9(=izRiO)aJ}y*IPq>BU1Z69MnDYczdJX{fEhVxWMmb zTak5Su8@7lg?JKO{62cXwrC+J14rrtFAe6E1LHO;SA<$gWQd{vdlt(ZmnTg+GdzDE z88C)VyC}r)s%dEjx?xRuDEBin1F^;%558OTpr;_MrM<^NkGjJ|XVr$Q=Ps_~LF8~4 zvZpa+NZWCu&eVUc^R zAqThDcJ*Rub9vT4ZD}J)4gBl3HoSYRI}A;||ED6l&jl0wzdB;Aco#(e71ozm@=n{m z&jZJG4@^0voH@>tA7{Dgwj#+;R(q-=?hc+BS-t(>OS`^o(CttS5?%7dO*y0E`?>4i z;-nENM6(aCFKGel>Cp2Hz2(p8 zYizdA$TL@hEl0^gjGnF`wr^h|^g6(U3v=8xc~vWV1)U@uae6D48rVJux-hBiN3~cPti-k_35gr16)~5WRcwOgZTQr=~C*X-U08x=f7V4RWL? zgnaoJj0z#w{99&Sukq!5!7B}>QvSE5bWi1pk8IUQil`q~Y$m1=i|g(O2B6-tAuYZl z4hTlNJ{rwf<}x)-yfdIh?=`3;M29P06-?4JxlM9g6u)|8OJki2QSppsdb~H$mSTgJ zB4t58H=0S`W7x=$vrrdF4%TYWs*TdXtne4yC3-Eejgd{KO!JS?mP-oJr7)a zx8p-1Fc`=RA*)^m=+Tac(#aQ_(Lw^~^URzoXlqb&%7Tu0*M9O*oEiUaN(I_daB8Lq zM!w~l)@2}d3x$9LmHo9O9p&+S#3hz*vuZ_spwn$amHNF6hmnIRX)lfS!6MU@9x2zf zKr#x-T6OU2C}>Un*<9#V8S!w>-LW#RU=#J0b-)GN)u@Qb^?unN7K6&7UIC9W7su1* zBg}h=n5)JKx!v_DPx_2s*~OFn@7-bTruVI!__yhL<4q&~J%`%eYeCq|an(^?qRj=O)pS-IE(O|Kz%>5^*q9UpQDEkrNR>Kwi9MG-eWHu8?fd)<`^`$Z zTAMg+Ju=~zyUy-;M4=)2((B7UEl_zr;74?JXP8*nD(a|37GlyS!|8xqe7@?oD=aeEbIimS zjz@0ze&mLDy#BSjS%&uQR#$shg48hf0I7E&m-|Ur&GNW3H%Ri&sVP%L8J;JThg2Kd zRQ`lK$8<-ZVPYE$o3XcS*$&#I^@~5(3S!Y!F9Klfw0RC0)z8k0+L}-Ao8%_?|3uI! z25JXpwWIXzUL?pq{j~+Y&A-I5g}rOn3T^mLUSp2@^oO3r#g+~)aT0T(2iNfmSJ?{r zl0x=#G{i&D1_%PAQQj6~$x_n>sRwoo5jxccD1N`QIvR%`eBC3~y(&*;QW6t$xWuFg^5Y$dLS^>vi4=b9>e)BZ5c=%# zCt^6#`7l9w^Zx`n0p1IjIY2*Mq5R}^Xs5{7DwU8i-z<%hNtX}~U;L5=Da{b0;KHjL zU%W%KHaesQ(ER2+LyKF!HpRMeEtLI5abwL#E0Se$#YsbnO|?^o5eAEd6qgHaGTZ6~ zN61&^seWWzhAEPduu|ysUqQ8I7<$~4WmQ=IG+p)-Hq)m2pRV;nwuW9*zoK=vNK4E02Z{5| z&JV2qR5s6-5paJC&-$+8wocyZ{$K#iV8zA#NfZO$m-GG2>i5wr4Q*hgP(QDo@A-_g zUvc>NN@L=&)06;{oL(tp_<|RCtESv#agE&VUQ?RX-77;YWZsZFnyr++;DF zidX)%Q&;rx-TURB{Wfr=T@XTqp>vag>JZwrC{Ycq^(IqEQ}p3-xwZhLPQO1G)fjk1 zOZJ-xHC0RTr zf95IRJ4O@BX@Bk9oNKb<{NAO7@r^K8Q)X>{KIkJ@^*D$g7G1LTitC3Y(P@0YU1 zDzQ9VKIbqik+JQIN6k!NzOU%Q{+o2 z^woznx&5#eb`{S5s;#$QI5N>0b?YTcX++IF;^SnFz zT0H)mUgVf++&S||HXKI}JIb14EoxmX?0G-8i2`XlcvLMQ|V}Tam z_;;_DThK+isg+zuIYq-XUSL-xub0{U_DcjuPMiwd1HXko2+I-e;YqO5=}a4{O>-<~ z=F5J@)(wsV9DW6)6y*SH0|z_#c=nt+j|l^8 zj5Dd_+6NFbCIwMP^mDlQPT>{P52+(k~x-#an5!?IYB)*1!FceZXdK)%N0~ zbs=d75bnrAoE^T2P0wIHJ*|r?SAXTR=P}dm<}EvQ{0NM~nQnn;MbAFSGGEWcvm+a@ z|E;fv|G)Ls+bcp5svo`}GU!9}+pzIYvzqs3fcOe}o|EllG2Szo z_y-QF7~H>iR5UItl2XdB6mf?#88o>Gic?jJmz`k_*Iku*?sBeF8U-5ZuO2B+N$g1u z;cBzo4$nTP!`XAhlESjxy`G7h9B)7Y^dwGq3XncFcn9%4e+hE{*V2<~Z}TAn;(MLI zwPKxddklcaz06hS5o|f+hB%zP{`W8P$U6M`_9ol7Wf~~+MNcPYGOM)aj|LTnK|+kL z%&b@+DxJc^XTsSQS7c~wdh;U_3YIgTk@cZy=CY0iW!Kxd^Q-ANtY0^y_{uaZMxm^g znxum+!&fcT;f8E4wHi!e8;e4+F;(R5SyEE-5}@o3z#L2IX&rU2Hr{CI7}&7HV}7Ff zGrUQi(z8EjwCJCZT+IDd0O6#_Qy$@_f=hKq-?^?Zy|Ad@opTFp1R~=SP1)+q{jG!D zs+N@O=#P9jR6zi(#o#uj1Bj0NLpV#bINeB&GIvUSFWMMNp9NZp<#Uf0_;KRwErz`2-BxspL2 z%Tr7I|1FLtHs~z*vwPi{kLfi4C{JPPdaP@6W`AidYgYa+s)Z0HwSKD&-KW%1I(JA; z8kYz;FM{bXMUFE3bz}bE9L{_)%hTtZc7Az8h7aWl8sHT>{VV$WQ(Wp@JIZMoe<$G4 z=aLQ*uaY_Hjz@BvQkO|=J@MO@ab2U9g8d>UP#IsTY{K;bND8#~?ld$=<|cEL2wL3g z3LpFTnbQv$3(MTmh0yVE!ggK#&H6yrq9u6Smp{I})ne`~;gph@t*P~Yv;c=%=PM0K zbMV}IrYVliykS1C=?^vEOv&qRvFlp<^sLz7Wot-Fn`N_!w91qiq`EEyt{54J zyj8St@_SZvb6q1jMq_KN646wRO2^D2(&Bd66qu+kdk=~mKKAcUHX zYM=nTF3eA|Sj{{QE{A>%i@467T|Bo?I+cCWf+b-sBSU6=LmIrQiMi3?NwchUM znb2`?r_96&1UbARfxISatwBvGPncTor35gYck2lj{Qaek zd$(#tbo5p4x;d+W1_1fGu)!ws`|-W=3Hw_f252cd_qRESxT*#@kshG;u|I23z&$yD zD*Qe!`t1Ko`8E5g(=sSkl(qBj(%2J%WT8amo zZtQ`7v-6H=X=icn53hGbNpd*qOYF@Z13v88BHhITW;E1uIn;BpNM^7|)Zc&UM6Z8i z+p;we)2WV;o_{WOzNBn7Nt6Mry2#6Q)J@K8`H84j!g^E!q&$Qdj-p4;6&;a3;&ucZ zN8>hFE8~{b9A&?2~+|qOKgJC_E+X{_GdEiMo_Juq*(Ge zmXs=&=&Q2S6T&p-u@VGi$`1adPZR1PXC%7=ky%UE1Mr!*8tuAnB%H+v{h2Mp zk0VfGejsDDTl&KM3_uJpotPA^Jef|~pt)vP3POkBg3wqV(h!MfmjLy-tk>{r`)>I} zMIixvL*|4D*F5=T$H9 zoh5`krkBe>H)jS_cz%())}Gv7XUFwM9CYC(Z~|&^(F@KCELI1^P`;}%#&DIj)Jwqq zB5~*5yar>-vuiZ|V;c^~BTA|}<=AjIx&UUOn&4?>bz*zGBUfok*?D)YH>Ujei(5%FG`!Jj(S3f9sTv zWmJ!y;^4HUr+=A(x8W){^cEAcj(4ykA`B6mdJU_6-f671BTiodc71V@?{=riT-uKG z9zR<`l6=-&k#RnGduxVhT7JmG58te%&9up*C#uI`c`2`;r*+2@ZGHCiamCb(q}+xE zf01tTwPyAhiNaQ=lbEONBOwgI;jT2of-LpvWCq18$oAb;eE%mE=SJ0E6pC?%A6;_lwARp@XU-*_9`Dr{`?&IaPrbW?pPeGiTYrt;-RbW1?BOd6$}bk$TF>{VltGf1Jk z-^s9Q9ayWvhEx7AZ5M%xBkRSb=VeoPh&qOZ>ArlAqPJcfh=+lGv|15vN3i~tb6q_k zz?CXQXh(^vW43Jpj)r{g1LmisFF!ShJ1LnbUl;|qV>kGX>;8~WLbOK$@qw8oyk7v9 zWE%_NpptNBIq8coQ3m)M?QV%AdsT#;kb>fB+3a?Na1iC8r%E4Ii=~ea zREFA}Qn*o8{^z;C52NoZeG02y`$WlA-geZf1b{-rLYDNItY^Fd2<``of2RAtA8v#X z95~0tePe$IrrxERId9uA7^nmJzs%^^N!<1M(O)KseDg7=t8@DSF4mC24gtNfIFU!QRRlfq=EB8^s=#-xTZcxIA0d zO78R)vfWH4;`-)sVR-d>4l^J}4A9&@F7T{GIN4u)+IhME^yn zf&DjVkfDfrn9XIh$mY5hBiO<22->gwLhx{9YvC-8@dT1!H6w_}i_w5lBf&3*C`A0@ zyU43Gx&F6TdU}YUIqyU6p%xS8Qq(VML55mOH_u{%3en{^L$?-ZSQ%ZXos!OO1KlE_ zx;jqxGqS8?-X7O7nBmMrOB%UOy}RUL?F`f}zT)<7;$KU>ePG``7_pHGkg{}Qh^kRI z7eOP+I?~HWzvGquE!fb3&wJ{bLuLi?{JBF`kKx#3&|!W3AD;|r8bAUN`l60;w}f-L z^~apk1(|fx{HFT!sxoFnG1+LTV?e)~r2UpMLu?92B1@Idb?uQikuN)Yw*7ghgPxcm9w zU6zRdEq@$cA0naybL_i#J)g@*OTtD3`t8$)qjnQbz>{IQk?)t}NOCYTAJdCFq2H2{ z@pR&{!|>DAt<*`iI#&}LLJ!83T#vITBnI5P;;nnaB88!6f5he2PmLm>gFuBeN zxBJn<7#8Y%0@SdZ-ALYkUWs3pEK(NAgG*n?jW`@rgfjZi)|Vm1Q`*bjd;$SZly$)a ztBWJyd3;zMf5UU+s)}48ExXDY)5E;0cRYR$*HDkn6Q*JeiAP!%FMWP-E4ilVe|6~z zx*`fyLlPB13u0m1Bke5btcg|%<}lh>F~BVv{vWSpW8!|MLbF&N?12_E*WJWfe zPA1=y_;xCj1w$PGLea4}GmC zKI#;Po|k!!ZyR@19&`{?>+s%50tX|NwyZ}Tu<`u zi;-y|&-jJvI#NyA718{*>l!tD7;r4E5*lExK7RbPAmbdvN(JuDCO&a4o}BPFzh{{c z-(EZAvYJozlKfwW0 z(Bk*O{QdXG82!1KgL4Kxq+wAKx81u`j4istsR*6#cwaCwA=46RJD)^u-CTY%hA*kk zZty7nAFV4MSfCjg%%)4mt1=^}b5y8b#9&}xq=&kTKj_o9B*LCOON6!8Y(Co?G}vh~ z>5+a-qjWlczP~X0yt}nJ97vKUu_ZlQW595u%K0mdp-qvgMi-HZk7NGjS7VU+6`&)j zr6u{tclU7uoz#qG@Qie^DTa?DG~gG-h3HgNS8+F_>xhIZwu-{i@pwtv1%|k%#Lwsw&St5D_hvfb?js`XYePKC%29(>4 zJZf|nnVrGxqM6VeYM!RjiSM-_qQtGGi_;IU=QoeiWDp38+wDJ?=1b_5Xy;GI$t?;n zhF6F3&Izyg33qX$kVjAYCMu#QJ6ubtAx$!wFO)VmZ9`+;hCrPW!lOyuHyGU65=DMIq+FF1hN*Ulm&iDbFj3bOSM3lcVz#s_iuZtUhEPuRkfpBq$bg{XA= zSCaii-hU1oa;%2R;oW50C>V$bY`rFy^7_iB`BdsXjZ_uP{ zwi@@=OO9X@R(sTQpE;W2B@%EGVWz^$rzU55zAPJgkM(4?*q>mRAYbWm{%JSVpYSct z?G5H98cr(H8Jz#fXza}y6J+6JD^!c)BdZ66+Pw?fH3Isf_Z!+_kZHByZr@A9LX`&1 zB)9I-#ERo_C7!u*vqSim%t&%9*JCDk4ST{=meEHZ0qAneJxSMtlj&*2rUElGy};0_ zUSS(RJH*V)69e{PE8C#+3w81PSDf6G_sIGRIE>HXaN!e1O~Dv(*GV}$Hx25EMANn4 zEyje%9WgidVRLUE!w=JOMr_Vgrmh9XuKVdi#nc`*?2B8YNS!?fP&~q-bMU8WAum;Ykx32Z(`^BJp;J*qI$ND?!b&Z+4Pb|L>K!M@M|Ii>5I8O z-$m}ghfrv=(6JJ7O}8%Xj1RNIxmp=;rtY7ynd-SW6FHqk8cky{1^simi!3%=)X!5x zyBv6U)s=SP+>vh$>8Z_)uxlPzW3)&MB1lia^MS}QXRw1Vx;U0a?_n_4sYU>ScgA58 z-RAO|!mzTpoI^#REU5+nYHCMMbE=I9`tMXQ8Ki~V*-#=ebm!A2>~oCxO?c&UK!Kf^ z%Lq#+BR-0gWSg7l{+dS3$9YzoCSL&TkX0v5=ry;Ylv2dnt2Mkqk zTem|}TJbV*QXF1(P2wj!GG+Cx-4Yc4S|~71eb*qK&JjnhBQuKT z!~1QY^t~bUU0!Dvc8Etyo@t1JgHBGPuTSRutE;+ImTANk5(g?tn$VRb@YC;*4}5+P zQjb^8iGV}@GG%!3BS)SPb-tg>Y?CF-BRS+EXol`b8@OPzp!hweNINu9x8SkMw+$%$ zkc3j6m)AS#tf{7#tDSTlCwIKkE*GLTfpW=gs~c5d0_Hh_FC;NbG}jtTN!GRh_O5O?jGoKfG?Tm#Qt!l?xv}D z($k-_TX?O*tI(wJT3vMcVQ1bD_H=@9d>U8gbz^n`*>wbNxJMuFu&x82of3xif=e#v zG4L#7dhEq&(c=~K2`kl{=CP;({lE6O*=*!8jkm2IkqRZ^h!zbhIU<$+^Mk;OK12t^Aql7vAW^4$`? zZ}N*ybx(I_2#uyqwZ*eFN$7k*pzL7y=!qP0oUHF4Op+%TnnxW-d)CwIb2JMdB;B{j z>F`%`dS2q@76e;PsxM7`kX}BdV*Yj@iy-OAtKTebGEAIu)L|`C2_Oh=?&-3^$;J*U z-6IDjs@<3MbW?1TWHVsM7T4%xda<+A5DRXP&cD%dJ`Z;1nog3c#VyI~ZB-Slh+kJ6qga zA;`xC19R3q3tS39N)rm(TnRp;O*f^rS>N-lIxIRT4X>@SkuLl z;rQO+IbJStKTZNrB$}e4*rcKhYP2}EQR{%ca6ku|bv%EWE}g_78)7|WX>XVqT1Wg#<)bq4i#lceUz#deyaJx5ZZFsWR7vC!Jx-wF^G&U zRM7yRwEa$kgw$$?s^Rlg3ld*nQ_s8n7Q|Y%E}=Q)OPJ*GLHRophly85%X>Yq__ypB z{4y0wXH*@P`hH~?G(;@>fkTA2aQH_tSf52R>zGa5i^MF2mJaN(5X&1db$Gg zkl6}G&hI!NVoznbL)X?33)S~V4FFx;#}(ycgU}2pR%;3RChcrje-%JZnvL2kz9Vbk zk?xj+O5?m-N+ys) z{^^s&^|R|tU9IcoLlx>+YI7MKI3K(^zHrRXW0lh798=(sh(C$v&Pu@Zg(!5J%JGZX zO6_yjy>xaoU*Tu9xJLF;YPB|tlsDa~yJcf^HXveu1q2t(W{UzH+)^?-Ue$$#yIvpS zbL)|`@ErD@sA@@l-w%~enC{EfmlTz4C)HfwUE>6Uv_>$7!47N-M(Ql{6giJ@fGrOX zZ~4LrcmJ9cs1lug^E@-5Ipm7Y%Qmwbs2EaNvfMl;##`IS$UAJmgzus}0}g4*Jra|^ zRQO}jp4i-}i9`H_VHYmw{+>JC-cISaqR;|io;CZFnsOj3*WFNx1$%;28>Z!Y8e+xO zJS4=#m-@sPNABOa1C|f#k~V(L5~*cd5=+qo(6dy2VYQsqx`~j=HHVUFbpwmOxOG7V zq{O#-7Ijb=8rbn;B9fKUFHb`Zs_q8iq+n=aZf9%)u2 zjV8M`klPgw7Txi~;+7a&${<>2gAomJFM|%eO&I3zDdH0KLM*V3(4m{Nlid-sbX5elc;jh0Dn|{OUlkM*8XTWI^MMbB`W_LCk}1&b&x>XzBiL zO+!4_;Q|Soh0E{DvG_pOm98E7W95xd*(uq5|APBqccIj{L^i%ed;ZT?$>9O{{mGU= z<&s2|;zQBj^|v{%MZD6-qIUIG*;wu1b>=evq7F_jIwj{q)#o7;e69FI zV0`}_zWl}wS9(;KQXG&{+-;cbU;7b0@LF-8qI(74c`yZv!za3-&< z^Mb@6Txh0rw=ev3>Mjx)Q()xT?5*UZ-p2L!fuFs;ep%}BjroZ;n<1U zI-?}DgfEg9nP|^sf$b^PUL+*|s{K8>h5dOwF(ao9ffyfUrR z$VbAN;R*NiIEP~UaI?Y{8`W%<_6M-azc-40MCljYd4e<|)f0%aZDc**J+XBpZycue))2&MNk1oH*c3) zq7-7lpT&H51g5U198QmQ+=@JxEY8=M96O=kd#;kqXFb$VJQTA^`3E7QD`U6bV ze=9{kF}I#04p_I9E53DYF0~TqWl{6|+HI2jHqXMrZ~F!s!2rQjw#Mb~p&a5k+Qp+^ zCdZjU+uE8Ts@MxsZmD7lZg=2uE;Ek)#7C*!%4Y%Qa^1Omcy#lFsyE61> zKfmnVi0X|&OXfRe7SJNrG+iWQdeXTWkpB3)GrI{gA3jHZO%PM9YGXj}EKsT_zgCf( zI}KVXNpLZ-Od*E__m8`IbX*5Gq$72NuloBVh!>UTfR``AAvB^DX2De=t>CgPb zg}|YYG7YNn;qg6G2DUuS2aDROe$SRo*JpPG5RqA@21@3h}i7wep z(7)Vl0A^k%lSjp}t8(K(Z>medL`}e{l5R zcA53_=wQ>!y@&(_F%#VK&e3jl8V3dvTlY27QjLwZAlQVpkBXotzCbPe*50VAm3G3E z)8%q2yUgX#(vW80bJk%&CyI;mjpMnyJoe1&aS;M}FZmIPqAv$_HqU zbz=l4c5+iXnfdgbk&@>jO@7zk3-n~iGAWcjisZ3#nao^qdrf=3OduLqhjHF}zT)*l z`t`PIkC!w~@#y#!6gL%>F|fM*Fnmac8N{itE|={D?zB+3MJTIdb6N7U#!DopL0fr5!Hec+ECxl5Jj7c0RGSEZqG zBmCv3Q`d4$Hq)7tR(qD<0wa$p0q=#!3k<-2~D1T&YTyoF65&)VXV-@X*KkFsLY=jjFc)q z;hg$!wro;bsB`nC(~6T^F1Z2xjalk5A5yZ_@0s=q=yz((M1fEl&u^t{Y-Pd(x#{s9 z3_0zwXT5##J^;guVfXV|q^G+WvuB@>Keci3M{@s8!4;4FPSI=jt$Dg^{^rD$r`KBl z1Qcg_2}U^6m@hohNb7%|^E`pjyzzQjb|WW9Fs4a|jt16-$ye8k){eRF?E~6{cYkR@ z-JcEIjs~eWzc6%Ve*CC_+wpY4DQQTjt+aH}Q7Y%*dPRd38H%UFEs}x0$}e9;DG?0% zY3dRQ4EdH1C<8EnsFxyh?fX*au_O0vwe^HuI#ER$2PEj}LM6dbRre#o&)>z9n!*6M z_WBfpLn~0Hj+GV(TK8rp{A26extgi79St^K-f6uH^>mmE$ze$@`#yMY1d8;9^7v%f z^gC{MWMGu)OAikWP$9~F=YnI-le&-0yLo}(^h&`p_o5%O)R+P2aORq)8^)u-vE(7&cTk9O(5sIGm zcYB^WNE77O`ii8~et;g4>KIulSC3I|uRdhNMJsYTlFQ^>q}1C_W;CTq-HF=Sg_+j7 zx@%FY^u<{o5!lg?BEr|#MwB+%CM>0aizQ+_iSvNoXI+}7V zPMO4^zfx#WRB`AoGk`to+<6i@zF+JB2mrm;7!PH#q(dbP8clC=1Yp*X>xQy#3?cfM zLYPB~Q}Nj!sYJ2>8(j772y3#N`3kyjx7sA);31(H=UC~`-w$B~!|ZLn=IfFr67yYt z(O5K{1RYgx?R8nBIk$O_-a^H&{>Wa5R+;mz*PAup~zg9tW{9LE)Uvxm|E7u0N%@$Fe5M3E;$NpNN z9Az(TANs%sSo>^N0QgTeX9DiDTkw7ciOP)P82Yd7jp&0#36^`*n!1pv{oVEfmPIy$ zgW(OQxv#XDLsASzdBD5F+LDp~wc~#WuQ~pR4-ER8n)|Fg-hC%};9nCpakZw&l@1Db z^ZbO_`Aqe%2Eqm;Og>*Js=Jmp+U`K$z;UtE@P&vwxv!_Vs@8pfbv|Cr*XZ>EzZ$?>}lzEzkh6DkQ_HV@;mzQ_0KSA+5MR#i}Kh#x=$Oy zm?y>ET8K@r%~JpJvO9tS-65CM9OP?x41V+RCkaf>dJ_RinXQ+w5->98&ugqIwTqsc zMx-o3I-$EPL{{f?5O32u9#sim$tN)BB1);#r@6TUwhO}Sr$sDOC(>O=$m^{QOot}d z1*@N`w$In8srf`676q^GeIzfz2C1wFHV|AtQ%B`^stk0Je(;IJt{)+iT8*nYk6U>T z4M%}zT(|qgt_JLinl*x~E>Mr9P5wyj@1R}Uq+)=|ScmAiKk8laMy*^S+8CR&)$`?L z{~8JZYgziYjqWTOs@~M5At61k?ceKKUjR?iABlm^dHbsN)2Y1a+=N{MUN{Ot!W1Iz zM6=_@zu(gx@P#%rQE7Fv6cMm_W9-vCS_Fo9zl!bBm=j$XL9ma|5sh7|bWj)g@(d=q zIW=&I7H}V5{om~0`-9ROEx|?mi`&EeyMA> zlVT{%fb-I?7iUV*-D;XE960cJWZEH}E=G0Y?vC7`fUug)fJ83+YDdXZ3q{O6>KxT7 z#!fQmnhn%G8V>4KY?&qOI=zUe<{>jKFRTGcexMhNaPOYKSgT+EptF=EuU0Qb?nUa` zD2Gm)ze16W(j4(5E9kri=_E;?4V`^*h-{aJXq6$K;AzW}!{vC25`{Q>C_Df2HM-D5AJFc}u2XAxUpA$B@g;#!TQpz$%ulgz$#_Fp+zYj^sXm zwlezWl=7W37FCh6NutBo!adx-H+#E;KX;IqXJTOLA!2q#ZGWDKub_&Y^-?K4hG`oi z#pYGsXYj zYKtlrw(aZwG>?H&1q{XqTNl8SXi-BLm>|mkLCZ@AS^@g>Uq9(BU|7P8CLv0Nd-so*;(3^+VwrPk11F&+_^;lpVf|&c|#%ono%cP zLu%k9N?3bYd>}}Mb<{PD1UeeU!>04)^(87W8!-Hs<*PrIOMEz?3z78~=h@BE(4#5j znx-CW`9e%P*hg?g$=5=;Vdu51%j-$zUcVHPAn2M^nbOP+BCoxry$Tv!jfc6(Rs{c9 zOujrmTdUlI@xb>m;B}p^<43MZke*HD$tX|3$1LkzOhiV;3RUSA` zCn}K3ki#9Wn;NE>R1wA@!{ib{(N+EVZ0_n30lD-H>J zl6YL!Tm;b3h@__j6nt4{*Rt3(h7U)p!aztG%+nX!gujNx4aZf@srU}#snvwwgZT8& z1$XAgWS$)6RPv8CXou~_P+!-N#&R^dhK`_fx{<7E#_9KuXYVmao5gp3IUEe>`|Ls{ z`({vUg=-&jcz8|Sg;4Umq{gQ2o zkr%%-K}keoz_R?@*XXw$?U+ZMFB76pV2((@D;6BWz6N?> zA`Eqki}WuU^m73u@9WJI?$uNzh|0y&!Tl4*sf&Ek*c7hx`Fcb&=kPbc?nxKM?X@eU zEHVZWu_#QbWkp5X_DuABO68~$emO=+9sgLRiIY1beLV66ntK?u@gws69?C9EJ^n2U z_vxHKt2C8I>C|_Tal35~5YHhOs0-{`gh+Uoqk%in+TX5W0F! zKmFKAl{vSfk(Fld=WE4NvcOXgvQx6+)S@P}Dn9Akl~{=M0~{LDekmE36Z%}W9zB(s zV}(__VdA7E2aLKn+gr!(?W4B6r%f^e*R2*PoO%54FY1L?%_cXokSv?aQ)2G&K8Gif zbIcXK_Iu=-*dc_X!rqb2-GpHIT&Y7k^ctXva`f)ptr!kpOT%k^1MTT6LTLnjEqYpc0Zw-;TY^N(dd;w2Jvu!)nJkBq#;c5QOv9KHuMtt-vdZqOQb9>$t+Vqk#=qVN*3V?!+mo>Es5aCk8;F{b=*S2BaG4HQUO- zkhjAv3{ShLjn|ekKV^zkk0v%+J;oK*B&l1!p8Ne>``p%`0`N=pQ7W4P!2Z}i$3b7< zYn`nfS=wApa7!{a;ejY_vhJmY{nWZ-DPRBk(P-3(%)umBQ~X+=D7}mYrM~InKt@Tm z0;z6gjEE_KatgSz*Xp*s&K=-?Y4_J8|Ps85vWtNxCGeU`*`v zCU^h~UgI_OIHbGl;ZC)t9>LI0FpI*rUsasy$thU2hjCg0>`B`XfP>HVu0Q zAYAv0v`1}}QntsM;|f4gZm(kTVq=^P;BGAOHL39Pjb?B|cVNpp3ir9tAGN6osV3Pq zVkLZ7T@9wogK+lNjgKvy-&Df>f|q>re*YLtFY7y#5DbWZoVBY*Wua=|C){i#C2bh*YgWg%&j7y*gerFP_nT6D7kZR4mR zd_nW2;r!#>dbND`K_~1yAqB4Ga&#RDqT*^1ElT@giNpSY<3&tYVZ&l#rpkCtho}DO zpt@h|+ulP5#ehbaeAn0aF*F?ELDeZ~E0Yi<>@uDGi_Jtl1wUr`1I#TpfvGr}SX^kE z{mR(u<#DUu7P=QiPX#})T`R}_P@~uO{b+A*50Dj$iL%7nL7$L%DoH%kPMfsGGk;zk z3;);3Uj)IED~XOLx7qNEOS{X(^v3ir75?-H_Wxn;Et@I{maxGC4DN&bFu1$ByW8L} zxV!t{?(Xg|xVsH-a2?#;53bAH_uh^Duzz49HsVBdSJ$cP=&Y=&?Cj^sT1G-dm=e|z}MC7cCpTl!1>)>Cm zwB=R>dHz$qW+UyK7A7AHDV{(=ITq%A^TE;0KPoaZvIDdhrAtPvxKHvd-!q`N3An}& zihvU8-WsF7$eZJkR)x|Zs<1{t_k-JBGPn>%B>fgdreeA7#@PsrHh=Nii3r8`GnYeT z!{1Eh&j!bLnjW84Y;ciWO_#io_7($A-Q8r#vG0{IJTX`fbLT-6#M-WG2j4h<7^RwI z$~KuP@3ky699?GXbXe>mGYF_}c1OFieDR{7IGLcFs`FG&a<}=$eY8C_YR6m}iTBBP zFdii#y5T&?pP9a?s9ss;anLjfuM~LoLzqyeE=Hg&;ACla!gp*|;R9YCfIW$I_ZYO#L?9 zk7g|869}Cvo+8>slK^y2C37@h!;$`=1ZNL87P~RFvHIom9D;h^aWQ%~LOgG-#$bu5 zN#K>r=OEyL(51_y#V*C`%-}!u$ynDNA7G#mH%cvP+}RAnUHuO>nN;>32DwHui68NP z$7_m1v!2M?P^8x3_>_`>#}!{L&-X2gM^`sqy3xuX3JSzU9eRIWB%g^)g+H}TNxs>I zU3)Q9(N}8DkA=-@PT-SrRwAZ!hy7SvFx>nftTJq(+(ukf+9A^dR?(yT!=58}B93gO zWz6k7{{It5FOr5ELFSPAz2V3I8)|=QC;6@Ul9c_`~AOTJ4!sml>< zWS-L_Ae)~X*gRQ++pc4HtR4%Tj!*ZjS2nx3Ew9VgsV|s%)mCa&r9}T=bp`_iV?quk z*Qn7+*Mqt261Wy`TiK&l;~9FO|M453udmk%9bbL?tkOdfe@9sOmXKQ6=)zKeBw93mxzBI^}T8?Qmbm=!Kn-<ee}n}0Tnd?f z{hsS!x$XVO<@hf;JuH^iEeTM;;gbnP<}@7PLD8$%p`JEf?!@;$Z62$@sC z0L*X)$~JO}>k+N=bi1eTe9QmimVZC}%~GX&hkfyKSv-f4evHe1kIJ>Eu!=KWz)y>& zJpK_E{)ff?hq2c{KL1Sr#__xMmL16h^wpa2H)zu4kds;JklNK?H){Ls$0@&a1|$ERFuhv%y2Wp9Prrr6%! zG|0xQ!VToNQ^z_XiV|Ob@;JJ2>8}u+siFs3VF%bV>OmzURp~Ue3w|gHU;pJ!!mx5d z&|{BWb5-CHFoJ<5WHlV@l-AU3Z8Y>mAb#m>COZNJTz?PJ{gsssfET{p=>5LOKueAA zEfXkWA~MgZ@+sIMfk5kP8NJdpx@7*d$)Np_Wf zv2E;^HvCpyQTK>lN1CnBt1lEcg*EGdb6oQ!G!3g8$n%OPvdF7PF>fRz&nxX&HFvVh z!qp%hH3{mX6meenVT^|2I=D9V&+V>VFYXWJj2oGhpO*$x_jMwVwC1eQrZJNz1;yzCHmdyGR(CAe{A`Yt|QZ#ceNu#=)@s4WN}%w-XJze<|oNl45kB}_7fDW3(^}GS||-S z29xe37GJ&2U&a%jnS?uBO>A;jv88jtLXYy@(uFLc?&BcrXR-|-J!h^dNTh7dn?6T^ za4<9YGM?y|f0v2{3$eJsr9L7(fEW6gk?v?J8v8?iVU!3AcO@@tjW(GGYbam0_!RXz z_RcI=KRC0f#PioBbt#AUaL85uqliN{Id?+yz9wy7TAL%_dbJUANm%-yAjsTlvsD*D zP0T@o!Cxj6Dbuenx;nn7d@+@WL9mhhrK?LC?iY2OZ}5gU9DWOA7fv)@@gBQpZLoyq z2AOo2iKSVBOsSh=)Ri&?pW=;3Gfpow_THBGeQ4P~Sxv#aMZc|gTKMsK3N*rKA$&o> z#ZEIcF@IYZrjF$k8t5h(lv-^yuRyioR#&Wd-s9 zT<@DU3uxhtFV$*l)%>z)aMT;lipPYR zN*nvRA&>ZH;OC$}c+=Be(Yx946(u>z!R-Un^0%uoOni=3X%WwZdQ5YPxo2a8Y?85u zPJI6C;BjxH6NuVE<2kBc40F0+*HN1wX}A`ZREK+zEh$zw!sDM+A15*Vs&%9*RxMm+ zx7;ckF_|_ON5qCVe3)%Qz-pc}GrpVT^+=&RX#4ujY9#$X+u5;D%0v(3Ury!^cfCP# zQTV2<=lA8wV1rl_Vl!DB_mJ5z&wFp>TGLK(PKRrDKrm?dea9$K(wBWP1@J?g+*W;6 z!%;oux+GMfXQ+vX0YDJB_%?KPNpE0Zh1+vBunW|20Qi3(UulP$1#%xzqdh}Grws$+} zFC`~4kt>!?-`6lE3Opt|n@!I8!sq6au^(3aI`+<|K2o-*gr1$G>Ex1IQzrFX{#JH9ef37cq&xNByum}<3$?4EzrnBsacZed^RUly2uEo3)sWQ8Hi5wGNm5O z1J?zK19%Ggb}+>jy{;o(*#{wEos2E?|6u|86jK`g{1KtQKepNfjzAK6EMTa;GK|5) zN1@`=okC`a&pX!#nC>7LJ}d7*9zIVN`}dy>1f=-1(mkf|lIht%6S>b3R9Xd-kB*G7 zeNYmk;m5tq+VhzS3b?lW?cPL7gWuTU4~8%lZVR3GBndW0GL6Ojkm%0z%N2Q$h&BRD zN~{_Ie3xz-r&sY;+Wj-rlq&z4>9|*n=c}-R&|MQPu8qWkJ5ZUwB`3n=l*MM!G6Nx9 ze2ra-D`4rNVSgHN*mgPXpc6=HmQ`%GIeO)A@6Exl?R)TE-GNT874~Z5RlqP$BHz7T zie=D#88V@*@-0-L&kwkBkHhdiN_=dgJlv*os_$yWNvT7Ad7EpE^I~#*+Fn|NRwl<) zq_7m_L9gC6{$diP?XC!Em|ok1mm_wqKV^E^>k;e6$16bIk$vMb^cWkeN|um7~F zDB%nRxa|P`lC8hNPybWeo5i`}7guL14a1@{=2UH#$%Qt%qxIdCk`yvBeKLVhM1)m5 zKKP%iW=La++=6Fxn94Xe`%AeBVGhS`4Y^_C~dp#8v$H?Tz_6!+wcS!LXSF5!J3CV1*@3213GDxvi3|2fV zonyeyIst^K4`Pp zRs}OQ*d%v!Ha1CDen7;zv?TkqPEgLT162P~wKYp)<$O?oZKXKr8GacVvh(2i%hB2@ zTb`;S$~r@Mi4t44u>bPRWh_oY)7Eg{g9?l0aZK!n)k7h(=@MtBQ)R3M4IO^9fh!Sw z@1E%{XGz7P<(g1?(n-_PI8HM4@v6FmOp8jLf1y8m&%a>&nt3^1^chfLb6ZK(2Cw(> zZ;Jd^Etq_0;na;te@Rp!6v#d(C={v)%3uC41^)iG0{a}hnkb~*$CNY>@K8id|vmYfD66p%-qy58RUoN zd2Y7i$g${iP$l;L(zgy)K5n<4{21=mrY&G;@J{3VMZpMzQS-4S2Q zja3W2xXD(BT^N6vlp=g!-ye!lU(?fHxG9uaf4Y|LEK&kdgu~A6l)p&NhtAp?;oTiB zF>jw)l4t2oJgWHF??=tBX5?hEvINZD{pL*h_zB%aSX>6k;xg+t**H=0Y}Q2|0#DBP z3c!n99%zm%z-}dGpSbhQM5lygFS$P0QxynhM|L;On?D_B;j%uHy=cW06VvdghD6Zf zT()fshFGn?c^SYq`L-ah_oY|m+S@sOsIK1(tCC!qF;W z25um@pJ8#~WjTz*>}FsJ)X%Be&&4Mk@Adyxb@%2=AN>t0IMF1-M-UQj>72_<^I~Qr z-n-@G#hHE~3-CBTD5ie;lz;g0rFRGqIi56?Fx;#|OyPL{R3f^AXq7(V=c<@emM3X> zBF>1vH$718h;4Xty?>_mg~e@s#<`p)39ffat2^hI`P=BUIkUYHZI|>SX`cOh%^c~d zpD=t+@otYqBa9u z-J_@gi?Jq%D|eLE*ECsAlw zZH6_Dh)^)r01j_~v7v+YCl`;yI2>tQ6O;-9u3F-%DRP#%m{i&f>aO$(`VnZyEcXYa z?o~08L^k3N*H6M-o@Lu6l0ZxWtw*RgiXS(2GIcP;kodpKRBHfEy~?p2=$#7DW71h8 z0i188@5k~^788=TADwXn3QezCi*WY4DZRf^rnavy%{cXsxuzUTE{Z;Qom3^16VWLb zD1ZF2lWp%6i{HEL5MO+HBE_&FUL377eLeS4x8Qa;5e1y-kub3FPb{0h+t5dSGYi4d zyZ{OO?VPIG3r39P%=7iF=&GnY4S88ZQy>hZ@Un$31MAR~jV=T7i~^+SvSzgMOes*Cj1b)Ae)`i%k`TQd^Mv zU6H%hnwcUtt508|_TY%giqjK_`_61h7K%)iXu1MKLMD{CiJn}C@rTEvYtG!P(qsWQ zP*i*l&6I;nf;*M2uQTgV6D2LkC6=09>iG_4KkZE3HVm~M9gKx50mRPW%j$7-+gX)*y%q#S4*1894E(rqu1$-_@1_M4*sbj z>Xf3Sw&k%@#->zkH1?X352XC^KjopK48RsSC)66c6{qD{g zGn=rnUEDbWx&(X&($&?h!$&H2GB4$pY@+>QLIocDMPwb*!L*-Cta%EKRxaskP() zsO}}^bqgrDzhb3Yg=hRL!iZ(&py~4MFWjY%jYloqA|BG09w}%p6eNe~h1>}lMS|rX zA5`iOOFyO930l+OdfPB{kZ<O6-4ps!!LDSQflgMkBjYzjp<}(x9!`G5%iuUv>zg4m0Fr;c@D4h;&e0p?U?L~f(1pKV z8V$#)hOnX)h-^fFj|m3&v!61YwiV)qJ-si3?^qK#C(sqRN6Z`5>bwp9O0yWC5Mh>O zDsK&KH)ymIFknBbkBLb0qQjQP_lmTnLZN+ zEkFiZIL>T`-uiimjT0iQ)e9A%*r>AzEyKu<*cTkxqSUUAhb~#iAc0H>4&dc>fZ!m1 z58T(45r*!yzvBetNwy_1aLM=HnFKsK?~%NENg!`JHqES1Jb|T$h^=j<)WQ&M_QZUq zAUCVX@;6IWb2VRXMc}6GfKfmu7)xS|eJ=&yg3SvHg=zuoksUFLjnXnwIs7zGYX)LZI!lLsb8ot|s7;x*|>+O97? zB^*Zh<8ek?T_MJs)g3>o=_TJ&0($DIScG1~sjG(&Gv|U;|G_qjz6*C%mTmjx0N&xL zDQ3C;*s78X$Lp5i?NC#GK07MQEapT~i{D1M?}Uom3_#-5GO}p|QFn1!2=n@ve*!On z@7hN0R4DLu-e13aFXOlU8$C7~H^Q?Zq}r>1`nanFO0edaW_-@b465NFsxo#zAOzPS z_;4uT)?7!tj}}lWOxXK=x9`x}xh2wg+=PjG7h<$~l5f66M*;!&ALaZa-3EFpun52w zH1eq%TO|kl3HU}OB_EBZq>Si&8+F)>eCki6obGo0Xeep{%5!#b3cU!-;D5ZnlW*2(tvjSXy%P-o0u`_9+Km-t7jmn_hcXgqcR`<*Z@xrug7qPok$03Y`%ij}2iq=dj--zu&~{49{0*Y(>_x^=}@leSVjN9cX+r_b;Z)nq73Dwk@oI3Qgv62l^*R0DM)Ns(UH^b_#ggg0(6lMxhcU7 zR0t*0i0<`=MEIM2(15EW3vb7tBCLz=PDqy3G$%=QgeV0PE*xLfk==){D5py1GT?cS zc_m|CslWA1G?r?(89wCDV0ZrHiZIQW0{;2$%J#S6MA8!O(6ug8z2P^_8t7?j$7ZC@ zva}?or&0QNd7o!G10hZ4)TYB@1`2$7=U{;I6sLqol9L(su-ST~&1uR0G9S#7&;C5T z?VUfGW2O3ZXO@V`SmTTBNdP3Bd_e%m95D0KO3VU%T8YIc-7%Fy9g6j~Hl(r3rh@a` zJ$*|8z<3^ME|M;+rukGJ&oh1W8;0-r|%P4_lp_7`dL>v>Pza@R*i00%{(g6 z;!Rx3b;=`p^un2hS&wZ`a^EB z)0z7Ai{)bdCGfQiWQPsIYMJ$Ou>27Ph{J&cn9j?;>m3vllE^E|QmXBK`#mTTLl`(l z#gP)_4owAJA>e-X4LuoN&rWrOUQV1qveQYmwC3)Qnvg_{uu_NNMc9KOPSgfUK%UXz z*0u&An~bM+N_5o|rns$bz*f3GIKXnDc~nCOn{cB&7@W+iAg|*|XUv=nY>K|}kgRF? z*A(Z3EY(j+#IFXN>~J87$)S~L`7rMWfr{qZFF@xI;vs25KKCfEI`Y;w^4?MABIkM_ zloY@~y6PbZGScLm8mqPbeEZK0>%o17P=$?2=rrri)B}VvYZ00eX3rcGxAoCukSxT@ zmI&mxSQ?bXE%(9UF_SlZc?BwFJ;bIKh8XA7ZF^rifEaa=`%LRK=A!Qgx&Uo=tW`I` zmh!2WyBhE_J8fVqw1z)u9e;6G|3h8TVw!$U_Xbs{JDEHD>Lh2_zTcPHpHZBNA}+yo ziGtIL`3p)ZoLDLh7`%AKvspFj|7~Z;D*AI282;$$>KW1)U0($4zcUoEi{jsUH1F4K z77;tBFSHa_Yp$s(50`Q{yuQ*sYFL1MBmhc3%8ZOG~) z<0vynMXQup>jK%|mv5Q7q<=ArFr3W1ZqM}Xcn(8hJ)-|LCp}9z(~n?6 zMj&v*;Lc8K90&1!Je$`6yck?sOK!Xxire)RQm}7ty#;k=6@OhTxml}3k=Q8@9kWCE_^M^mKs7$uHP?i{ z{4H)tYj~>RteOW$U@AvVLiz8=IP`gm?#4S0q3E$vd3WGLXR%7Kr``633g6@h7o=rx z--v+=)0@ql820+w^&zs$bpOO_4i^Q0I}N4YuKW$^s|%9-FCPE=XrHT#<^5$)FNVJB z8LUdtITvLR%8rNocEDGFs`WH@mlnFngE)VR!W74=Vw03ink?7Du%?kt>p~9|&QC%B zAT914DS@AOF-x5&bJ%f4eVl@6Xl>~D)3~fqwdi2=X>SVP)_}z>`}W(;Z<&8Zr&SWw z$rm<@$8CezXSk?5%;EZz1GOQ`Ca~YRQ1&Wrbp#8{xb84%hwGiEg2)41MooX&Dnt@N zb+Ly55|kGK76I6`#NOHp&YmFXSHs`$2MwNc?EVEq=UXz8a=$W>^Nvu^TnQNYz`xQP zj2;qgIVW$}M|y;fsg3u$doVS>@d6XbZzgqhJg`F(x-H94p?4?tkKUfXdh@o@5C(}C zs7E_8eqk8SQQ8Cmkns88zLsfrAt3b0T<>Z_7_w#r#)^bb!TfzEwY|)N_!h9jHvZjv z>XWr^ZCLRVmohyU>agnoZmG)f*)7I0NJhY^8wvjl*nExEo7{WfAn!uuZtOTbzp&(v z6A=K#^&O@rbfi!@+L4NIk7N7hMCiv`Eg0X3tVr@8bT5mRyhZZDT;T4N!e)IK7Z=~0 z2^gT|m+MxOcu&6Gn_*bDOP^&9@jWV_7u(K94|jLM4L;4l&uuo1b1RIBX<~g5CV*wT4Ia}apHW2bc={`v1-cjR$j#l4gE zYhli;54|0xR|T-msFxi={3Z@q`Tm&aWzar08Xw!?^JS>vE0hll6zt(JMU4QMAbJ$B zlf%uSr~h@1$rER;rQ(RFkc*}Cjw5-mGZAV>PhYFP3UX3H831^$0)f#XKhiljllJ@< z+W%U<1jO*Uz9s5~Z1<_)y|VHJ7MNPPUzM>$t%5M{Fx^N1NY0h5STl5fY`#ya*Hm2a&^+TaGEu2Y0??r&paUj)snBUs5}iM(8=xTygxXFU6i zx{0<%N6KaVc0AaQ_ZMh<`DL*F4Sp~2q&Qwq3~yN&i{>w486HIZW;9@ox$1`VO$6$o z6y2q{!fkhIYJGJVH76G{qK)jCq*&9Iy>g;TM;#xxl(82~ZFzwy`^-R031+uo_Ol!L zb=8(?iu4v?o(ha$ZLg%AK@PY&$5f29#y2}~xJ;L7_z!M3SA+T64yyATv_}Q@ zPI(MGP^xB|cf@PmrkXqUCxmB;#bgv;#NtRpz2BNVejJH!oc$<)>e0!3)k~3=t3-{6 zp|Inx8`G$b1zv_fUAQo?S3IzNO!hN&RUXKa0h%k1`X<#f9L@qHsG6$}x}6Nw$2BNV zWB{+#!3?L3AK6RF_#ibFKXL#&ZG5VOL};86jk}kUm-<8bA9ADE8;giLdF|q z#(Z2jfwDA?ITN9TPx4Rc&SF?a=jGLG*I;%e!q2@DK}>t5TrZmEg}m#}q)Ji)O*pS@ zA~+zFSu(yd0q!(o{HMJyMAaWjwz$E7Ry$`E+{>CnG>BuJRx%9AHU2y(#6$6$VIaHp z=A%`G&g)T?y1Sb^jb7SDG^q!F#BGg0Lc~u0l*}nM_cai zPj(&k<*5-7E3wtX1oa&`q=?9$DKr~4XOfCWh?dH3%ErZWaBI%eGDD$~_A`({H|M-s zo|wmjcpQl|qd|WCWt_=|GDK|1NR$Ixo4Agn9UedW+P>*l`dav=KMjVb>=X3Zr*xvo z9aMAp%SZIv1mexkyj%pK2=8TmI?%=nJzyAEaJH&EZyzJXU@#05Q&y@7yfmc z^I7S3tQ+21pHF&?Xv>(|+j>)Cjnipj2+B~_XPN4V?Jd%xGejjUJs7MahHFiQ2#j!O?rZ*?C|Lw3p&0m*6>pG zDzO4be?7snH#9{L+2J*-@9@RNhaKLA8*c6RVn4@grhG#9xjAFNun-vV-a4Rk>u!a_ z2hnYsJr?-GZCdC8hC=_t0hz7%nMon=`qgz#Wc(hPkIX8TTShmV$(e2@Rc|4rVI`Kr z{gH}g2-_nbQpXv;`SwT2xW#1Lq%-}GY`2DE-5wmisrrTsZ zuR#AX!f(EcUQjACcT79)h*_)K9$(W5M;!EraBO!Zw%T_smqw!ozb7&|`}6ZpAdlNc zp3lpDnIiEEVL#^I!y2$M#Y!6X`)i@D8Y4YtS3Qrr@u!`wCigY>Ta+1kYF<|GeHX!t z!{0V&{$38B4*c1XR*&PYNFu}ovSynbtfO}6zVt4ZIEF-#L$<0nj2jM{C^mtXi47nu z@#mHzSL-b>GB=0jcCpqM2#u`gtS(CJ&DN_h=QmKxmua~BVg`7KVBnU~yuv;vG8n{2 z_js6ZAPv$V4j+F|EUY)hU$#3T0jEK~`yo}smN<_t%sc@L-eaTF*gW?nYkw}&{+ja&2 z_nn6L0D;_vC@euFCC|!asxcKy7>0OI<~SKS>Gkam3_wgw41f-A$O(cV+{2$g1#)PTAO35cY_Y#&%N+!K*;>c zwIL6FwR)?NdwQ?O<0NP*n$ zd<^d9_RxqHj`ba^w{>9Vu__478`O2<@a&XmZwoQ`dX3jE+Y!;AfPPzf{;Rg<6-A8u zlbPEJ$lx=Raac@@_~&7!QiFj~da}z; zD(ui^ApJ{Kw}Jnp7-SPJBaVN>lj>u84E;>rY1jX-0Oy0BlKIqtfp@e|>zCL43Luk0 zD-?~(Hk~IFh?Pz7S@%zLG-m>6lwg9w!r-dZ7@x50naF>aKih%cRZxTFDFj5m{--Q# zoP8o@Cit)Fv#iJdmGa+E|EofTP5M74DE%Q{r2o&KVGKpU$^Kjan>Zlh|MV%m949FC z-yWgo`Esy)fUv7=r+HhXychP;$Y24BSTF zq074d z(R9)|y!nl>VHd36nk{w>VaV~dQCXLh$oVF~z5-e>n@^K(h;%OTCcV#u>DUQr7RcmCyx7XXSjPB{5L62yPxR*6o2gq3kSh9 zdO;-!c{@`B-JPchFoZ(@8CG5^1hoc$8vv&)U@A4j1I9Q6@P=c=4LK6#Wa);y2o=FRGh!LJyQpy!a7{r zGweZ^LREvswp>#?+uMDCE|d-bI*O*cq4?AdZmsSV&uhMP@K|#s? zMHD$g#IAXV7e5EY8KnDBaN|x+)=ZHx98xq6uUDGcf4q~dAw`Y^TZw0R8uwTDP4)Nu zd;(Upo-oF|t)Mw!W)Jls(`=P*GxMSbwu`YH-N~_hxz&L@ZPwf?nr_74xH_W|kB@cTbD_ow?f4oqn=`X+e|jWtJ|Co2 z{Y(1urv&sd1yH>wh5-V;bb$ryf1tZ~$<+a$9$MJbo>n&%E71`$pXgq-Vn>h9K0?z0 zM`$0lLawfPc5hxNEFGPY$ZoysVgZp2;Mww!)#4D<@`z0<+&`FcR&QPk2n5`)F4=Nn#ftmh!*Kpcr=f!` zIb|<+@cr;3hcE&$$;;v-W(qX}g0Z=G=pNm)!FyRc>Mwr0>ib`#ZapIb9uO!ffcmv* zROYw4x!6}W5UMUvovH_MJiAfhM2Iwz&R7Tc>eA;`Mz^qZ0UQv$v^K#rORE)3_Fc%%dKXI9CcMJWrXf9FX>O`61Qv84ZH& z4nvJvff@iI;JH~(_?8$-Tc!r%BoHw%hBPY zpYnHdM->sLMF~9Xv{X>w{3JbfzOZqLDxFG;zi@e7`kWNW_*n723?*-)77Q<3ak~Lu zEiO#0Td@rn;sL!iiRvKO(WAjBl?1P!qgoIj4KD~vp9;oB9X@h2TP%~VB{L>S)nnI(P!dzRJ%)a9aXO_pG+$M-FfFGY zJt^ij({xQ5^R}C$3upA`YYRu)w;~Vcvhv;8;t{V2a%EP#__q}?TVSelUK?iVq@;57 zLRXw1l~nK&wPrR6husG7io3>|P=SNYfgmEHRCoe|ykAoNWgEao_A=A4V66w7@w|0p z4w*cR9*yRzi)SfyyL=VCnf~YqP#kuqOZv7F`X-J#qFQ<(_Y@Rez{6fA9H0r{{bup^ZV4a9%uA)DsNA@SEv+(7WKqKqg{$RG2n zu3B8_km+Q-8N2R~7(p?AVwo&$t%ulE?=q0Va-sLvYH3}=sbv-XQsHyzsq%UwoWFSS z55DN9P775WD%uh93GLXUL5MOJkoeQD1GwE{@cVaFtPiB>$O7EFKOf7-*jTQF1T?M# zF)(O5Fy5+bkX?F${LY%Z!?Q8nS$nNvW*(X=xmmZ&xe!xyX1D-(?$bkq#&X(BeMs-c zLXPjU(bXjio+DUh56JyP0uVFB*6QL((txk`5Dr!Vl^>XkpbDm+<9`U#T*r8{c^aDO zpYMkbeR>=pNoD)i?vecuAL?@#536VYyv%6v+K=uH9DNuO1_y6TyMwE8Ycy7=FWYv* z3D%BrJzRAizYBTK*fB?utsX41=TH%2(+F5agg`uOU5*6F?DMC&y0gT@)`Sz$SYCyo zDK7Vc0k%>C9u20Uc=V z#k=88L7IH5kISCRDj5C%wz$_`7p*?!ow&A?dEB%MJJIRZz8?+O)cqHD)6L05+&}@i zBRJ!4ZaDFPQ|Ld5P)gG~e;q7m<9Y;L5u5EldRe`hw$ZhavjbcLH^*!mPZph>o4reueXxs_uzJ5Ik7AvOti@hT>8wg zL}mZ*d-K>JM}=?VvU+#Xd#f~tWoz{W+#U46IMAh}G22r6{z!5w@Ha!2|3GB%k7fGh{eKhhT5nD5}s#6E(Zjg7gO=H7gHRn z%BoL~#!|DH!b{@cQ%TcPdsp2az0TAtKIsEuS06R*NAm2@5F|#Mh!LBt%M8KtY*@6P~7CS5yws^i*0&!#q zMAaj#aRJ&h*(Ll;y<-mYvrCicpJjrAeRMCy6LSG{O(Gtpw3lo@OF8VM9}udynCh>+JxfAPUub;V}FRH6^pfy zKv4ih;Oa+b$C<``0aRkqi8Y?^qTI85WU zTJNs5*YK)s$}Oh;7r@oWebW4 zzHmn0qo5#kGLZw@4G^KrXIpZW@H|C4zQTzWGcUo;cG?z#QTJ5XdpU{jJR^in-*ALv3j>?;6}3;Cf4;*^8~>6z1&@`dL2)vGlhybL zp=Q!&MD^?<%pov^uQVpl63=n^GLhM6*-$B;dHs8gyVQd3Em`x z>isfEB=$Hw%2{v3kd^IRHd_S7yBYv8eS^^vLgTrb9;{KH3sGm7kl)Z^pZ+B_pC=E-77;Py za9^l|Bf@d>pzeW_2bS%fS@&a#z`6E=hAkq+7VbxrIMYT<*RUM%wR5>ZN)6)hwPjE| z+EP}bSJSq$y2rE{m@dXN>{jo^XrOrGqbrMUq;qjY!N1F2Q~$PD@JTVVzw(=Pr$_2P zTRoOE^uJOoLNNX|(pDw{7H7*awv6%m3!_H&pLSqsnejU^aJbP-a?`_QcjC?!4_RAw z;wqQ=vt?sk;3}rGhL{xWMeDHTG3iD&ZI%Do>w`$(55z}0KpBT5koo-^m$n4z(B-Ps zKUY^j9ZHiZE^dL$;c!Rz!(*E`eXBL_vXUKq>1@ z54N2KZo&8b$My?}b;A|aX>^zLLy1ax8T_;aq%Gc+{7J{_70M>%o@k4|D=#Q0Dki2G zzwitjm~YV62Kqt=CYY;*?t5q&+-dT4vG>el?qKQ(iMQ zI!YB8$c2sL<_J!~acwL{SLReHzjV-}qG5u~R?!Kp2Is+0yuMuyDcTOvJsC@;(LSFF z7HD^zwxYjPwkZ20%qEBoi9lOnxc9D4dwgHDK9nH8e^gCpldM;4eq2Ij^KMS#cw3fC znoeg^ocw5TaiSl8r;EYerk*Dgxmk{QBvV~rf`i!VH)Dq+Gj8t#YsUKU(_cJ4QD36H zlPxtvXW^*GUv3S95bpzOLS&FMg7;6h5BQ@xeXyQM`&{*eu;nYaB1CYT+E&ZHOH@ZI z&=QXav#Kb!nKgSMxN1zia?(nT9U57;aZ*Qp1#4GMFKs?38@}wQcv9i8LSVLOLipq} z+>-i?sRbi+=(#!EKEI|AR?oxn7g9oPHeDUO>8=%pHHWjBH#nBxxh`Hc#WFc9M+rYD zbTFnh!E|3&uHOt-Rrcai*geFi^sE=qpHnErl!$Zk`JVCO+ziCVJdK@qpUqO5+_SeF{ZyBd(1Kz(I5q%$MIY*dE{-3)N78)N-6iv< zX;AYvy5bT9)FGHWahaS-1EL`-T!d=Q?IVw^`)z7ch!EX9`nmo_kU*nIh9&;B*6XW zI*oP-(JgHrNA|#N&=sEu$rF|g%2kE6VRD{bsDsdeQ2gH3$n*RP0T+tS5rjXc*nQdv z7Q2i4w=tV-w!KD!8lmH^u~H&_`=`8|$WvmAuEopXIKv3D*Jac<_kF`7y^05R^2N7S zzne0(r=lg45Z+z;&lBGL#xT{@2wkMP?dsvWlKh9*?J$IxQman1fK&8Vhp$FIM_)Dq z-(Nfb8F+Uz-p60UtlI8=fti)GZLUuk5|@`oX1}EChNJ|^*2S)l&oPwk;9c})EvT{H*8T1gg+ov< z*S?MYKi-WawEs626HQm%5=p)7-VsLB$%rWs``eg7Z(K}epokJmlcwv4JNhk0Ge3W1 zG^Zs)UfX*k@ayrq+Vu=W3q}@%QjWZO%EJ_Y>-FGM-*V3I{y0Oy@eJ|BjLv-7_^SIV zyIOhVO&jF<$HP8uOMX>!AYYopwi*cT4V8V~VQ}Y}v#lt;e4i5hV^gZzCk{-e9nJTK zMRuTIdDye*5zEqS*w*qct-5E=D`kfR6M)%o+;8I;IA!Ayf;X4_!HpVTlkg!ACp{j1 z-dx$z(TAQK3%|3DtytAo_zIB>@K@7SnAmou<2!QVWmlCMa?e9++EH%kvZTsp~-P z>}12BbAHoJiIv!^s0`&>6azbzK)oY`Vex^MHzNgB7H+^k#ferzm8KNeEYdEExb@U{ zW4X(Qf6}Nd*EYgGZK%n~GB&ctWF9CK4Y^~pk_}4o8%`4!sx=a0B6n};)8+iuitylw zI*)MnYDh3Kl|fu&H7U_CpLVMq(kiwX$jDR#p4n5Y=O1<6CV3SF>2K6=MeO=ToSw1e zSN}u&U=1Gi5k&f3Z`$lCP(Ot;`iI*m`7bK{5zH$|d8b|X1e}1cTxqy%M|@fr)g)(7 zIBWC5=F5jn5%WhIkP_vptH->uP$h}Yr?XpG;^!f zRkG{n?8Qr5J~)g#iFStSRMn`jx3C>qYp(@kbLf;sbpD9}Uzr@Z%j<5wULz`LoeqJV zSZ#z4_#X~0{Mu{O%SNju6?fu8zmyp6G_yF9+?NO1@|cCp^ML(l7N*m`7gpZfMK?5- zq^mYQTkHsjj{0;w!sl5X>=kl7J_3^u-p9y8bylg0Pdd*@^Gf&2H1GHIFGX!P34lW? zS#*Hi$s8yT`$57A^;lNhus$%tBW_UC?P^OAxfc#>3X5!*9F@EuyDomB_O@7*-$hS=ru9eAMTO!-jW zi8DHDy)5ylzzH>gMJuk!I#tb^s`woE;$hU}qtBkEPkI(qURH$yD*S#c%Wf=d%*W8F zMIOwT&|oI*T^Vx4such4s|$A&&JXJl#jNtwwbw~qSjYc=cM~dTH(|M(% zX7l~2ys|{4g_V>OU~{9-#~r;Yc6z%7*m~|q&4=Mr$?!Uov@kJh?d95&W zKj12Ms$Ehj7@k5{|J5=oLM@{N|8D)$leool9H+B&{c^3{k9d7%1ETYppEQc`I5^4{ z#>^qv8WMXj)Kxpn--f!)8CZ)gl?zVvBd!9zB+OMLpWL9mQ0d6X+=qw`Cg}KEBY9up+!~X9AX}Rx4aOBej@>7YuQVj;VcAIbt@Y6rapoTz_;gc~9~dE>BHg zR>yIDsXrT>i|;nN4BjFXaNYk!s|1P>)a(e5ysqaakv1RxW<10CLlpE7IO0)?8>2Mf ztheC$cTlZA1nQRR?#*QT+$N~`gRuX{1+@4{YZ{=+lS9zX`9QHEV)}Q^hz+@BCDP}> z+iJhJKueN$BQpd!=tls_2fOE+TX*QT6|8wf3xG!PxLJ?&9og-JH&TK(`9{g zw>?@_x7Fu-uIEN^L6x$VI!$mT6=lVJMcyuW{NqRLD+1t$yjaLcahlW23UILyREaVf z6Fr#**NyXB2dLnb)q&ZAYVzlut~BAq+ua(Usbr1zYcOJ;jhZ^$uRfdyJP0kgqd;Jf zYNKNC+Ko4=$(Nb)&G>**c`HZp51xmE4-LlX2AJIeE1v52CL6?rCwwCx#s}CVxa^M2?zWv3B^bnS73TdF4)JdCQ? zbZgEX#FixgQeU6*;^mJy@czLwTiE|twzsoD^Qg<+mPqrYEpS2nG0zWn4Q$PszcoNG zI>lj+?Xss~m|q};4~Ap_W?!QA34{pUJ1LA8Xc9n^yT)r{bE9)+yN}89BGvG!v&Cm$ zX>)O-$NVtFf0h14%1uSTFK)U~Xl#BMwg$45R8Lz2=CAb5z&pJh`-Y#f7W*F@wn6_I zB-Yuk(2NGtJCnP3XS+tDo5efd^1GI#WsyvR#hR264Bvd~<(eu`%LoM*To@mm9;bgy z9@dAxLKVkWA6=4g?Yqt7R|+iT)J>X?J7yBx28oF%GClMI7yBO$JRLsij+WZ(lCY=K zM4_irM0iz8b{;MaKpdBI!aiT%x^C~%)E+%sjY2^~G<0Rt0$)QYS_)K|1ZN1HY^fp7 zcFZeSt3fTlEXDq$El-d@8_7`l$FOcjWsshn9MIeJaD-lk1|ift>N*ZDdthA20;lq40KQjO?|1dlQ5DFRU`11^^rKJ_aM8bAJy4f(*wRjar$$29C~vb ze1kK#q9O0zO&mHjIZyl!v%bkz(@cTjBOM=o%n&>>Da}W=!d`$uE=lhuspMdnShG!0 z3pcD=p@jZ9oqjlj`yHw!KB(dd^#xU98IxGq=Bu=q&$@u_!3dB?jkQ+fu^`5dH&$Q2 zyY5nv&To6suaP~0@qV6FyPQvD!o;rM&~ccNa)<;L$HkPp7YeqVHUrV3UesBN;l{wI zGQC45KQ$hwLRC(hzj0~1t6Nc+GyhR~s`r3>Ukg)I*2|Om7`i%aC`W6|iJ9VNI?s7E zWjfEkUABhkKY=4NZF!CTX5KX+7^mH=Na|>R>Hmj zNEUCS;PNztWC5VI2Mbbmb?YPaLk&!|vJaua-3BZCZ&C7X6X=GV zZRP_<5+B5bi8>A?Z#T-QP6QrH;Kz$?Ev% zGi_}})B$(#F8M-#ipZl^kxF{^RR`wC_q(hL`_HrPQyRxHiPGN44rxI>5z6`c%To6u`9PCoh8kYw93K=WKWCc$ zZRe0`DQ~Ot?J;BH^-{IUXG_6Y7U zK@^iI*w=`P#B@FHd;-kU;SL9IJov+3(dF#9g!8I9u}CzL{eVZ}NdhpUb-doRYgF2+ z7*rx|tj+)-Z(2JtC}|Dr=O$9A1CS>(13%i)bQ9L$AlAVkXs?3XxDwf`_`2@D|~hInLUDz zgS@x@15$hSBbE^*s?pn7>;3stMu0P3|N2U3n+?v^P0Ub!v%{bW!ty-Con`Bno$0R0 zKN2js!Cpiozgj$YiKC0YeI?>e*I%QkSNimhTecunsvkWzqo}@tEBoiK1 z@NF0-z^ze>)+A1E;qj&8*lKll6=vqD_f{{P+vS=_u6jE7B2*3k?P#f0XwWq~ zC}PwbA+oRifd1Uzh7Qnp@4kwDB~||0>UGv9QQ^eqmE`ZO^ilNL#I!32@|`_&v^);d zLh|fQM~tCNI@P>upLui=gRcx}HOIADE(-%YDy?&EOGtV1vv-k=O1MDqSSGm^cM8RK?C;D%EGc5;o4kqRM5Y z>KR!XM49)!i37veCvhG+{;9R6q!id&o!&(j&4oWyBm3_rU$Q5D2hZ!>aJ{Ym9DT=) z{7>NLixl|R?;0n`BiM`5IodB()4)1CIV{?o7EyayCKZgBFa8A8inTf=`5|h4PbmaI z2Poed&daOaz&XyN6wPnMTsUq-3$Wl{sAfT(R~g>GN@N|I|6SaTaOU}S;K>In-VpkK z{btV(t8A6`tmqvEPk=&tE;rKj)wY`xZyKSnR7 ziJ7=ZyAi%L_5(M4C`Qj+egFc;ZB4dato^`KXB^t56h5;isuT4^9BG>t`TciSu6x5- zLdOO?SXdn~12f+UoQC$J(!lPM=P)zNCyBf#o28cypp$+!1c?t z>Xha87_MR+W=%B7YKw1_Zdw$tU7eyaG5=t%09bn3`WFU#JQ;?l*q?>{pm(xVQ3a*E z)%jKQx-%kvt`&Y2iOoJw>?>ba;=gJn&U~$^!Jn(ji*5}TVwJ&G++ND^eT6NVxm&tP z$FH|S&i1zIVnUZDk9{n5d2>voCnkfG~z7dAs(dlju`67-0$+L)$`|?3w&MsJS zB!=@RT9P-iohjv<$);t#V zPCO;#vEA|m)X}&M=G(uEz_JhQ4MflYrQ2_0UZOnsn9JV;UcoFkG_y}aNzcEq#q`MW z0~V^gd)+t`QWw$nlqck0ljPqa-SlR&_2#w^18T*BcIS=Zdy9`{_Y*ryiyjf9)=iZ6 zfY&I9(aYF1#C@6RU>gaQ_okPH(BBpbOx>&HJj93|^Lz%q)=QP0bn8(Se=Oe`+&TW; zQjKP5+YRViJ=?|>=rn&SFa53Nx+N8~?y|#h6hR3u_F_8<0?jx;Ri96Y2m?!eC_NLW z&|HhSiSjSVi}{>}%Ecoc13 zp%l*#LA&0<>o7OV+F3#}EDD3dg19ZS;HDHKU{O928F3cE1i0Gu$1tNFcwPd7?uy>+ zKYt$ahM%Z}&Mw5rEB7jfNf>~%7YJseQmJ{#xmFG&lZ*955`xXwbSO_klQbv{^xYl6 zp&LeR!Su-$zq)hN@3c2JGC?gQEifk!gCe#*octHBRO)j{MPJ7g8e4hw6=9@ysxDf( zM=FLXzNkJL;3h>66RQG}C@W{luP5s^7J=64`TDX+erL1Q6z+2pH zL78bza%uRby5g&m*|YNE-|-()5?gE*1;F{AiXlF@;RQ23Fkuhc!O_zGE;{KTLHv8z zMwdJ;5<>rk0~Zu_PE7SHspN@!Ljra9kEjs`V5JovdRG>tVp;+RaC=P%)zeG~EOx=^ zhtdc%KP^iXL4?<92q-r1Gl@MqoN50kY0FS(=fv!(P}eIapYnpBwm=X7 zJ(p{*NvtG9qgfJes0$ZbdM@5XM5Fug+E!{i-0NMw4O!|u_4azrvW_>>1!2eohC?A+ z3r}*APa8EA)bClAk?<_%l2%E4f;9R>09^ScHDO&{2a)bAXF&_ENY3f4te!&Nn~e`= zhpvfKm900U#^SLpe`4FDJ6=~k_b(otp0iYN^~GxKH%9kQ&ASR1m)lmVPg7#2VTIJu zbDXfeKaz8n(Z@{CbNDI~^tdQj>5w ze-(=H9GVx5?fl(ssSL2XhVG3(-XtzJwZ0#}j`x)yS5g#=9m(hVlrUq_*?&l$hPD;n zXPE8K6Wm@}v;Y1Al&p2pA+DB)oQ?28_~`*~hciQXK#6N|MTFJJI#8}?{MIr20I({B z>($61_k91$WuvWZ_iT*Q{tuZ)i>U)*%*xNd(@q{OYT$0GvmfutgePwqzs^`f-G!y2 zFSDrM$njp>k`IBl(4F@czT&xH(fxAq7*-uQHg7>>u5y~5(V^2xliIy!Dl6Y!y!nc( zb?9=lb@Y22^aE{PJ0X0vtAB=_L?X>q4i3}!5m_Q|7ht)J{HTgBfbP*3-hM?Q>)gzo zoi-n|;t35Qi>kkq|HpD;T2+O<4`?6*S2e zJ}8qGC5kv*wf98Sa72?FYXwb=wM%swbK|-s@14Icd1HHOxv|WcF`P<$_cCrHnQDYu zAttt{|5NXGJ_^C64&!~*Q)@zEid2ILS`2ICnBMu3Opv+m+=?b~Z+0XME8OD&{vsI- zI@^0}o%AI8NOs@okJ{>-c*(LNx3UW43_fT$z}1%PMYcHkuB+N+h*AK~$9L6OGMRg3 zHDY2fy(;usj<9-E@0Y^nVRI~JzjumtC&?`o_Y__(rBW8h+_eFJyE2;lQY~C%7d$gbK5@Vo~nxk(YJkn%A+`{tBz9AU)dFs&IkJyf1Q0=>2j7^H(Yxh zns!ZU#uPQBh;YUxRomjOl4T(0f5P?6AqyMr@-s>({w$U%q{PEW^AL!ru@)b4c1x?K zJ^nP>=_HAFC&P+vrXXIf!0W02zIr~J#u}X+5UyhJH1<}~n@Ou*ye?P+ZZPzPr^%$T zhGR09aXFSW^{b1A@36t`JsTj2Jb={xER%jY7%i|G53nZOKFnK+zKDYqLz5hE<32Or zeh3am(sZMbPl#A+CPV=3SZoc81cV&R0cR={U_h(ipF=Ug6Kc~6Ew1$%KGXos7EVCBSjni{{GeRzSg zCSOebVzA8qTDbCbL?@emNaQNhwny~s&s)!-p=UZ`8M$Y8?l`@aA_T?{+Th5aBXZeH zSRmY{!$rjTW$2+=r*BNj_)#sqyu)J}=1vjk;|m9xm^2d-%xI3T{31afNUNC}2c>T6 zI4#h0O8m7oF@UjsrW=<%gL*9uEl+&fTa^)}2)}eAFs~_U1pic3&rJrzrQ^Wzm!4=D z83%rYX=ErF>GEMYr*vV(&OB3Ja*x$UOSzf{VMJ=^hlqiVFaxVQEOTK!585Od6*aCw zfMDQv&R2^^x;?@s3=W}5SxzsfmF6e8BS(hl_|GyY#SYA2hP%+zRn9~O4$RBUFA+m> z#6HZi)n0-t@r7E?a-Fpzzb^d`O3i`8W#0QCl7ec&&R9i?6!Sd==IxF~Ats*gRgymm zSC_tqP}Z=96Z>@h1WYXvYlQKzAL(}4Lp;eAOIBuqn%rw&F=aH;W3)2+-c`ffMVBcG zQy{BN)J!+p=K{qIAOhnnE=gfw`N)x6CG)7c5jLUtJA&X$Rxtq?=w^Sqcav5oMJ-eHZ|zva9Jd4ur*hkTxa51A?oDT;b!%@2Y|0Y3$= z86IZbWsvgPKdEs1@F8i-7K;T%mHHRLc z)S)7b?yiG3=|S>6ryrcb3tRlpdCrohw;$Bzx6#LgbH&$1>tQ^cD+Y$j;$Pl_-3wJj zHR^QyKDvXI3}(`{UDV9E9eYjSWt?S;S?^l`+l&F_pK_UWRUK3UEd-`#LKwxvY^5IY zny5Q}(YB^9ZqWt!$g+DT+I;kT(VT9m`OHt_DETQ~J1xDHzeu`*cs7c2b#|#Z`gyG^ zn_&yTELx2K^Q7SA*RL)L%UsWp3@NaXD2se7Oc6sQSNkO0`CI0a5D}m6BcX(+Xi>S> zS_neXBWUZrN$=S<-2+HeD-ctSSr%o^P8Yz@$Sfud!&|YVuxWyM_ogpQLReLlXRK_w@8m z1tm83hOthH0-o<$DK?;O*=c~S_5_mpkMyuoTzXwh%nHI7N}at;0PseG6tG4}-Z77T*EAB^3O$MM*=wy)YlWmyBk{fo8tmVI)eV_l9u`x1>Kv0bTriX^K`Yk}YW+haQcmr&+gn>^+3~)m!IUFZ%TLWyc8!`VXxlc58%_S;GvUF zG?yiNf8?8m@ptQ9j4izbuf-h(XKKxZIQfg^&X)H#Pdko<>l;YH_7k9&~W{p@O8PZ@5sR?KzH6 zdt8qP9%7<3mZ!u_!T*>>hAZ|VS6`dH@obii=DOlnE&kY4MtT}f*P>>|Wn(Q$P{s1Z zsXLH_(@;h=_S+015D3)oun_$iJnj|M{UlmnXFYPJ0CWMImW?=0Tg4gjB1W~l49ulk zPAO9176#yTYgw9)WmAM6i8f27#7FvYI(UdL;!DfB4Q>}#52PCn&d(EhdKM2wG&D5) z+trN6on-O^K*U&0oovM>P9hNu6oYL1IIf9)=T)rYR&_KF_51l*9oTo+HjxM8u5~a! zVjcy_e%g#{wLvKy4UfI{+I~W!D^w%-OidOI^UL2%JIbHrrvDM-bu@IqnJ0ZEnc;oY#D8RDFb<7#y3xuz*5dg8GJJw%ki!@-H} z*6tbW=T(X1vJNh*hOAL2N2*vcW4?`U@+kbdwJpBilNaN5gylOgP06ZKNGf;rdoOjO z>2If?{&6t;pNSy#24daYvtZ%A;OXu|q!><>ZPUZXCIx5|;X#|Lo)Oud|BJ%aZP2=Q;{jjpJUs5_ZEpJKg zdXBY>*$dNfryFS}lV3kO9&LQ>q|HP=1gV+y699u`5_}pg6?Pn&36js+>pM4oA2~Y&& znkJyMS%7%-tB;z#+~Uz}6k&SR_R4Qbu`Gq}@e((mm60cBv5%1u%RYZtNi-d}B6u2z z+rv)J?P5jH|3jg++T!Glp0LAzPhlN9u@dIwV!-&mFS@#g;Y4NA;BUx3n~TZjaYr1i zz8QxNsmYR2i8bFeoJ4Adz5yEU`bFGI$Q4_5PCXpiH!`m6J$hzll=mYe3LSn}p7J=7 zkXr&HzD}C?JbQjyWyjOefJk$|QVz=69D*TvZrudoV(2>f8?sUiyd`ELWt{*<7z>Je zN`MbQk;iev$m@n|-7$0Od^1 zbmBSi-t;R5pu5LRf-&_<12ENtWX|h<@QVKxMc&Vah@W6OcxLs`7fkiJC!c07VEWi! z`gXuhVaXZOm`eVN_JI4Y^`;Lo6a?vHuryy(M&(6j8PRCxL2g91Qzyn03MKOA6C9()LxMQ0#qSz8$Pcu zD2dX8+KNSc`%YFc8&rR1^xO)Z+0Jw{GTS39k{oVi^)DpXdLis`(20kxLDo z$h^EqnKHRW)1TJr)_Z*f5Zxzw9*eKMaFHFPB*7)}I%KkXsFa)aG%vp6bPzd!>rF&#jItxUSVr|Ov)6s0WWuqPOHO$QE$6~ce@%%N3r(MoQgVw%RJ`txA! z*Zs{Lf5qU!0$SWwMhoQO+!_3we{wLr9gK)I?h22}*+AtWuQni6i-=4QqXJGM0Z`+C zxR-iewgRNiEozVe1-oqHGf+Di=}pN%2Oyoo@H6UWll zVK^BJTsIm5m!-1+Y|RT*i-5p*Od*8f*OdCXoTLIOxd4`QOEdNUA(GhALn*0gBzN;^ zexzc~NuXSX?2+3IcR{CjoH5SQ)*k3Mlzq(uSuL3gxluPP9uY){ZgDFRgo(T#7W=$4 zio+s!>~tlAmG~bWgQTWoWcMQ2|GkYYJC_Xq&$Bmyx<_vR|E%~RrfTwkmqv0EQM3Gy zJQW@1e>Hp#K~ef2dGXtnxBtFRs`fUW>HjCSJFjq+*dOg5{kTK{ZF!40 z9Xm+FfcIiWIjr$VqjorU|?V>Kf*@e zc?+O0K>s{&5|>eXgdX0Hj6=}Zq|TBW&Okd;XEy^!6AUw3I~x;rCnHA_6I&;9JLi4O zRuS||?7v_7;AmptY++~nO3lK?1VhTv;uRO?E1-!z`iG1A6(>J{^DTf&;FXxdD+LL) zaHA$)42)M8G7@5H?rA%7F762~nB9lhou4D`L9L(+c+kcV4G->Zs*8!sKC_4?mRL-{ zzLyY7{58I0B%K!f_1l-2#EkQz%KD25I%(;<*YzAFxS8t$(dVQyQvyRbzkEeI1|WR9 z_tC`tJ#xP9Y;A3AJo)DuBjjN}2M0&g;J-Kg-P^2rA(ZL&{=IYPKV{4%0KokB#?rmY z_D}ZCzuEQo=)^RIj%@rNvzn*>^AO`Hd$J|LzgHulpDF!&5kgG(|L;ZHrDWQ~QjAgc z%7u?Kqs%Z9S`z*q{$rKcCBqkg`HbgUV=C~QxHzXh2w!^q&tra31V~+`=AoI(>*1vh z?#IMkFaCLik%RUB`NG~aNP_B!lPu%c+~OkVYqjI6(?A=jvUyl(;alO z-&hMiaXc-CIqGIoPNDJ|MALuYU!JjbC)?bcnY;);y& z81|orh9CZUanXCPWc<6sOeTB!6NY+5ImS%3eWpfz2H3eGU7T3#4vyekU8rBnURK%T zhyP`%Js?{<(Q-}!Vf>M90f&;?dk>ou4@brPz(u#-UEORDi)CXEb55X9@|~x;8upma zO^am!)Tqa+C>QIWh0`J=^9iU>J}|YepRCm<$FWDZli9os^rwidv*j@6r1An5c2TxM z7dA5mjhFwku?SGD9ai7sg68sdOM$azYOv$_XLPy-H%<@M(Dpx$7p)CjimtB)0pF%_uCA~ZzX*W9k5I_`pk!+zJbc>S#IQ53H;2jJY@xNQ`W%uJ_*W%GraAfc`_-SB2ki`;^ zXdy%GSKnpX@FleH?4QZ}op1?8O9Gv$%(o5F1>D3)0>q7v1`E>Y;e{6Y(c|A2ATj*q zU;e9M7$cuQ|7$k*DQD*1O;=u5?M>@#n``QC^Ggu@uS6J-KZJW;c9XdcABEA{Gytlj zD&i?id<@E;v;Q9l!y^7Hrj!h6td^QKwNhahf!&W25vlx`?7wq`OunWH?z8mEvXN5< z0A!oYT%G^f0fv84*rVZirIryYxz`?aN6I-8p(~D;x!gI3RNj zjdQmv(F5?Z#`P+jE-l^iX%iu@ZzDr=^Z&y-2Z%r*+j^44ZDLP_Xsy+He`)n`wbIEi z=(D;1F_@h;Qu;jRYFbo5Oz9H6vg#pu@7?i4N)r`zI33HVRAM{V zAOQHsDmOiwiKHH9(${8hH1Z0UCSTbCN-s}xsILo^jAY>5eK>p|5reW!n6g&CKHE*; zcQBOh@hDvGiQfJmL)+l8od|{gXWMP$xQ!mN(u(?H=?|k%%_sS*shm_$tz`LmDK-@n zTE^uX#^qWjl~cymQ^vJ&T#V|e{Q{r@34=>dz!hnyAEDBF!W&(oz%O6E_x1ISIOwsw zdi6e%oNpo!mxO}yAC1hR^Iq;j>RE-8*$Knn(vx-(f|DsJ|7HB5LOo~$p*hCF;=l`! zs{7)H_s^q6?|x0SdY8m}-Y?rjFTASnPI%^gtkq*r_6wBX`d!lT0@w`2|JODpv1>eB z!$&32nput2UswF9Z2KyPeSX3+QUwWmvR4RCDUdM4C|v zt9w@VYB%G!-ZIImKqi=4fW_pq`2W}lwDDu8QtwIWA+q$Fa&VQ@(S(TsJGsH6qGn3GYVvDHnk4= zwscR_xrPkxKU46NhAUDF!LMZt!#cp0o9pzeH>DqJbAyU zY8mI!V?|`nu(nu(`&v=SEMD9$>R+YoBv+qnAz};gGmG56&KcdbphBikDsi0ecT3eh zh+KL+NPE)6D^HnK!xP4&E&GOEAx>q=aZNcdUQae{6kH$Hf=Ik!uo~#~B2>Y^SX}+a zv9)6o4h8-pb3RopBO}yUF2w)~pdG3u>{NxYzT0Ou^nqOP$3g&tWy5RZP zc19;_Ecr5x<;M=G?C!PQwHBooG_did?SxeI=7^)bV{Zo|%ldq|hcz3MtD;uskvLjB z=20y+i9qKc7#MU9h|_Pfi#-QOi(P;VanYNXH@tH*=jqctH}ZX$k?>i%Z_jA{IERsM zbeTw^c*Fu{WMQJ56$?t`bo4Tw$HtNVP?pZgIOMj@UB|1YXe>x~-I;Hcqqk^wl~n-X z-XwkarH<9TF{qjx(PN{&rHm=+(KKk(-y08;z;t0Ac~9-<`myr*OnF-n%8fv@3K;?H zs@w~1Ud$9M*L{#xb^GF*e9*#mw;=fr1LI)7|A;k1>0H#d*i(;6OR%J2^p{huZ1Ui* zaRmjD)Iumh9Kv{iDs_rEfVSh0=gaw?R$2{+&n(y@-{0uG5&)FnuJ({WPf`hXl{943 zx!3P!?GYBA$UZ7I-AF!y&+XVub2ij? z*JJ$=^fbu-?Yo>@_fDcM2$e!0-)Iv`x9Ltf)`+T)Uyi}ML-xmc!zIr)WQZ$uj^JwL zD_qC|!qqK=Yy-)!kRU8ezc$p50c;F^;DKuSP@=iPkTpOgCuW{nMA~TK4YWc3rsTTi z^mHI-fv4D{q_&~(k6n9uUbniRCyD4r$P9MAVH0{%LaJsm%*DRB{H9hzA&HZ8$F&it z6aA1*=BGAKL5Bz`eGVMB{9PBRjsTffYSPfq936!jsxb7P^=O?IkEuU|?2iOdrJUN` zcy$iyv2bzaN0n?{NUh^PdZfJE9qID(TOiZ=1B_RSl~@*2!Ju*LHH*Mr$xW8Cu_i1` zkN~?|&2Q;?-$Y22tBbpCJ~Gh(aN7IKfgSjLC0#{8P7OGwNL?7y%17&9C__>2Owg3J zJK`hE&6toREHSC5Gn}b@bLUpNT5+~li+JDLuQ;nEs=9dD!}239<-QbH4P~UD#v!+q zp8?mMIQW#VB?w+0i+1{?h=H-hZ-mX0+$4Tie^&x1mM!7!@B{+>(Bi$8C-@a`esU7uhPxZedGt}Ibkz! z7t3niD+T4L`JHt#*Ac-7Ht1U@YB7TgW4!9O#BXz5FWh~_ttN3$XWl0amdU!7yCJE-Ei-t zLe8Tjd>c_SmE9%p2`BC_Mt%|}#RPS4)xSWtjrfpNg;KSnDyv}j^xX8<4)b6S%>UrY`21W=_9;tKs;S|2LLGk-AFna7& zGM)z}SZ@){m6NW-)Mjk0_(*OVagM(F{`#8 z?D}`gw%9M9a@xKVc_cq0i^&j$O1z(mFl-?49<016WY>;n`37^{F_rhf$i-WC^b73v z_0u*Hr7ToJHpo;ko1^mKGlsGFK|kmMGz(e1VJO5kydbWG$QF0Lq;&r7y}k{;YMpNE zOe6Bl;e&}1ef>H!OKJ21s`0O}Y7bYV%Q8iD7C2N_*;K3L*Zd)fi`r76FAQn%BkPvB z6!;f&_&EKTiA|=c6m%_9J(1%b&&gcU!s9J+e?^!XI zi7c&B<Hdkcb&z7qNxr)gEC=5}EF zRYN#GvL6R-O=bu1cxpamx6POxaaa)lau)ULV+Zd;=A(T`)$XY13qwz0P?91&Pm3JE zDFP^YOfInOgtm!!54I;SS)Jb*v9jymQln%UG>7!YnV^lT%|HzpG65Ympw#*s(=0i( zik$*dSz4jAe-i5XSV?g0;AC1LqsgV&jEye9=NcBxMXvCclC9mS=|NgpFJr6s8@7oi zA25;g%0m}hfO4y7f6>|)*uwMN6RuoXALOeCYL`|N1Z>TeQ=qo0*Nqi+^2690wvK(- z)%bhIcAHd~e;xNt9t5io>aLX~qg7ERu@B(4Sw4#kQoA(vvvG2W34cvwak zU(54!fGzgIwDH6LSgsHj@G85mJo7@;DreKxQwhAT7ir-=ja!o_xj49~diVWeo@+xE z)XU4tyr#^brFLufb4?D~>LiSm{buzgSu-tLW#+BCLy&@J0jY&qlTIDt)S~Kjb0s}y zN&qH03=D^a@P3BgoxR(kGG8E)Th^i_U%U3!?GEzRgfwCBMd6F!3*A424E8s>%Um|L z7{nP@cFDi|6@U&MyL06u^R4y|o3C6h?EucJX%i=G@XlD{=3LFl3TEm28>9+NG&G=v z5?UMUL2AO?WL~!}Y@=VH2QH31slXb$hw;(BzXf@z_*_`13LO0Ub~=$M`pDF)s2Nhb z{d1v5({>|Tv^Xpz#JxTAxBg-bwk5OWJDPI$R+_(I7jzbzELj+iB)_{`zp9o4)LUhH zCVqS!fZE#lahMT@k1Hm={u3y{977e&wj3fH?0OX zUQdK4FV~a=i>j}+#Q~g;>UamJ^HrP%`(6jk`cw!2*wI{yNP_bs@~h;`EEnS^wB~4| zXZtd{sw%e*ttHLax9HZ{p}?BD*Ys74>WS zF+wjOCrsQr90DRE@VOTto+;L$N52^u((&!H9rGw_LX)0RawLy=zIvJr^ql3g%e(AB z#M0xCoDGf)I!H34V{v5~S$ zc87W}px-RF{+T^i?m5h_M}KwUPAx#Bv~*|B&R6l@eCRN8SJ8hhnlhVNu4eNGY{t{L zT8`^`GE<~u5~4K9M--edn{q;&q;^Qml;O`5R=Bk3$A;7FBK=ISFn(6pa#!e|%-{cl zZfTsY8h##1obFXbl0b1R~+TS!+&|`Zy+R-&`2XX6GE#XkNvMs(|R*QfIE01CB0ldq25bLfIv} zdQMR1W_3qoV@w%OqklNNZG+))g4Ip2xxf}r%xd26Q+g6QtA;oe4STCaGd9kk_g{tnq!tiEWxaU=oaN-wuZDOmrT6pXiRObdzn1x6fkpE>l#5&M&TtlNTUWhBi$SSJaL zRRA-BKvx8bogYWP1fgvK@SC&6z6h4cDGMoa6&R7kHrB8}ur*EF`0ewVdHZl83$UAO#v*eKL~Fh@Fsdr0xcldJwfj%Q z;#pTIH`>hNMZC3Kq)J6rfH-<(aDAb7?L7Pf=vG~7pgvsSYk4(fqwcD?M}Z0p%|uLo zx2Yf^FX2d-qa^*4|39VYotu8EyG$~#{5)yks>o61W@r2G8+4c8&GusZ4A(_J5Q6MG zId^PxwW<@hO+)pDpU2mc8oA_PqWx~XWOl9X)=(pXiQ+0EqIYh&_dvL^zoDqUxX*m= zZui}H9*{4}dPI!c_lMU0+JWPH5p;6I3p|VF@w(;Vu@O|CTSza~E8(cnlqb_iNz>jn z6+Vo?ra#@!+C08u65apu+nBV4YC79q@{zsUEXt6tYte7j_lykI#UHNeyQ}G7g1+_D zF>&PQPe5FlBP!{xlthzN9a@?|zVqv-I_lv9=U@xAnBU!|XUowA^& zDA`HtLVR{4vS(mK;E$bCS%&|j$6+lzEZS=_uQ}y2L5CzSo1S;QSQ43G-@RS{SDX%WjH$V^nHp{>s(gGS`dKoyx_HH|M3?RSlTERv4@z}Ot-}KT+IZGv0m1S?yE3`oMG1&ozNTN+EX2)Qd+9%sbnLJfeSjA-A z(hIzO%=4``r_9w`E$?I(-I{N{sBcbs|bD%A?L2u9nY=o63v>+^rI zvL^f_9prA($3Vm>_!{o(xy=d>3};#`r>_2)OAi>M*YGBko;7YRqJG#PZ`OKAcG&)KmRK+K5EV&;~TpQ>1HlDWKc{uC!l;nY0 zC_CAS zV*4*VoU@yTj)qASJIK_klBHlTOT$}TR6PIV`VA?md!F%mTnK9eH0?Iqn(kR@cIl@8 z=@ZOi9$2%;w3;pc)w}y;vR?F{OTXKvG~-RPI}hOFS>hzxk$A**y=V9+TgwZ7gg{)s=D&w z$;@Ymt*NXmM?$;O!h7eG>D*fpq~nfA9Um>agri9~g5r%vAp7e@!D{Lz4%f9FJ78C z+RpQ0{5pIJkWy7K?RWAQJf0~_hqNifi`w9;G>bk=W~ZqZ@q6QFxA1o9u|u+C{zTDa zN4F988a+BXB8?+b4%XaWnJdX@dD$$vuK;Ho(&!_NoW&_{7gJJr{N!0ACkBQci+n3V zK~Y1c?RN&5+DQw;OqbM)(w>IGvm%HVDv<^aD5Hl2Bie5o5bHKj6yo5qZdY?WCVf}X z9&)RtY?8q%R8VxKLgBsgQbw)L9zO+~7NZo(h0N?$2wIOS3!EF7x@mOj?VcvWz!2&y zdeXJM9nf=rvb7M)!IF%kC+7MO>y(9P@GF_W#frD2=-thXCzoWTUMP*6(LRIgck^IZ zb`i#Lt$RurvQ!Nx;?14pkYauS*CySm$?ZsCV!RrBhj^dQoVw6EB7lK0fF+71`R`r; z^q=yfyt2kgLU(pGnO}~q%{}@MT3e=1*B}^+wtUN=d+(3OZwrN&IHB?ky;obSQ5j40 zcTH3cj?Ay~#Jl*{zM#GN?D6|nKa~$Wp8ezdN#f|JJXRr_ zhT!Df9oy*0lI(4H!YrRp_Bmj1a+Qy4!@pMS@C*OIr-<=F>V^WTm?GH}?#K#~!W=0| zPpcofSX!0W5w}mge6b!vtkogL?!G2;X2;4TyaN+;G&kdJ8>;Cy+g+U23v@2jRXU17 zS-2Sf8c(ycDBqo$%xJNs@Ikys^FcxV0%`@SMlR&n;ZazXim%bE!03E90gOZ0Eg1w( z>-*{~IToM#x-xGh4e{8o&i#0tmhBAgO2smr9Xdqca2b4(6dbXwa>0DT<0l%?;$?Z;xG-RfVYHn6b0%EYo^+A zexbSsvX$uMpuAKNHas6gZSiC6mE`S>^G@u|eyi923tgf28$l=DAN{QxZjDH)shXwF z$G{V2`UJqFpstnW!xcrm?VHLg8%w{_mlbN6d|PY_{vMWTL5=)>b|IkYEO3x&Ez@Ul zkZN*Oq2@?RR5Fmcqt>B4L~ZqT$~x9~vV-=TUPY*j?zbj$u*_yx?hMUFSjQ$Q`GO95 zOL6dS=S_h>GS{8W@9tqe*clI-67BXK-!K$_qpXH{Q-3HCZKISOGC$cQ-<}|H{{yu^ z&`=8lkL7+@0a^kCYDB9oZ?)!R)pS0n7mp@k&1O#7$foM@T-_GA3BeKO=lUm^nJucz zR4J5kXlsDBTPBGg!*yhT|^~9JYrQt2H>j%A0T0{gyJ%GDL)I0>L&OHuhPS6q;XBdP zth2V0%ax3jgwHYj`H`*);1X%1PEpGAnwwv{7{euxRUX$~48U(ozNq^TNF~8oS@$xstOMz49!Vwa;Y)7s>r$({p zV9$~-y$Z+k^ zSWKp?%8CD!V4u#(9~Fb7C0l;U>#MP4r&Dt)PtB6L>@U$y5$3)KK4&=@eTGKO6z(+L zm21(*`PJ&IDGHxzUqy&U@!d;WXG2#rRGQIOW))eJ-gNy-T(k~-#sU@Cs}Qj#>lV&t z_(YsuF{k5{>?XIVtZIGSPxLCnwt=%&ILU$f9keGqs9BvBWhen2I*_&Ku>yg0lNhl* zktvFFVhsPfu4Jiw7u!6Q;&qF`P1CKIOPg^kMDJ=}W*nalMh>!HdL!m9^ zJfPD&%CWHCo~orxVPTNKk8d(^~WJ(Di9BJ{NAv|mwvv#ys=@|3q*OIg6j1>&DYv=Q!ghc z^uyOjl9Z@T4^%g=cqqRTplSUEN8Fon?piwBA)h8xIF%f0xyq5U(cK%7N;tk`2@KY( zklGk&7Ik)=G*q~~{fdmxM<^X1slWU!j%nIlsF&}+H&GK42Xp5qN0Qo4j@V{(1GKNY zRcpTVeX5;FDaCadr)9Sold6@zDT*HbC9EF>$`)fJD%9GJ~pRr)Fh@%ts(jk(fu_Tzj5taUL(%;Xz`n58++2+3?$ru*i zZdIegu2fCjDAB}~hDQll5E;eXLZw{TQ^lFfWUc1UDAu=kBVR)UqR#|Jj12B1C%~i;`u)-7flOc|o zIiKmW>l)QWySxSg9g3G+4Jiryfwi-e(*HE?#pZ^HIy?7J>0Z>X$}TDsD%rD4^vP8( zs+#zm?t(2Lms!}p{8GWR89VP9>NkFDm~N4%DHJ2S2d@-WOz>_#nBnh_CRQV=ta}}I z@jP7_T4aRde~f)#c5FeEyu)WootG8wDLd9te^y_r*@E!CPPk<@Y^ z_(O5U%xmZKer$!SvWofL*1)6xwBo)0Mp*u#Z}I{2C`a?HrMS9oDoP3^=$(JcXv=hQ zWTUX2IABVW!!ygjoN|1> z_91@gAB%|Q6uyZ(qN;GXWrGR6=$8?M|EA_snTi=ZT0L=ZV+r& zN+t-OgycDI!Kq7Cg(XRTSJWmAE%ncX8WM|PL+g8^%{i#}<6j(JMg7cO|emFL=%-7>}}2A)4aIc!|0aiiu&@P1hRrj{8RSL$$fS z)Pl2IaW1x!?vDM3ly7&#p_JOriw(h+YyCSLS*6Cf%?PixFw04i=-G^UU$@90pJqL` zJ5LqvWUhjCzX>Y?NRg87r{*p5AO6@{zq$-$28=}c{U2nz?awzju7(k_YprZBq4!}g zj*0z5c{EoB)#zp?EqxE8Q?7(%WZeqIJSBOGj2!O8Od`A;de6{UM3Y}t2i6U2*q?w$ z|1w6`9~{M!s6_?7$7g4I`l@P83Fq#3APdzk>_9~~&FXl?Sq!}tC-F_ogaXd@edPosO9QCI`xlz>!Ry}V$2*A0Rn`(T(w*AsI&F&w8}djg+KDypnWOC&w=RpVj+Lu7{EJuy*2h&`i)s_jZ(0|SP*G!0{}3)Et95Q4?G=C z)^kem8^1IG{kyTN+N57OeGU)`b$+5{A@wgQ$9(7)JXK5zx)1=awE&} zf*7r8OBk9;m%Uld`T2RcT45{{`p1o82zBLUv5JL#4Ob;8K`>OyG1uDR&~ts+zNIE1 zEIVUlpT2=i>^ugi!)+_(an(Z5;4Ooki^4P<(R(%sQrfDUQ} z6DL-A_2)PR&MBiTz?v$Y3x-=OyxjGdb1SaoVP zqM!kCU;%RRt!3Qi)I_hVSwN6?vuu0s!yZEojKlN+(=jE{o7@axFUzBqUVz(PT8U15 zPFFYyLIo5@zkr*+)(G!6;c^OC6z98w+nQ3b(uJKb%6jFO^gE3IXS}m zRW(2m=L!GE$5pO=S$o=h6;?ogs4Ho>Z;AZSb! zc{q;yDVf7ArNA{|esbkSjBG4>BPJJSNNErrd7fSCjr#UPF%T*hc{`<7q9d?7->i*L zFIHV2Os7nK>i*6ETw~FlHE21O8;V`j0`;4StJWKd9RXJDx6q;sZ0L~_tipUutUBSB z{(x1LI9xa8Sxl@ox~Mk10RHrXUY4%INm{#DU2|_Ca-`}p7H!5;>68R^u&YUlIxv$* zzJ!%AYU3dL1K`)p6C15x)Kk0I^>hOTLV;ljjo#-hpo$1&B69)RX%niz0XMKjC+AG_ z&c$18c1c&#h_48k*iL)eF--|L%aqVO>XEPsakcVFrzG#`8qe`!M2X~!o z7-ORXDX4qjpUm}2O!W4LY)abV-`((w3(2e75Ou!1h>`DGg{VSHD%de+FR`yQ31-bk zQtt=u&3H|eDt(N~D75G2omcL*lS0C2Q;lsa9U@#I1c1&)H21o+EkDA=EmfI!?}FB* z_RNpl8Z0Z@Uf(^}By_MutVL<$Sh)6nQY>=T9Fv>m*qr!0W-0nAns&LB*Jz7t3t&>+ z&~m~ACbHzy8|#}{NqC*^?X&`Fv1T@8roq5a>~z#wIK9*3bF5XnI}ewIbX!7xZo2js zRGnVI&+39w%MhX6NiI$rYQInLy;|}L81}gWpA_1D>NoZ@K*qFEOg&t(rZt$CG;Vuq ztuWQdWh{yspG7tH35V=f`ib8=1%OLC?Ru5fql+diUqRpR_u@9sjO*Lg?mn> zL8DmhdQEFtxQ+_bvE5cnKzh$`MS(M4Br; zN9Ktj~geaibgKb7TiKG%5o+-%(0SWG|S~-b(RgWbRHTT#y9l4 zQ2v?X#2Oup&fK{mCY)rM>5Vgxcoo~nzY>!m5a+I%>mSthToH0N8<6v`Zl1TpV~m_6H97HThi zIX13Jc`mRecpdRNV=6|LzF~0es+^PuaoMBg8BouUu55?MZyqyWM=n&YO~;+zXQ-5s zS{}3W=y0}_(pQ+Z18q55P`-Hn`*fe$L|9l^%+`FE=JzRUaI?-=%)}q-SLkv65;bXE8uv#AC6^R^7LI*$N@VV}KR?01G3$07r$L*!0P5Fo=u`kxl3d{L78HHw_k=xBDIbyo15wdf6GNvZBjlr6-eO zA)kY#-|fz#MK2lnHrr2)rmKE^)@ck905G7VhDVi0=jn(MMysuk z^RO*knG!v$_@(2gbAHw_y0H;5psGo}Ej|C*Z@*dp_3MMXaWO34qHHg6K;MS08f8lg zg2WjVa$m%zhZS8bI&Qu?eVONRZHwGX(IVwCRcnd$SlL`-sceUT59z_dYk>l-7|h2$ zmy;#uXEa2=EN-c;M9z&IF1)XJE?oWVy}%9UmX(6$Q6uq9i}+98Mq_&wq&VfN&vjE& z6uPua(Y2GGD7vE-g@kfD9*NuVQ{;N7_pW5fZ#pHYKubRGl(~q}J2|79?9fJFr(AFH z3NM)Or|RU0%#v_e{>3-qqPgXnf}5(R36_V|>WYXGE|0O^<3MN%TZ7xCf6cE39Z`bf zY#ao(#bE6~{8;ETqfyvv%Xe2K)uil!3jio>zAZ8XkdLz>&(0?ujD{PcOypsPHa%NO zHAW`5t@+yR>K-sz8iF`zz~8O}T)<)dOXe87H(uTbX}Dt&=e@3!{!tw5e7%H@UWs1= z*)3y|yTSZ=k0#CxcDc_S$cu%>-}_RP9>1)NHDS)i)|D-2@5$U8-f7tyxr&k+*kbWx z)Dj&qjf;@#We4FC$#tcoce{8;Iv2~VpoQ4Wn9iwwX!m_J{RpnkhRFy2%?ba?O1+63 z0;__XA|Ot6>y^C>7iqfnE-7Ot_{XNE%Vp2K)XgcSW9b&#%@Yb}Ely1)T)?Jeb6X7I z(nq{Y14Th!9HS~-@0lDpCWLDnqGKl|B9VU31)N2gHBjx8fvecnerA3 zo4GmKmNu&XFs7C`y9463k#~wmZMw?QiT;$tOL6Ff?`4ivm;h9Dz4wK}dKl>hq7~h* z-jM2PpE`Zbc&+b5<}263cUvGsdxg+5Q?f}v%otTc+{gI3s8NcwMQ}%z`mQXh0zx-s zYq@zL0HE9~`G%ReSxY0i$`P(*!d4pXC&)-Nu)6X6ZxRf_67F?7u}|`x;loaKo|6Lz z?$8YV*+~wo&JS}fb<(&}PsZL%e3bs8p!_F^l!|NW^UX?BN>YqnNtE@la+y3&V6~7h zb|q^>)O05}xTwja1>%(}0u)5o8-G%o@`9}=-|`oHMs?css>w^GUM{xZGvD0TVwXDh z?+?7%1nLXz6C7oET>jci+$&C@oo4PkP9GbSO$0yQ*0a%jX?5=fTNq>hx$-?LS5}j1 z79`=S-#{>+#WYC=0rqhWwx=+bhv=X}y2%FaF^JB_$??|4XAY)1@*7XZZKt}W#s>QZZ{S@ zw{N*p8<}ufd?!i0b>NoHz2smwP)wA5nUkU|P>r~NZB6dNN*R2!yRlS-&K11%^Odl- z^g257 z;=t@`ZS1pSf^oB-y7pQ$sMX*)eve#KI{#0&ED>n+?38Rm2X~rdJcpHiy!U){yHrDw zV}kEtMS&gSbvYrYL5_Ra!`MXXg3?l-+$e>?jj{4(wRhn?xY&E6M5vs8RPDWc7Y`M5Q~tm1&@WMu5U){-WzbVWk=P}4vbC`4majik`Dfx z?ogFpD}u@IZgQ4w2QHp|S_&Sm2R|N83wjj%vNil78$EoF}d8OGA}y96792B*uaD9TyHf}eIFY@37CZC~@MQ0^_gmj?|+-?tOF zd=5`;(>yIYAInN@TNj-wZGrqJ<86ncR=q`$6;qizTy-#&!{|Gx%6`86N5kLsu{va} zwcIJk_3T>i>FHd?6~4@$5GBNx7pwSE7Sn7W1v@6z6`s<;ax;lf`gs>!HS_wE|DvJf z_V9goDn~gr&tKW@VSN2Zg~GBB+{y73v~yqUutV|na|DclsAQh^bqpw&27qFo8Q|b~ zWZ8%7I?5D(-gg-p#tR3DUPB^d!`Mx&{MCz_a`M=HGH*$Wt1GJ7ntuOp1z(LcC@fo5OLE(!tuFewH~4Gi9e#LV08M7jBk_i$Y^YE zb5C9(`j8_L6uZ>>QPVRa&mwb_d)H`#?k-Tj}SBvFPWQC>q!k^iJW&CU6X~1_QJP(|N>_O?F zGmDQAB36Ac`Ao%v4>uFD`LTFjg7|b<;aIEA z%ky2<=@Zi;#l8ynJlQbD7kP4C?|)&^mvFcSMIHI7=1g%}FzNf$h8Vexwf83sdw32^ zp@c6{afn~idtm2&NeWfpI5QsQdt<7(n}y`jdO*7f$B&umPmqp#(u`(l>FM_U29dA? zS`nK>GQe8n*xYjGuX|q}VyQIV=|puS4hzpnD+w~z+amNBbOD>yo4FP%dp7758QPjS z*`=cvm;KM{qmik@iOr#G)-gZJ|47{LLuZ%k(fM(=O>aP1UP-P}HXwGCcsvxQ!Jr@| zL|WXlbCDy^Y}%RSdeZ(TnlX_DD@!^bl_MiZbNN%4Dy8{Ub(Y$nFsD}0aD!x_eB+1i zsEQ%=@Yf-!s9gP<`#)X+GVbNhHFnp(Gplz$Whi%h@lkdp2V78ARo&A*@;GT0i%C`J zYtvw&UF${zntd_sKUBDLuB^`UI(H1(`{{QYzxsm_%umAYZ;zu`ZJw~U=tsLH?KxKr zRh0d6h)-lgo!b2FrY zwo(j^52y%@vU2u;V$TA)Ijg)(n&j>Me9Ua)ioga2HsO)FiaL}DO!v}x z)2li)IOZC@r3B2_AK~RVugZRLpZd-zjb^WuqV%`KTQ#dAOvbnqe^Qe$zmDNY>!NN5 zN8tP&QzT%>Xe4LiqG>?q$v^apST{&_QcSf+(I(ZWAAD6yzYmiQRV@^Usb&ugtxT7| zbWn89s@(-n$c#5Sr4+&#jbQe#lPc*;E%QQ6Uki z_2q3{FO|7LUVb+SYXzXUlPBhs7^;6OVV$k+J(WvmP2EG)b-WwFA&*!QF`jg8Gps$E`@JX#kpoGV+<61D6gQ^fItBIneRN`{DrdM4N9@M_3 z33C3n^@+9koe9A(rfe{0kd0msI6DvUCMrWZskVGC7t2K3jkfeg`xlgjz09pou1s6+ zbDzlTwS&?k?M(6AkXLEB-p|D!8GLbmd@XR2D;$omkQ-JU^iBqsKg-+Vn`Q#vt)81k z{mttyL~rGl|D$YA?{trRvH7g~;@=fENv=Qe|JKb5qYx7_HKnro z_10C-G21f$#|{i=mbVCZ+q@b-Y;7MDeoIQNj5eqj7#neMGNDTx`j zgz~;KU7$_I?if_TOMLXkeeb%;po`Dt3F!%5e6qmAr=7j7lm6=>a~XP?ExO=nisjBw zOg4(Q34g5{eyll$+1o$+jHz>JG-gWWdeffO`z|BHx#%2_S6GgFlkbx=^ z@QcQPmE)}eKW#3BtsXydA(vLINzWT~I8rh+ z&}4Ex>VrGm38kg}WUs%r@nf+7F(u#(i!61A7PDPja6{KAXvB2WII54y0L6dy^;A6M zJa75-CYVVG!nr>DTFX;}yvd#bF;Mw3BQ}_U8oW4#Y*7f6}>I{ zcxYVJ|9F!t1#5uPzO1r)^xKnn)nu^yCjj=;svf$zaK`zH=b3?f%O$$}No7g@ZS z;m&;Co9ZbK$9BIY*YyYFVB0k{?`b)&L3`^3UTdMxOxndPu$vuY5d}2Q8Ke|q?m3Zq ziKKDh$sJ*RvIP^a4^ba2hOP~5lEk0I?+9khORlQ@-t+H$RJ@_bKXXkE{sNplzJ$q8 z6sVL6WqR|(DRi(XFZ>)TUc>5ODkSY)+;1E;x7G}x<0U$>m@zNx)oA2E;|5%zau=fqn9U)ICs%>i%?aHoRNwose0dYC zNvKO`n&$sQ)mMhap#)ndA%x(;9fG_2ph1JXySomqA-KD{ySpd2ySuwP46?(0_wMfd zGr#y|x~i*BovJ$BJfbjraSj|xG>X;V5>*L6030pE1~p5(z1s%RXZ~s(;8`A^CJPIW zyq-Q+AQZ?Y+QM+XUen@g5`|$?I&(If5T`cMnS=_ucU`M>HWj_+BE6G1x;S(82&L1$ zYzZln*A8?p43o0mIGKN)8x|mV`*rB{NGLXE`Xi)Mey85}8a?Had?0%Li7D^3!6ys{ z;y@#S7-DADr0>-xgkV3LTLCj{B3;7l>X3ZF;&(Ed2Y;==NPF9U^8!RG!R9TbFuoMa z1HWV2SFN3ff2FNx@mm%NYg7jD@JIfM{{0Ahc{teOc*|_ zyakR*P;}OO16JD^uJ6#}LY(gpQDH3)_>Xf`%eAoY*3LaLD10~&1H4jm*&Kc#CjvQ< zF5uP`BR0Qnj88$M7ClSaWK@+IGxaJQbuhvu-Es{+@pURwC>F)R@XI`v)54iE$9YD= zV>5P}I|M4U^IDLZfWiYbpx= zA^(dpTDZ7bhoqmEdAmayFPih}(UpH067buG+EL+CW&(RM9^(%o%s0FodHLR+1}1(m zPZ%_K-ov}|a4~xByH?QIgo3W$mKu!Al$paHW9P7FvR#~?Zde@dq&eD8xl|5?bfeRH zgx3dWH2?p#>3ws`$ErGnv16|QZa>^B)_ApO9SYrEE-&zUemljPFZ?l#AEw$63wi1Z zpFBsBG=MDwQ+9e%bz$8dCoEWG{Ak%qYwa_8$UzpyFFt+UgT`{}8@`>G(>_`ZOXrXY z@IfFnmv7YI!Lxn{gK>7oh+#|roPtA<=VBsGDxSZUK4(#LWh?0Th#$pOEC1g{{sT`R zleZ5JZ^uW6G~><~Vy5tFc%vzqqmg99Jv0z=(%nBb;vZ;Nuj3LBIHNA@qjycN>e_d+ z(TrA1pHr4qF?o;p=FQWdUHbv|D|3{vr}d!#XQ$XdRt1`?hBu{UcfPT$PGJKS`{b!6 z*SPzu58Sz3hY6(241Dv+Xo0}@g>3QU+ulw&3I_hO8t_MKmb-1d0>(BxUiSf3??y&r zw1=pmPZmy?#T!;)=)Q|xPtfZ}Q4Bni@*S7}cx{M-pY85R@$TuEW?5}-$y4DaN_bdn ztr+piSScs(HFbf*VYHx{z2$}MGY~OUy za8Df-RG&B$lCZWsiE-TgpH%j(ONg}M!7oJOD5|NxH9HrR6@@aRZe@`nhL_okSn3VO zguP?0$|9HZWhD_NaL;hPLqIs&I`^=SC{0;7@jAYe721sak;0zrQm&BW4umIPF2S%9 z3kX0+@hPKNuY*@YX05Zp3d&sn8i053H(*#D23zbpZ~pL4^Y>ktrR#$;yt9?y?W;jk zI&Ln0GoN%I-O7rl9T3<*x(bna(@L^sJh1Q{or9B_DWa_%K+INGZ20z9SNt3a?vb9m zQLH91Y@=D@FFz^%wTF!Cmdb(+mwdF$Cp#9C2W*Yv4gzg(q&Y#N4*T^=>A~#*Gpz!8 z72@`?RI2Uid?KSnWK^76D(n15e{7Hk65N9wjIV?mCcx;6{N}O;({jq&i(|8miR@TZ zG*gOnWVp@O_>zaW+r3%dX3>@M<&}tVQt-o1OxaX)hCj-vo zZAjkW;d4t1-e389o*Hab>TLGCu#6Cg8ANpjjtGU2Gti?7{YV_DQ|Aay=uo!NUJPRvqf{3*6ng=bG}qk6m=wBtAo0KK_ptrjE=EYSgNHwjO^A*G@2scWyq3Dfm=@} zSsUeAE>EA(zP;MfjY>wt?Uto~>Zg|=mAg(z{5`8f7+hg{%kND-T%p+E$g0Rzx#97q zH`9Yy`YMY~2>2s3m+e#)Grh>vN*?QukEqmpKZgKX2}Y>k--VNr*s6zJ0aEU90rOZ(UX_4hsQL{#&Nt`Rx{-wZXmt!uN6YIcg3$S>Q^M2Mh_LPSS zY~-Xz``3a?@nDO<>&Fsjiu4bt$>^foMgRgwr4B_4#n;*V*fWIIz4Fa2*y)Q!xx-kx zIJWT|kGJH2+Uw4}uUC;~xB)3li%!XfED;0}d5dM`l94VQs$%-{`>e&xXDpGof2Mjz)EHxE zkD4-B&mKJT3l zh@UcU1H|R{r@2rh?H<>`yuo~DJR+4>*^^NOm^zz;sk~-`L8r6HsyxinsBtcANh3?e zh((jGc+ys#**Z$>VeVlK{~R}P7XXq+Jsh3q*HAbWL_c$#>(^$h(N|Z^BjT+}T*I+> zh@?U>c7Ek)eWu>&Tr?hvStq>8_UDQ#vK>o6lhHW3$TdjWNlO7~!jUkQEMWV}!`m2t zKs47oCqjWP?bNEeMmATGq}o~0o2(q~XL7-!BTHBUiPQ%r>dqt`cWY!FNkBIWGd)$K zg^c6*XHvWTtp&<;i1*sP4!ZpNhOUr2cd;ya3Qf{bOYiW!0mI_kl)n ztx%k3D$S_-{7FAz-&;;<{T+W%?@mm+Xy;)RoxIEn0eCk&*&VJ?8T@p;2JySk=V_4}3Aexhp4R3G#=X~aggSUy+rLuKl*9M16MdIf*I zfEpHc_X?kf-!Oi;8rxI;6g0n9klX6(BQRc4Q@HsSlx-$7=Qm{yrCXp>34nOBSwYB__%Zt7j+JXdI(~e)mqs)AX z#mvcDVwKZ+dm8BtwA~jqtRVLn2LIo6wZp1uODX5PSFE~SZvx%7$JIL}tASMK3~Bu} zy1XYHeDH?zTZ3u(!tz)xtUhc~uWjjS7_~umusIXW^?BZrh50DIjF15J4Y}iYLM?Sp zOsZRN;(8d8r$Z$eYfV(tqTE-2t!Va(N~@L`sFill(B(!O6yPT6e(nDNHPZ}aDuaup zSIn9b1kvRroIi%Xw<+NN8~?#P!@aKG7j&+;sr5DeG1pz}!^-mdyl_}_s$lgHZ2 zpF)`gY7ochFE=>63dr@eiD7P+{JZ|fc17zjT6idUFzMNm#@jfy+>~cruK!ok^>oT^ zE_-qC7|-m279on)n9nWdXJ&a?{%j5MRX_bzQA?RXO_sbgT;6~xXfw`a3S{QAuGAe% zh*k`#8=ca`67&xZB}UwOhj(tuA-Z}iv}nNJ58CvGP#`GxJiT!dyS#v^2D-*II0Kg=DXm&;Sx$VNIyMj=UPkB|7Ch7qse6jFi~C z=+ojJS?vBs$Q)00_H8)Pa$7tF)@PQeSYaie@6EydXP9?TeJHhX2o^^k7#pK!xSR*ww?V!ZXldL5n zkNSk7oq60ssf~fM3dK;&LA!nQ8?)WicuM&1=|x%=3y!^EpYn$lX6A<`e3;U-H^nZo zXNwlAXss-EHo7*4pE;{DAhq>a2T^K+Pvw|qGr$`(ox{@jXK3n(K;gXONf!~Dwccp@ z8Hk1PT@U_cDaG*@4DT`YeH&qsp5)RJ1X>DHrB=t38RiO{9;f^4}zg zi4u>&o3V$rjCROW)q`AV$V8ms0N{x*a%XPSvAP1N^IEN-QYh|mxIoG-^uLzRi##zD zUs$pG4}wZ3%nc!6UNn=2>PzGS6!iEA<}us)K@lAT)#=Nes4w5rm5|(|aD*TD3i3b` z`L>`g#~D|csN?bqlErUx?$~ z+I*zdKYcL4?fU2Ry7S8Oo^E8yoSC%vA$1T{=7?MA(ZkRkpj^f15I2&0lXp4Zsh?4b z$K$oqTX{WxbT(^P+9(gJ=9)1fkw3X-z^4$7om1 z!Q%^32^?+kZ6}_Mp6_h#FxJfuc7>?ccCe8hm5PH)%P1T(^G}(1?sO-aV1wQtaB!J2 zk>Hm)cEhKobG zj?-B#&_CtP!;W{Mdx!I|?jes#da*p%HF+t}E!SDLdh`qWn9f+=%YIO>`&Z8EZ?YUw zMA`L^2f0)a9p_v#e-t@iE*yVzNR+C;RVr>OEu>7Is@nmN^Z|S0YX%Ez30-8r)NfyP z7q3`HICOp5;VHJ*a<~v9-{9!s$hr;P9{yJHwP5yUj;jvOwuoq>D>z zbOLcS;c1B1f&=&|QX8tP`vz0jb`eE>G1UUEj^D#aLTgQovX_yy9fTY(n6!(k`lz_E zO~;G7+!|@HUuk#0WQU*wA*;Wu?svp$l)?jE4B0?7cCN8gmi8)4-10T4L4ZR+$~s>^ zubF=1h0=KD59nMyN6h+@wTupmP;_GgiIj2bP|`RpHcx zgdgMoH{Xb!o``0^J!zM;Z8{95{#ci6OOV5m86;0+HW=5UDKD2xZxenx?WWPl>iaZt zeCz#MC_#MLW!})M-D?MeEc#}7uy9U#x*%Epml8rvmn2T4w2kHKsTb0rTI$N;`F~7?(k4JoG?ZwbRIihK&u6Kk#`JK=U)*>ACr-XAJ+}U}XqvQT~ zWs3hwE%%K;1!`vSawP~b)BxYwoKOot>}I&)nx%D{AkN7JMd@P8pLDWhL=<$@XL)gCNSo^exl3flSwsl~nQjoCf< zYy1G?EZA%$)<{)Ei#wSVPuG5(pt;PoVV40NjR0d=w*gR8&N1WEt zV=g4ovEmf!08|NKe+c;~_%zLOL92{3Zj71$ILlZVJAC=o1=pH}@3MDC;%rUd=FxWP z(BSnXsu0{YpHB zHYqBV`_=5pcnq`-N-{OXzNS-AcVp~RHn$pPf1%0B9;rKX-6JwDHhRD@hlXM#LA1H@ zuZ$OU!&&4MXTP_cGx^2izd~)jnNg_c zRh5;;2`tA;L;R(%fJbuXJCCPn;WQmlpC#I~G1@B=xtg%TF`a}hME6Oysc76(5rx@Z zM;km^_PN_!y<=!x&#azy@d%pH$GaKR@v-gNOPy>b^{o>E$>Is7I68%dD?L3w^pc)N zKCQeT^|lD=N_ofkD5lFyzx68?8@ZoVs4z6s@GhuvgG%r4owv7wIDt{HXoEW_Z~xId9x`R=5JS$ci{7InEGHf+?=5q9MWnYn8!P4pM20LOM+iz=5i;eq=7)L`_ zR&x$vCnB{XPS01vx{6jTA#(S%zakU$s==s(r6UPtjY zBzq^&UK(sZQrF%>m9qMWCo;Ch-_r1KDQ3+XJOK$k{bK`fsuZV}bhzSYQBx1R?)&DM zw)A@(8gnOm0m+anon6tPh(4h(p#^h5dwR}PfHUDvGV-sufwvRzkJwoN;x5&u3SyjH?@W5i$0#sfGhN9`gRKmnx;7mD z@VmW0?$0`ujg3v4r^m(RW$*laB)98z%=|oFt4i7>ulB63j6%omenNyAfyTeS5&H6T zf9qUjV!?j`_~g-Hh5PFzl@9vY;b6knbJ#6Q9^HsVN<@d7C-=&tXX7kDI{HyD1Igp< zSREIerNB!N(n1-IWabJ+!fmE-x(vu|MH{;U0&xzUSyB* zn~FV~`h(d@D4_4v6U6Cq@hva{*QkF*t1N{vqjw(B&fcYZ-owNoXa5p~_HK;xRegQ1 zk0*#~^b>`X8GWi#UsSD=MG1Nor3W~*ViGuJklmbiq<-W(-P_4NPUDOcX*qkOL_?(* zDYJ7L4{uDo*XfOG45W3Qv)YpmjZP+zN9m7d9aif+hhy~4+gNpg)0qdp0eS6C@ha9E z`um5Ou7UqL#SckbLZZLTgFS#9{?BW;C|R}pw)N|T5AUWldOoujf!lplHcK@q`FdMX znV=)0rcYHFfy(#kj;O`kKH@1hKw)^5L&TpVz3aiPBYr&gKP|wi`3yX^Y~!3!3WufM zQ-Vg)uEpQFc)n@E3DvnL#{R)hILDV^*~ZgM4F|D#&X#=+85lGs)0(o}KCVpW<$HXx zv055yV{aSh5uN0{v&2WoM;I@q`n-nDdP3iK48H*Gx>=MXSoc{EJkwwjUrg%q0XK}fvzA&)W>S<*p$MzSyYhs z?j_)fHhrN!pWf%Kg~^d^Q#Rp8X+kVE{$LQT7)ShDOz&`j+~{Z%y*b6H2Zd69{{&-A zoRW`t92ZwAB=B6WTHQ6|32;&7Ex)vzt6pC!x$cVmJdDj!2u|?PoM5WksQ=vJmZtpx z?+f)NJ}D!@uyO6wW?LG5#t1!MY0G%Tgb{JBKUn8_a7$0mk?Mngx)Vyqql&5%H--W= z&31w`O|)cxRtYilx&BCKA#xQ9&;do;kywxU&LEoixLKL{T(Jg?c_%DB5T3#vP8 z2@P*so@~W9UV`;lf<*%=xiGE)-lEGB$CjqEaYxxd9^Cgx0^?)q@?0u1`9>mUuhp6! zKLxAvWbvo7|C#t3o&hF?&=v&@Z!zc~ZbDS2mVUI}TAqZsGHv|f;O$2*po#H(t^0K2 zqpq0^u3kSHy!05tg1VZnUV%vdP40G{4d=Zp>M6Nn0sj-NbsW^$9M8m@ zTA#M|lVQoBEEEqTgF4+J+z$&FPP4$~PaDfbNA^{-ZNY_#dPu+Y{9{$)&}>HlLy;`oO#O`)2(s5 z4K@$fRUd2+WmOdltX-6an9a!Kxy^!_-C)npa28p!!FQ7aWbICXt+VEFEiMsw9iMLn z;1aGnfAXRM4I;*7^ zKvd`>CF8%|UIzAA`JQh}nbMkZNK+k%?hidrcpU;H$Sb4nZtAlb#>Jum^4#Fj9Rt$c zk2=iOkf2%#Ovb8@5+OGmsjs&#u6=6#0mPUIX=>Bdra=Jb=ziCu>6Q|dN&*|}h{8Zv z+y~-V`*$Sjawxt;gx~tn$R@O;R(l9iZ+dl!h({))ud>@f6D++ydaX`TMY)!019&o#wb-(w zqF=uel{{T;2w=9oxlu*NB8$~92+iFWw!h*8 zZeL9~UD8XM#}HVMW=W8_jSG-PyhWemC~XgcJF1pjw*jHtBI0`f?zWC8P%5IC2|^wx zc=$(FwwJcuYtICgpWh8DT7+aXxfuea>9D2z2v7Jn^MdmNcr14*GZy5d&S$UKCiO(+-Cm@>by z-YWMs<#UHdQHT6qDgaAZ!yIoTv3F9{muuxrb{0;0s+9PMX518aI66YwO_9k%&NHkm zndc(EiKmT|8iRz&CzoEsY0!l47=9jzw|#V`M6>RQ7CzdA3w=RkblUB?}!Ind*&nDEOG~twLeuAJ>n4RhbMl#SA)Ja zxw6wpG>C8MXt|wPgH!x1@aHl@1>>WoL^g}ED*=^ydr$Nf>l3%}>^*tuseLn}h;|la z#|-b-PQ<(*XTAZGuvRJND;I8-gD+SfyUyS;%6d^c{?J?dkQe8BxY|VR#~{Avb&J*5 zN`=QhX0SFyd&1@Fzu?!en~HKSkY7Ak#FLJL(fvrE5E(L}OVo=}1mm<1^06p>yoK32 z`hdW^(^K0HGXh(eFRBIA4T)+ae5jtD!h6i&q$QF6O#c=yyQyY@3IxpOoDXT#otRPO zX2=I~)n>l*)1#y&eNyJM9XS+x-9Y}l@7T360Y9yW(iu_xH{ogO#{R zNrd+B3TW1pvkq^WvAg|BcaI)dK#9HiiOP@R(_pm_Urqn~EOu3{t_z|_z`e`q=2EFf zk~{03M^U+kMOsCqPzsr;dw^_2PTUc}ccGIE?l(hwq7+3;8 zhp*YQWWatRJkP}OEGwy@z<6Sk$ZjCLA=;Y%Ra6`33wE1ij)UtJNCdr{R|=VmrmT!X zqP4re2{UI5SHIGR^N6iXh?i@+Xye`d4-S#RtuDWF`y+r`JCxGtfZk;0{bu`nMs=PG zN1g_H^MMP_+5@~4F(6IR)wI>!Cu=sF{-!n7q}6#`=JYSKh_jd2o{3yyhZHBiha8@~ zFQG{jl+EBTCalSriv1Eh&vg3(9#9F)Ic0yzb3hir4A0w5r(`N+Ds;a6d#^+9W6r^w zOVA#1AGbvro4in{2_^27JoXx~j^z0Sr$V3_)oRP|s8zElAW9~Fs1z}9#HHqR!IJ1C zlebK2Ex&hgws7OzMY>0jP2A8<6tLaZWT# zDQ-~VYNm~uryH_!h0fN=%MiF?)LdHL(Hin9Gae2Ic$CAs~9o?8o zXSR-<2GY|~mCEWS5VJ$VKq8}}3d!0s3al{Qqod`ET8W%;%Y?GlCfB+_iPEo27soI8E z^K&xe2f{9>QSYf0)2O9pYJ=o_oWjX6->xV@AnEHO#9DB?d~ ze$9_%b~67NzV^2(AM{9UVn&pzT=)x`ma3rrfm!MpfxP8T1{b8`m%ZIaOp7=+o@>#g zqDiZsfXmp=>9mI(Z02_Jt82uEn{byxrGaL5$X_m7U(7Ort)TVHWbXEc!Qla}VDrA7 z`e)ff7!yK>%83l2ale39K002hi?J(!Q0R`;e1<|_Uq1=pSdyLl^-_H)bh`+dDXM+2 z1w)+7e+n10@<@q``BPUG>9=pFe3|N3;p_b_`7a;;na<^aFWqwh089=CvVx+FAB!!| z(h`FX8z(yEw`qgYoFiGw%a}P5!6V6zeu>nrHGR?{CY{USmP%-#+ihS+KL+}Ap|DCp zrbm$4DresF6j^9&3VJNoWgaJ6T9x^_y`ox1wYyh->Yn#ZG2mA^G~fmXZ9BnZ{7$MJ znkjmHV7ohY0ogG$&Qat0GMWt432eQ=(Fp}Mf){_JQex4*M__H>UA4{I4+K2kkpowBVu9e45{0npLFJffweiO!!yAN#=UTU#o>s}PP7=8v{+XCzVt76o#7sNL z*l^pC=80jnc;iYpBMTb|wZ6xLWKha)sV~fA-pJ?9&du0w-xO5K_`mAKIRG3ETwFFZ zh)PzBkEVj_Xf9TMceJ=5NIr$p38Dkf{!XW&$5*!a=opfq6sy(soUHUgc2<J5nR2 zmVJqoQsnc*6Xx@Lwg}(xlN6BSkF=%09ZU^$kQ$oI@U~6exzRIekr-67`D~* zTi8QuH2tP%7VdZ{^peXu=FWrJ1_1nn6&8#t<95d9BG63dTfCjW(^r-)35fo!ttXmH zsIkaWM}kNuI&n3C7W9?PVWAAn+O?;LumQc^c|G;!&e}W_Q@Hz|c7teSBL?m~A8E=U z@!nk0dLL^7rm`{XOIHm4rkLTbAB9wAVl?AgR?Az6NjDAd!p{G^3uSSTe9v~>l&7#L zi#Z>JAs{G`Fhydui3xYv`WvityZgi(uor{frT;3H$b~L#Iu;>s{jG&IoVt67gr+<_ zRG|g#se85Uas`xgNJrd344hKr$G!)|yDPsatqnO~YW|*V7muAXqG|_t{0(Z^<(w*` zXq>Cqw9Glnzd9r}m7~tjMrldXF_u1r0v=exdgOV?(`3OQzKo0D>H8nXO96JSZ0-wIhd7moi zMpGv(&3=MMdY=>zD2ktp+*pC8L?jRehyX~)lfi^}(H9_Xw(|9X7@ycj77?k}tJz{@ z-Vdt@nTra!tS?NY$pI395%wxt89xM%H;sr)R^DxUU?5!w^kuXcHsNOql_?v@b%9Zwn5y=w{fk$3|lC^N)(`vQD9i`7Q=J3D{I zj@KME@zj@a83{3UPm$Zb2q621v~FE=Ddxdg+9!U`k^0ISdyeGIp5aGAo50zAaXa9{ zSYiDx6?^6ara_ck+3_p!o*}m6nRFrPX7^) zKuoS0fhP9q@M}Yt&1_OshJFvYp60tC3m8g>g=)wO|>OmG5<59fqO`#=GwD=_UJ$#?9 zi_`{>m)hiWZ%^k0cT;cgwF&1N=v=eOCECI%dgQ4jA=}_3Hk_})y=4NlX8JlmbN`}K zG)SJj;EF2qG@36hvd8?*Up{zm$=G-_EL)bBer0v#^1^|jK+TYOQFLZ@k4 zq9KIMn@v;v&Y4?y5a0O&>0O>X2B+@JH-)0icoztGJY z;tysLUGiPl3=P>Dil+cSw$V3Rs?ub?%alkbY)58u+79!%kYl&7Xzc9lU=fbp{mq}zzw&hU@9M|Oysl0s4RfB6HXwg$O6DZHB^tz+`fbpk z-5dJ&m%``wQI(LBeP%f9oISa-#avmkI3Co5cFPcEJ}KR!0EI?2oKfjaUYr4BS7Q18 z)%+->{=tC2*Gt|w@wh>`XQzYwQy6M{j61^HtuIeAWT`@SX8Sy0?e$_rnp%mGvtHJFL$RyN4H>5Gukcsi?+fVSnOY_B>Q`%ZW0NOW!~!f7 zXFZ4xT1IhU-=TMQG<@YT9L{*C_SBv2uN*;&2#Q`SW4d^$0sb5vDpo+R8 zwbbMXnGau> z52^8-vg(3HB!8mo;pu7X_*gW9+jSt89nsZ;$8Jd40=}p{2(#8V>S7S?^@^+I+2#YK z8>BeU!hS*BKrdS)TZ)`^7YQ*|e)8ZijS3_79p>2F?(N{4bZ#E6M+h#VpUUIDQ+_^J z6LQz|i1z6wZ-sNTffa`n-P32`0Q@ds6(NaCFwH*$uB4K&M?i@UDW zvw zFbRLyWj>IW&K8;(LOx606zH9Hn?{^1jddunyXHaUmt*u&Ddx%tHD>3&pGPv`Q!Mcp zbeW$sFQ97U-YY||@9(KK3B8^j@_P6CV-KNp9&1h*r>;`cpEjAKRs;IMQFA?rtYFf! ziiEm476>SGFev3sXG5UwH5cDKIv68V_|Hp}2TJL>8=uqu{JR&9*+z>Hw+J$Kb;<%y z3@el4Mi=sIK^JZbv>JbhW>X(e17f&$k0-M93{qGtgc;dk1))Y%iy2Q+I3wiVGFqs0{) zPy=qo)b_*TY)##9-0q#|zKXi8aZl~7(bv(>MF|U=#MCrMDGRfREt-zizYQTr%7;HX ztRUZMH;=}zDjX`3`17nc=EOBZeN8ZPd=@}VllaeXW;Vy3QtHe3?Z(UPH)T)WHzL3|gTNYu&r!3B#H3y<1p6s!{M^|-^ zd5D=FiU=~qI0r@m`6l_#5-9K zTo;ZR&fXDgHn~O`rgPp^xPGN0kiM42D(CzewaYI2Qs&4jF>1vi3$b|+7>t7*KT-k zKiKuTjjc{+iTWfPd{6=pX7o4-1p86W`7>So;;$QQwV<;8RR4tF4f)!&I5IH^zEkjW zK+unZf+v+W1S3%kXF6VQ#w}J$$otsoO-=ZUgXi4fA?6#|x!uTDm&MRM*NbLiK^rUw zQnj-ur!J5p@#v99zoQOs&)$ZKjdwXQd2+((w&4(?HosBJ4FG2!< zUz~D-DD1ZG1DCzNB;7RY%-0{M?0azT12_IWdS!xK&jPo-SH8Os@~_lfbj61CWWmU^ z^qVZSSaXpR6QC5%UfL67;!B;-B9tuz-Xf|UE@u-zt&kZ<;PmhGx;NixBEk@#z$oUr z_R~37D?!^(C+nm>9!%!;4J|^L)M9Xlt@Qm)79HF?2+H*(ju?~X;NsM^cp4g4zGm;V z@%*t{Qd1-KH5#dSaN3%Oyg-pyG-M>jTl(Ri6)O`Nk(4R_V7gTGDUs_I8@>0{vk=gN zS&`21mo=9g^%D4(2oiW;O&tV$uKM8#a;3ect4+uO7?e`-;m$4+|a-1o~PxkPTz$e~JpwI2m+5#-_Ru zYqj}*BQls;;Tc*&!+E^Eam4Ryp48pBpRsjw&B<$b4qs+FYZ9;h0IntrTKh9&p%`qt zU|z#KLX<1J@>jpmjl*?+p5Wo?U9rAZJ!MN`9d<*ZxGs>_QZA`$i@kdyN=dZto*MWZ zbB3!YAf=>C(ZjucHPze2<&&to>{v$f6V?5}rgpkXZC3c*E zF!={yo5zY+aIXRpbBOV37P`Zt2HJ7eE=z-FfA)9;Q^gOfr&q5~AxYcfiA-UMFY-_A zvn7bx+phusmae)Y6BF>3mdx`=MjG0^2th<~4pn}nDle5soG3T-|lmm2= z3B4fVvvba#gf0DxENzo@h=KWD5rM`sEHn%Qnvf|U^X?8Ycd00r8)UPg(_dT2X!`b; zI8}k%P2QjjRP{cpbJl;0F>aC=K2S9JPC%(nl=wO{WEd(fwNN%qm?Vl7SLnXP@?2Nsr6H8MvR-G# z-dbGd%c~bbUS}k z+&q0sRR}}SYD_krwA=!b1%gPh(9U~*eQrhdl$;iaz|4v&7zJyz^jD$eii9zSUYz0} zRCJ!14-d$_aOZsq>Odmvql(kv@Y=hEzO<_|Hp1i}MLf#{DZeE))2Ew6Y?{Z7*rNyp zg>6IQc%_e{H9D0oGx;-ckzTr^=XhCZm%!YMlozd3Lc2R_{`$6l0|S8e>)O(I97?C zf<4wRZ0$Y;sn7TeP#A&MG33kDK9bQa4`0{ld91m#AqN7qOqps(VfQi$#bgL#sQizt z%Z+!vAboV^-^xr-whWS+_WttZ6U@w@$?V5@z29}ulmrGdV`RjZD#H#fw;SB_FF@{} z*luj*)(w+^16QQGejxS0Qk>Cn8v9E^m7o}RYsZqzDiqY>*MR@D056Y-Smkg zKFPa?OMQ`d`J|K~4R_uYT}^E>QC5Gf0h!oD4dN`K=C2andr2s=(xg-ziWkT?e|-}f zMX5;V9gEKG=djx%SvIEE8%Z8s35UF<*Ss|6$UuoTCwt3E4#CQXSC>Bv4w#dI**bh= z7DRL~nqF7;fNQzh`8lbZEJo`$kX6^n*#Y9FFFUPnto^$*1xFm8;%wDgG;I!^8O#X46QYC28FF-?;CzL_<)cTuW&PC;=Wk-ljCcm`ibN z{V!E+MrPH#j49V#?D}(^@H&M$Ju}%2y*ydmXCHSTZRpC$QY;E1?H?}Wh#V-F*C;%T zFHBkd@xou<&Z9Dokzz8U!9_w_>fIM=H%0xOMHw4s3wa}SyVRuuU5e=BLws%_jW&QD zf{mvA0&3s75w~-$FAEKJ@^X4!QdUV z*lIRE)+2|7wIgc_h-P9?1t1>#wmNxhPtaIeqAb3+f$3i1l zu;q4@Q_%60xLWqx4jh3oa3T6LFm5<^@HC~ju0Aqam336_gqAD|wS-R&+TfhHhdh32mc&fOTm zL6xQ0q*N|F>9aoBX~_V>nJ+MWP2+C9!o_RkK=Dd4Q6XNaHUFZJn7-kI!0%I?=#c)? z>Wh7RX%8pGH5MhvY)3A;H?lK zWtP%aDHH@JRQRX#?7PVQ@c6X)`o(Tlucp~rC^r?x5xm9l`7BgbagSt)L?Rj30kVqP z>5o>MQrPwQf|2yz+ZqPM4%leh)GbU~uRQw5XbTVZ27ABPP?@5T1PF!Za<8mq-q5Fu zIk#Dk3(|~Nz3)8)HxfuX`1OQ~)%DCUCit;N`a|qqfA0X{a;F10>uy-w^M7WGf}Rn$ zzRa3Lvt1)-lAd7yJnSnxsCy&n4)Gj_yruM(eh%qKP+*qXJX|Dgpik-Fs@GU>zJZID zvpcx?B@mvRj&hd4i&`!lD>9mjoUpD8BL|k=h!ur}uY1eZ#9^j-jLnDAh#m?I+Yv9S zHACb=jqdN(5kaD_Ihr1J1PoQ6OdM)oXvPPcKP@Vj)JE2PL^zHnYfomsL@wD!M zT9Bo|+$&omYioqvBnQARspt^M!_!x?ir8sZmDTMxM1Y$iiN)J#s%&#CL1JDcqj zQm2b3{&|VyB-zvwv!`6Sl3&+7ryeYj3@xJUfXKm8PQc@>`6t@ljmEwyin)-!7gkkQ zzYN?3BiZa_#^(d{7eI5Vu^2Nzn&0U@6!9t!8*NDRqF4hRrqL0!!$tIt#U^2NkWY-G zB|%i+!%bu%yKg<#l`Cvo?F0*YYY82yWr5dFB+gX&#FxP}kV$T>cchX`f8ATt>}}B! znbB8|i6>Gqi+L|7Xg_d*MyPF~79CLGTde(vu#N~yvCl_+_Sk`JQs-ZB9n*2`+6|5V zg$geBiHPMF(Q?ijw~IhlZsbS;L5lilT@$p+1C#mi5Q*uV!EC`}#xSfppYL_YYW{xK z$nz8u{6AE^V|1k7(*-)w#I`54?TKyMww+9D+t!2~+qR8~ZTt4`|E{~%z2AFvKV8o` zb!yk%XO}T&2t^7kQHrkKR}XtC59W-M@cEyXI9zrsM*8(YwNsp%dn&Y44ehS=a*2?x z80eYDQjKm^eI-LnLl}m6#(xyEeEg#?YPK1-jo?$E)#hS{3NYN7q&=CE_raATZVjH7 zN`6o@1EJT)chabYa7`b@Z7%USWp;@tDv_zG^{4<>*j=`BBm)`}D_~v!>*%MtQA5%M zQ%28TyG3Ck9bkf7dp)X!%JyElP1TRO$E}iS?LMW{t=s?GR{Sx6r=0(V8`)npX=?@Z z_~5A!y+1!g*=m$^eW^-v0|gaO-_kqT#U-nL(u&_5C&2KRa%GIFOZfkk(ZXiR(KS(W zN@W|&NA!9l(*u~Tw>MnFv7S^4vuVVKICG_XKc1L_JgmS=|xO!7)=Q1=jf?MycAh= z>#e(t*9b5JBj)d~Z>qhtAN6*;f)Y2`6BclB#CRR@0FI_RFy~=!+3}y*zb03=zJ18G zT6Zx?MJWs|aveYC>Gt>^94hx7cATOwdm71lc>}yDmg_v$xSw=ndaK_MKUOEX*am>{ zcmZFJVzE>yWZo(zJP62Uh9!av#3}n%`jFL{jUPtR>hNkWcfB(?e@b$?r4T7+IpzSw z`R`TNS{cJdEw|6gQv#n~k0*MYd%ab$!AchNxJthiCh| zQ~(`rqgE_Rm;Jv`+yrlJ#N|JnkJj#I?j;P46}0!NKftaF@9e(M^XHB(x&SaWxh~b+ z^rt)Dy4F_X*xuRmz; zK`y)VMZ~8=wlw0|T(6HB9~ze*y2be$1Gk|jc*EcELyY&xt;XYcEWk3fni@z9K+bNG z-Zk^VhanXBJRQ^|(oyQwBRz{>{TMGcdd( z2;~cx)6X7R`t;I-igAn=XAl6#5_nA$J~qZysP&#ND0>MwZNSp27-~usfv_WvyOB`X zsugGY2T+O_4%hda-`!<%y(tY=jt#rR0%uDIPtSjMou|rDKNR3yE97|n0Q0)`z{G>4 zP)Z4w*jgKTJV@FzTx@n`_GWVAdE@&iUf|mc7(#tD-S+wl4?hs>M0S(QJz!AF9Dmea zX!in1+-jD{2m*zeCwB3gceq@2`)a)m^atR1e7buRBTnP*z3j}Td!don<+B_yPe?)~ zU{fw)VP_avebp$Vk4)3eln?tIzpy1sf&ln6;z}GW!{74N>~LzK6DXH85NS|u`4NCDU_5U zWn#)bW|9wQ8V83zDMVx{bp(6+_6ri>%U8(%VW;OaI2ARr+U!A063KcTX1RZ&G5C99 z^pwDvV>yR<%367LZzr!k_avNcQr|t+-0Ryi@d>hK%Lxp_J%$uT$rf zD?q)r@Z0qw%Ay^bE^Zo0?*{A)!@t{0T#;P9{;TS9&2|qE-EnaT&qFmal{$|6sfn+Y zKf~k{TvPf~Y~*6~{xhDr6%G5^)M)mV<~p$7NipKO7APj+J0wIRM@CX>)0YnLr&1Mn zBQMS3uzy3)2A9MnCv)!cwg8FP`+lbTWGvKjt*C`A)fe6-_eE#Q@*@3O0DQXx}vd0DRs{1T^didyfoEE8cpwf=hD&SH8g@Ey>GasP3IvFQU z0#XauIqS6?&cg&0RU0y1OL>B|9Eb{7`)c02J&pH3w+7-MrMA?v>={n_Z2zASiMYCo ziFA#0bo0OBp2k$C#n<+dXmIUQ`;6?f_fsY5JDnszWQxI5?YQOeVSZ=4E_iAb;ZI$r z0;-h#w*AD(9ehVTyq>X!$DQTpPWwd4WX}ixi;$8|^Ee!~XRh8Sq(aRo{kof#Oo)O1 zU7JRiqh4VzZwD?yDzm~b;4(JFnxu$auZ0E6YDKz#CalutjH*Z~V>I5Da?5QWfbELR zeuSKD3J+M^Wrl}8X1674?z0f&EMSUI(3oqRD4^fZS-;7 zpTAL?=)Dw%h`H?LCIn6!OHRiN61kQsTPkWkp}oh>uv?eoZDv#SfCb;{w_$P)F`XFW zds--``5v=Qf1hbpQ>84}H6o#JR8M1i?t%_faWnT*YA_4y& zQFM$tzEa+%?KKM0O2x#fm8`*6=XAo|@VzUt8ZjzIYSlm=jN0o5(_*=U*L(F;F<@^X zv~;-SVr7!{osESJz#ADku*#0BHk|PytX<4Z)@<5i-XDSCVr43|Gfl*q(fO89MnZJP zD?L1Y>~-8%flI~|S~k;o(liqu>**^%wRLY%i27Teb?%m#NTfJSgLr0>OuKt?l~V9j zA;fWlV7|&rx4U_BGF6GiIG*s3OlRE-i2i z20zO?G7Gl->P^lC|~QYKeMl z!J|}N{%Y!omi`!g@-5*q#t<3ez1CWx6QQ0HtFJqj=vwcZcT5Qv1^zP%cTBMfZ zFVd(H<0nE!bxOS)mpASy^Zd;|V3`5LAsM+i-v~YRb;4f9z~gEEff#5G32?$Z+|+^ znZXuMykLK9P9kboaQ?@!0~@yzWx`>h+S+f5^xr6d-A^R1?PQ_cm^%Tx(WDa?xkhqy zrXPhpV=H&KXU80eZ}WN&8gBR`sK$%-aHHp_g`6GN@|)tO+xB7H{uF8#jAgo0)2vn2 zLvN2kl!os|ih%6gwb1n~H3zP_NFiH))3xIEQ{?BMiU&+hHoKog9qL4@GhiFfU*RgN z{)VzX7tX!R@F->?QpxrRa3{uGEyn1O_Jf5D4t?_?F#nO0^_0c}k#B8t#Y2uqWE<|! z*xKA^W>Q8*nPRBK#)?I1I>v?rn>J6hfAaDKKtMpi(ddN$d%h0DR}rSG}*X+z^?>G;X}N3F29LdD9fIDV0(y`a4ob6)j!`QiQeba)%)*JLxSr2 z>92b=t!+{Fu#he-787q?Gk-2cFJYdlz1lk8Eia>_oK>s9W9_2HjHn2C*rTiZBK0YZ z#Tx6uwhC5%fv*=tqblR-dfz(`Y5%5At>m;KWw}eV^8M_3J6u5Ow=`%6}|NDI7f#m%-4V zMKdxh-F-88@o~!%-0RZVtK-?e$4PRtrrRm+j!aps#;!{&dt! z6Q{-8@`${hJhv0wR4Vn}`&N4I;kr9&CWUHAPm0O`^EIS9wc0`LZnl5bzp~z%wKLit zF~mG^S$vn^)-fh|aU0GT{T9#f>41{~x|EV<6>d8qlPRF`CpmzpU&OYpPpcb~GI3|;f$T{2{NXmtZJDg2IAlPz65inLz zO*{e9t?`1Rx1+jNEVoFbvu8K%6N&Em&poTJJ0B5T-vrwQ$XVwT>bK?dz>Ql7R*#jo zNMOyPVYMi!^E;zGwRmeZu@M)m@4@Zyq|JzoWWCyG^H2Yx#Zm%&PNu>#$$fN^IlJat z=F?6g>K|rtc)xU2^ly$RxgXTtQcbvn#J?)%+QxOT_`QjT!WIA0 zGvtV)Dd%fo-&V-C%IloyM6g$ck}E#1ZMpZZzNf~3z`37x_LJg53`|-t(w$Cc zv{V`7_DPGmO-#`iERe8}BCD-GO$54#Dh2XCk(b5d5xsA{Jj4<+C!1$$b7W1)OV9qb zWV%Sn@94-Is+31HHwy)5J-R*X0*{+==c-(9oWp;MdF6%PK1pG(-J};?U|dq0XTIX6 za$v8QXEN*FZf4kO|5qI89OoKC$qo>l0me zfAE;|s>c~ogx3!~=;zo5Clg4u7~DVhDQ1n=s|iOboq#c!fuoGysr0;E)OH&T4?DUE zF?|H~JJ?-ur##h`n{@XWxs4pL_2>0JdAzl0r(_tJl!}zR=I!p}vroMv*pqnv<#U3+&Yj6?1Mqa=F;P zuyr)?Z%*J&mm3&M@Q&GcwKtp(y=zfsDG2Ahg;10Lpv_9nd=wV6OITcSHRetFu-6gk zlh@~hUp%aEH^KT(?)EL0eUjMPMS*BEwWMS0aU-G}ENix1!D(NY`i|97=)}DPTEHFT zMq=O(5SB3;x%}+Ir?H!lga5F%&6q_p^0s&g+oto2S?f~Ijp5aJ!$qs z34&EAo9HEcsWBAXZqlxMarmk1F)ymSJNU{&3Tp4WnK_KYe`QS%A;Q?5EXiH`?h`RW zF;{#AN^q9g?cX#LOlr?j!JX9_gWYrkF7~!RiOr3FU6TS$e<0b6h}8r@sFE!4)~pq& zj_c}MlV+%MbROW!I;F8KOcZy>;_l4`&+0yTJ6{ zm81mjqE)Fd0=E2*u;&bm5OBafWrZ3J?E_>qS|}6r^IJVM6(WU zz7D*3qxhI)E1p2q8B2#E^Kn{mfe3!IRi#FMzS&JFCKo7XHNlcncWTQhRMRrNtsz1o zL5)_G>UQwiLC669Cex{Xj>$rmvJ8Vu+Tf1A@$!6^j&G@S{lDVIyJDAxZMgR~us$~_ zquMKztJXYhE@wIcjBgPayAzib?h9&qoYtwQmM+_oF{{En#pp-hrSVN$lqhG_;v)lY5Z6izb z6b{r%<+%=K6IRnhG>pyTu?^C4PVMb`XGgJF&g`2LDkJVoMn`y_0Wso8DW4xVQ|Eu$ zJ_>*ilnJU8T^78Surc}_bcpwB~1PD;hJr6O>iZi(H!? zy>=@?fFWu$ff99EBmbUSw4BWs%ZY^ev7pruQI+Bqm#5dLWi8b1BbzQuTGmez&gmKq z@9b8ug_!@_(kM#1Tj=HWb^n_1_iq2T1&7UkqW<+mZ0=n&&>EcMxS#^Jd3|KF0|y8V zQGZazRF7U|qngvOEOPl&Xwrd;JFnpagNc3W(df-gvaEl&l=$asm*~o}iC6cTWJk}} z_g=mzP!@Zs*Xty}kfU%wQ>c2k|D#kIRd zeW!M)@-ErqQ_bVf%7bU9I`2VjK0C%oOk?<`{bzf^nE&17X zU|R=%9XwZ{ZDI(FCY||`v|zvG#=?pl zB>(^r0XbpgSZ#VlOGcDyY7Hfp_Wz3o$yOY@f+m(DD`RB2Rf$%PUpZRCqzK@ z=X2?TKdzItr`tL02+;WcWehbqOdN>-x$o%pU4!F#C$Aow?WpuC7v56NGAgM|0HK6> z&lv7xFQVH!$eP2>;r@uuZY%acm(0O-q1bE@lgO<)ah?-5FU*SY{C$Q>^0Ts!=O?`E?Nn%T;*8m^oKlid?*=MSw$*= zoCqex$6G1FO9Gd*A>QN+WX=5D89ssSm2^{eK^1`-2+9A~O~rwK{<4leE^)giO27gyi|nA{3J;XgX-<{j!|G?fF#%#pyHY*9tHxEouS0^sAr#Q zEEglmGS~U!tY~<;Cw;o!om{i^mbc+DxYf~n`(L5qLRe|WARAX_*^5;RQ`_mEOuou_ zToCU}00Yt0DS3av&rz#?JUpen+3uO7eH?r9Troh2FU3@@y!H?QbafyU4Ka_a<~_^b zU9yF3LKaZ0{}8zd6RqnGTCk=_ks^uWAQZu3mIW6U9%tN*#AbixsdssQ2FDfHpB-Ia z#BWU6i11QaS2)N*x53wBn(}hb!aN;XpIUaYTh5Z=7uZ+rgd>Z3`*&p!#r*`rL62`d zQre~SSx7d~VYa+H^B>%kAf(=uYRNA;V;Zyh{3H0#=?HWpSr%}+r@*`OHjifY{9CEAt%cuq)UZ3iL~EH2z{byVLuaN8?T=M)A%GyW0B>o7zci$}c`tN~Z9JNm3`|;gY6R9uEq4wCQAj0mgncvoj*9$eN%3lz8 z2xkOle#nL~m013-pW>3gRL}rxJRiX3^7Pi2k~MDA=fn2y-YvCj5jts5gQ}A2ioHmd z!BeEZ(7mmwRfR1#7H9EjZ)pGh6e9(j4VzLVSm4BZ@^M!hTs|R^%`5K`+Z#9i321b8 zyD>g*j$U`m!K{76{K#scKm-^Msfc~ukad;Km?@a1O}_q|9dhEh0}-1hSnW~$t(;io zf@;M(9a#O8SP<7W7)xf&WvU!8{pkC>*2o)BZk^V8-w#R==ktjRzwXU0tv#=N%Pez$Ng9^z*BlF1M;lq&VJo0Tal56{+ zQOWC`dTFL5TQDjLvTctVPd_QLal2VOmD0`+z>Ycc8@n1(tGg7Zo6gXvPO2C<( z)nC^9BQ)&aYH&ASWY>Duu3@u|@Tj3|Cod!!aqEE9#ZQM;xvR19o`UV%dD~E?O>-_1x-Wzbwr=0I1~+ zf>_<@cEb30?MmXdW!G-R7|fv3@WNn_agrv_mq;tqwty)*cQA_F;|e7Ecvqe$-v&?Z zxEh?Py5mG=jjz(1I!Kn58T7~GL|-rG7U+5@0tP|P%x8E@C@z~+Y1_4O^Zaj#owi(l zy5q@KfbHzt!%3l%$i-RpU+1JUwI})>QJ4EN)5R4|LR%^1DR`5e7;|=bVr$O`3~<|1 zNkJa`+PwpLy5^BjXor~R0lIELC7dmKM(%qTKyFcR&Q726pZjI@j)5D0Z1_vNcKFB5 zJDqQe?$PoaRlM_9zIspnlpDm|{W28~eXG(%8|Rtuplr`|tDu>aV2S;{+%W4gLkAe_+3&RqKUFcfjl9 zVuwQKd%H!pZJhzuZ5gdoAIWFQyTHtSfe68?`_tS@PN2`&cK(?rT9-<(|GXiWc`I)WyMkv@IvH#tVQyqR9W_9u)&sWE;k#Tf{MnrOH2<_ZWF*!oG-g&t?9p8!Fh zrA}_Lr`)9~yG?X&)1%VURC(-x_fD~tQ#xL;>xy`E&Qjv$PiHaudeBOgF3t9$XBrL_ z(~IPX36lR?wz_cM?_r9zi;}sYE!!ghNw7b(VHDO?ja~*ZY!J@nbDrcb^ylH+EfG@w z!W}THPc)(KinOWZi^m-$KLL(b)AKx5-B@LvsOR*whg*x5u(TJhJ`o=g$oov8r}Cl% zqr??A!BGn7om_VKzgGR@g~j{lI7_yZm&H4pQLlD#2H>}KUEbmx`Pcn*Q^u0qg~+LS zsd}J(y@#yXv?+&b$!#}&m6E2YU6RyDVU_-wFJUE8+hOt@(miu=lDlrT{2d`|0PRGp z(R+e_djf)5W^lHQ;HBvT>T-KaO6(2vq+#YLvE?6Mme}v|5Fsxic0VV(m}!VUKj5RE*RD{yWYgz9I&1Uej06DqiXDkN4<}QrfZpNuvI2dhF9(M z$Hsf&;#5qcruCA4G?I~_S?c!t7+N@SapjAdUf#P-&t7LkQt-n8jn%iPrqXJMv-yH9 zm736b36L++sA7t2NWQ7g97YkHXwXh}#XjfL9{TNajR2B1-g@Iw@L5!6Gd|~) zJYvA_fd{$&bp(ivH>KFi)Wh$gKY z6QAtrQ{{`1x8RqbuKS`Vu2inK!=A`;;EoIbn-BwpuuNJt_G|qSoP01vHV0H{cmnb~ zxj7mm1ssTM^ndjESUYy2;F3HgA+uMpc8Hc$=4^QCe2_@mNb zOc%PhF(h)T1!z@+J`9TC$)4x`95Eno(Nwb$w8&$?Zq*E%KzFB?t(NbY&9iurwJrsr zjD~J{?bID=Y(Z$Sy3)Bib+LH7q-^#i4GD@u#nZ_~AtDO?iQe1CDylb)yV!c{w7Xox z!aER#=#B1(r{57`9jmKEqHw0ft>`&uC#RM<9nR#e(eVuDeKaM8NGYQWb;=tFpo24M zTHpa*MWvPxnp}_s>S%){P#wk1W{dLpXr2%Ye@i_)vQNdu&B-8$Sy7!nG9i}tvjG)y zJJ){#Ae4WFBVCudR7vmjd3%0Lc=Z$V{u_;s4Yt!0dS*&`?KbqIUEs+_%8=Zoi?z|4 zSq2;7a(#kvFUq|WGK^{Prss9?Oytr3gDs_UJTV$89(41f*D;~)iU&rijY%KIo=v2~?ayS!6kj%aty|6`nwEnAHSe`8Ot z#d%`;X+6+H3~(50%|SLX^SFk73!N+5zFgYS9&OW|%&qP>w`H*ZZeH*O+#&l-RhJp6q%0+%qRAN;!EP^$&@; zN&c^LQ0qq~cO{rX&Veu^7c1Y^2q~71-usw_*YQvY+~R;#=;edJ`BCm$@oEY;MSf9w zUyEM%7S5o`#T|dSyficOYcLG>S{-{~sGqv!2d`-~>V3#6IX=f$hXbm#=fj{;yNe>j zB)!Veh=rwFo8q{N#2F2@-RSw}ZjMq>Mi4K*j=#|;W$>w#8u0nN-HQ|xE(n_`8i1Pq zk)rCZ3I%`OT_&&I@VyX!6A8BWG~nbxl+0r+SDs1p+dYid30xJZgwyh|oE7}7d9q2a zrR439$s{iN-1~-5=64(7A28Mx&1LK%z{b){v$ke7d1%KoYMpE2$V0;jexpSbwTiu; zg0*otZ+F~2fPaxL>)knz6dUj{M-wk4jrZa;&ib};M?7|yL?3w*5_I}9#Tr{-#UfyY zEsM`$G$IOL77DKDasrJ4f+n`w{;tHz82)c>hzeOL5haAL&hyc`x}$GA&n&-sB`x$- z*`mP#Xso0F+!e=fkLNNu+-zMydl|<)_W9uk@}4bU`E$k)}bgXXdWZeaPpAWjx&905$0B4{Mjm1EjsA!L7ZUP*Ym%?nKwJPApdkdRNn0Q=-J1 z;C+_v65$?*Y?deTR*_$R5M4J8ZlqydY)9n7SX8d0mE`Me%}X*b)zVKb9<6=Bg&QH6qInrF5XT%KVDE zt9a+`mYg~H4?+*8B}YI4=Maf|8?u^$cJIe)3jSrUksbTs@~n46LVb{%zXM()Tz*g3Ir4vRWh^u-lNs96fe%l2nae}fohj> z`=0w2*+f8A!OH3QzQ0Hby}QzSf*0r!f-j#ZUEAC3RdHjnx^bL|19VZH{hi<$d#2kmW%P zw8yMB-awlGGFD8kMCD%`;7i}3j;A@I;n7m4V`sTBSV+6l@2_PR+H1#;5%Jf>Byas{ zM{-!A3z3jmbq36`ou+^Ei}|;TKJonKLWjaA6sMI2PSZp16uJR;I)`EeE8bP>o*+^f zQh7jy(k-^i_T}l05jUGTP(hx&Q1yPDYY(-VIEYDEMX5?ddkKm|2}Z?x+WM(Y0=iyJ zF(lmN|2I@^hBV5*W=!zH&l2&UNl z1Ff`o@Bq1^d6V=PE!MF-J-?-ggA>bpE@p|{bn+w+)#OQdXYF^)-1n~&c=O;^(M>Tb zRVa4tgGrSw2eI^*N_dCHok=<{=cT#&phCUd(Q)8D zksV^Vmfu$NGae70k`M0 zw?Er>m4_)AkIdT^L0nn0Om?&Ai0-TmT^-IGn`A$vR#Hn3*~01SE`l>OoQ1Dc{0 zBUEwFG@tbJGp%;$j&o%H0UB7+r99u6O+%v6$HMVa(3LHlS& zGksFyguGH^1cjn^GYnddfu~Pooi_X-=M=UzXD?KZZj7morJ``(VgCZ^IO@)}%hanc zEAp$_-gXvYXhz8J{q>rR4_*f>XL-uH7B&)gdcf+f_W))0zIov zHcPsyr#K)#%YUBkQXn0rBi~+w(UKbfJ&tUr^O`adonj~wPWbR5Y9+_grhP4e-7a6L zQh{3kQckc;OeJxwB?JP+pwyqtivDL!Kqzw^f&Y6t~jo5w{2#XEav*8*{5eOme+k(@${j& zrgnL)fYDVtoLflXPXG_$Qu}r#V;t(z;V}DH3ujmMnzs#r?(+Li!Fa7dTIi7@?`#8V9?#^ap2NVl%<)NwP>Z!yW6*wC8F2fyLSIvN2wE|RkFpXPU;A}qg@PX ztPcui!`Pk}o)U97(S^K7t@4+{%;-xzPOg%Oi3wR&2oE5ihf=#x>S&R0N;L&wjysy| zhAKzT?2o&Y7$R(TuDSq!d%~ZXzl7y%vK2&uq^^6g8$3YYFSp66M-G1ZwO&b^(fub$ z(a^IjIK}W&Qnd-rT=eB&| zN7^GVPgA6(wR@f26}w9x`b`tZm;G<)JfxwD9S$R&1M+k2vMJTYqE}a_t*ykMo+XiC z9R9#79OX(?Gw+-xTHE8Pb2brt#rIH!vSavm+e}&AGFl%DLie=ru8lSC512Sq!2;&K z$xU#Q6qu5|!+aZ|P1rq@#uL?4PH#wsP8TQ$X9+?_qQNk1ejm=2T7C1g#czOnnxSHe z?T?XfRM0{RN(o9(ViZtf>Ovz(jaE0~79;nLBQ5KiHn+~^Re&2Lxlw?wgrtN_C!yO` z6DpQL?vCqgAD8)bn|XT1efGPbkzjkCbVed5H+LRwzJE?+vIzutyFk~E+<4n!BusQf zuePz0+WWc2{>auaomJj|tFAARxpy>mie#A)4HPJz`Vd*ccP_VE_PAW}q{IzS9&gA^ zADnrjUd;E+Qx7k}m&BJPR)-J5rWxC!pu>^Nqx7Pn3Z-|BK-BFn-Q@U<5|FE zryzJx1}=yc%vwa|4ogk^ojLH2NnBD9Y&VMYX^y}B#otmef-rIPUi;Z21L#?hN&U)( zj7VQ+btU|O3OVbf!uxsNmUx}xlOaMZ`qwzn6P1{7d|f4P;o!hu=<0+Y9tRUo{~yYK`9NN^QLuksYaXmCN%V}+A2wIS2!s<6LN@1 z+GeQO0Y^(;m4V`BB#&W=cJdvB;Ap1_w}3KhVq{^`O?NThgNse?czEsPMfLgctk-GR zA2<37>LxRVl4UrlV;1QCXC<=11fA8ayH^3nfdq$OrW|u8E)bW?GiDPXfsZX&2``5P z-^%0Jp4Zw{d~D&03$C$0zkFmI^Kwu_S)7mIjUF#=Ecv1pFQxq$r4*2usoMCe)pLt2 zmZ)TMTLQq+@{o$aGjfqrkVD5`|Ld+9ds#Lk9C-Zt76@vb`YzEpwJyY*6{@9%O_$n#2RelZ?$51mdEO zkN$D7()R2&scTaM7fZ6(_d9t}q0lH9?F}?0*-QOWD-pjWu;wO2ASx>yMRvaDP4S*xL(ruNG6m zRSJus;i+qK7K9g}hr(uXd}myb))tqk`75)I9zK>A&=~z0Wc#T*2Cj}G_`+R5Rk9&# zEZt#Qo@g8%u4ZJAiRqi*f(}lEtH94Uvuh4fv1j=u+ZOoJBwMGe7!&TRyTHe8TMCTd ztRr=3kt%+>t+t4?_NV(*^&%x|o}+__@iL{qkKz3@DW18=LO?d%Y_g%PF5}WW!!A+6 znUP8>UQ;EHF=_R1F3aJX*9|!n)!*+(c`Jz8>pYW%zZr0uE5Qu|Q6;iEYvGC+el{Hn z0V&Gl%>E0CU+ykEW7KRCPVu!O6kjL5wpoDt!$uH&YKToaquqiAXsfw@h)Y(VZMK?L zC6#m~e6q5LE-X7jX~GPnMDg?AtH zrtsJB%in%pSqO8^d{1$2w!~v*?7`)gvD)sBdl~m2#8vS07Bjb%;4BnAh5fk3#gSV~ zO(UIp!bi#RedieOlk00xyV1A`QB=YiPQs3kQB|vo>r`BI}Ad^Fb>v2zZF4J>iNRj z#7Ib*Bb0R?j^j{IUpDMgd-aUe92$QkX~Lf_x#C6L8z71zuV|LriH$k!A_B-zy(JURODAT+i-QeU#`R31qUOcI3;Bj6m0t93D---*mcEbA}G#Ei7nzT z26}e0S-5&*>H6AAKy8m#&9QJI6^NBtK$1T)e2%#_O&0#}B+Q$*35O6=KA7%W{cOb? zAH+gY2GMnY`(nZg=`JNf4X#ztF|=uunuM8%C~(GHCd87(&heO*c?}6ALA+&Eg;x^h zeYZ8)Nj^J3x3vPs@s}n7*WWD2HC*;=BLsb%@r>RnwtxpMCrnfHOR6Y~$fwQ$CFyb1 zmX8awoJ3oTEOH93fkRG)VT2d2xlO_)id%b13Ke)m zl|W;8vYADKLQvZ_WX157NbZ{gqWFPAEE(i`y zINe2?kT}qbrd${y-LaMnvD-141E$IL%>=*RTsU9nkC7oBC?_aDUYi?Pds~)Q7U>}; za+kKEh#Gt$g6-y7(8Cyb<|i#K~|RWrADIEW0q2bzG!9*T%gz`8%D)1q?Rnd6rP5M zGvz&{rR(Y~s)SQRo73=yl*l>-W1N^P88!;>?CfkxBirD&NrO&`k~x=|z?-dNjpdB# z2y5BZRxg?nd(niVd=A-;#)7KX@xM9Zb~dJf0_SDU$g`whP-}W96yGo<>x)Iv z)oI_buoh=~s$0?B!k9+I8NnQ^#tRh1 zaYPu|ii*r|l}eLCltK51P4+z1mK3aYPoDFO!}mPuoc>3&m^C~5q6f+~S6ET*Ck`JS_PZJBufj;d z7jo!R`|5IwH}6Vwr}j$cVsJHBllK0hMU(OW=KqMq>d=dSr3hs(Ke0Jd&nZjJvVujn z=#P$Bi)W}Ri{7-EAGrMeeK;Shaqu-B?)9m!QCDRfDnbQy9d-P5*pS`hlcT*WA0GaF zH_GGcf~8)wL$SRYl=_nkc+5arFb4z+GDXT?tJViUH04DI)2V;p)z+gSoePHTrr40eWM=g!&gnCi7 zHy1Zu_lw+|q)==p{i4NMMokkN3ttEOTw;GxV3?tN-Bov1hdaH4i6YI#_7uqIp@b^3 z4zIhmF*0a=8m}D_?v~T9Z`qs%OVr>o8kQLY$(IUw)$D>q=(OMmJ+jG^Pm|Di1v{_80FkHt9{(ghHm?$T%pZ1h5?wkP{Gh{{v z#}>x-&=r#?=h{Zt9lp8qLxn{WR7Ub0vUSIcLVGX|!J&^OGj({H{z+#F3U3w z^kvCx7AOJqddV!;=D}LY2YoEd5ssdlGJ2?Fawvx_3uVn0+oGT3!4S`3#uPc@sM@6R0=E;I5YerXhd^vIiPhSjPw3xs>eEA3LdYV z#f1*@TF-RnEM)RbQEx!e++Rz{BhkPlISj9zYwq&~y^@%-&QD+_`HxluU#aSh+B{%| zJZ3n4O>%0B^5q|rxG{f2P%cf*`iA3e?-X2&bP<|lr=-+j7sB^n&fLw;!M6Jq52Pg3 z`pLjwK7_`RJfhAIqa3lzOEe*67jR(>lku}UDz-b|k9)%^HoVy(9n;RwmT0%Pio9Lk zxw=tebL~Ew+%~c$W)tn12x>^%L?r%gxwL#=n97@h*b047rKoO>42qI!uTRkHLYVmY zTyD1PNM7GKVdfu!8E7hh<^7c&H);O)_*1jtMJje2!!_&1jsNq2AVO8rF|0~s8ZJ#; zRl%FcK>GtMHg1QOx~OBcng(|^LY%-5kutCuKvAfEra}m$#|nh}%lOQ2Wc(zaJb)vL8>VMAJ;;Rf~Z-$R>fq8 z@iM9XPU2jTunfTwrnIf(znt6dN_xpROd}cm^tN zI7SbZNcGp$b8rSOWobCet};rQOnBPSE%ZIXAI~4n`!5VxsdAr#5FKd?h@K-P=Te93 zGG8WeGn#1dJhxF^+{=TMW7D#?>LNeg_rK*F4jT)+vQm@TRuXGFep$eCk!8L)v>dxk zt78jOeb!#qO4nrHZh96325J@+q*V4>q{g&LbODl1+Aa4+cqASu=ilW0tgUiy`=I+* zMyGC1KPk#^@lB`W{Zulr#gdEJYn4H^YWcO1m_sKcGpo;xKHVOw&d9XAI84sa!7ifO zlqZLfkD1vj)aUUk5@@E#FAH_nexI@8{%-JYlU!fWEZT()946B_9H--x0;f0W`?Jn@ z@_W9*(FMyj+#E&P2Q*Vz>=`Bt^U2&RNm_Wix82(|*sk(YMpx0=6>NA< zU&LtNpUidX@KuIEG;uCEvy(OJwrE$rsNpR5{}6VL?Ui*=moCJ%?GxL!abnxHld9M@ zPHfvr#ZD@AQn77!p0}_5*xkQj@3r?DW88C0SOGyu>zqZntLJ}){Vx+-%KD_p&;dk+ zH0f;7q3%X62Tbb~+>xj}9fr44XXay9ftBrcQfuu~8Iek`Ce>;R+zDK6<}d%w=kdD2 z(W!qqN5S}Ys0PT-G~bn4Clw#gdpajEeTZujuUMPO3=p1Y9%g;Rj;Nh)g(~ zmI&Zz^upQCVe3pid9v=hYn{i~=r`gL8T1#axZfw^>Pa6Rn+IqqrZfhp=JG^4l}P8N zLz|SPteSC$j;i-ZKaJB6f_-vtrL3$G@xY{9=h>#U@GSrSa@y zxVkf{BE9R1wolK8wPXkA#=V(oSC+GJ_M>Mh7JsG)uKn)&9C< zAK&%NaZV8qmZqPsG@kwInVXPux!ql`{jQ92xF9)ztsvHiOR7VIPLc|y$b0bC=8)jb z{ZG3Gg&qQhs`Oy=CG^)56ME3uaF|tM%50vVE_D*m&=sKINM|x77D503sZaVb=>1t zRO!THOmSLo-hstMVnQHZ)ak(PEj6bv@%O4g9{$DSIceZu-V-qfSQ9XuEEYNBbKV|( z36q)S2tBREK+*v4@$oVO0FJ>w@Io?cZbJjqCJ(M&Bjv$ZOaEkhppVD_cnrA4+qti1 zT6nLC5%vA(%!y6-r0o={M&mkhmuH2vod5wuCgfw8%4H`k;kZt|F3yti(%tMWSicfl zQvsdny09Il{)a*;5u!%=V)1e1;w4iYbZK;NV06^H-?5a+$BpFO-lAXCYmhN2WWHm% z^EGDMbpJ}Imd?fB zh2hw`q?1n=x2^ z4twW75UHNdR{_FiO%7yNg{3hU4~?*?asvoA&U?ceMGf%7uF{|s2uFZ{Aa$aV$hIEAfCodCb%$IzP z(!Est)GCJosW2-;{7>PA4!nGyjy{wl@Dp*YV#WF6i#4-`)B{wbg|WQiu9C z@E>;uuc?$!5OL)oDWEii{MaB6T=Rgb5N`~s@RE#IcoR|G1V`V-me=s~_@eW6rwy4% zZI_bdt(i%Aq@S04jUoeZ$G!ggZ$n@3`pHjGr(hFgUb&Vn9nO>={2+L9$Whik85Q#u zMGBIoHfM@h8UL3>eI5gNQ7q!AYA-L%x39H-{T^^Bkyxm5?Jg}JO|lJL!cIUs-FoN2 z19z3(6@OB1FKKu5`nTcnkmEE7|4;k5T-ur&Gk8f%iHj2}6O+OUM>({*s$HYCVo;Fz z*EI}%__USN=n}NQ^IqbD=-S82cCM!+4g`k%N{+-<;ss^)Vz#0AMC}VT9Q)rgjSd9^ z4ld*!-4S_tWq`AD=(wa+FOolrSRV5uj@Y#T;9B`xUq^|9_tWRC0q8qa^$f>yvPE-f+2 z(M9!n#*QUKuIbo@4TP;u^zsC`crz2{cbF4>T_Mfas89AveIlKkLX&xDz&t-h)C*-x!$l)?Su_nuZ z1hh4~uuyGEW3;C?2l zzlI>Yrk$PM)NTJ_dY@?w=fp75m;ZoP-#oP1juZ@o-ZwM^q21AkMsE`s+)J6U$;<`} zZw-OX$PG<)r^~W|XPg6wROOqNF6^AMlRF~TIB)lX(|6H{>$ZtoTlV-tz3LepaK7klqojM|&!#{*DEr8I?j_3XEA?$_AxHQx z9zLd)Y?h#13E^|#@$Ldi+%Pxx^>4HIz82;Y^?$UZb-D?hrV77-2q8p=ZEduZ_Ygx!>@g$jcIo z6$MUt`-_n?h*V##pJ7ti1H=Y_+=3XMx?42I{I3Twh6DE2ZBNYTPJ6=@{fxy?=h9*o z_Mk(Gahd4$@v_slI!ld+x7FKva3P*B(ceUc-^r!hn4aN!iX^h&hMWC5FY3Zey0g0- zVMqk+Bz8YGxVVoHWAymP1FcIWrBu6?wxvi$fBWgd!f0R)yx1C!ttPB91T4SiKO=V1 z3q46OYp=>=&BtY(kFe|WP3b})Jmr=1**!HP>F^zs9)M0Tbd9$K=gyv-E1 z0rxPem!7kxVpaAQGCw4ls#!CjQ*q|ZLm)FD+lcL08h-qYSbBbwoG%O=*64EKqZB3u zEPL@ApYFYPh{W6wXBJ-$w9B}2`(CQ_2M|GFi^o|1Gm9y!^lLr3BLtXrzducO3gQfq z`-G#44T>7U(*KweP zn~6}s1FmihDV8(3cGhjd(LO_p?LiSqK69Br>$0Jq4ulli94wh4MVeOY%+{e&f-#H4 zQX$Y(`L^|z`TF|%pgRbs-mf6n5j#fodnuK=m6K=h?e9rzWRaM&K$c3K*64%dY#E7N z^_GY1LL+uNddRj%A?Cj?v2`l~Wnz(Am+<-{%rcKms(js7Rzf32e1DcLdQhb9&I=-R z%0!vVW_SAAr=aI{zJueq>5Z;7*;0`~7{Ug`NsZpF8l{R4C!kl0rS@66Fm5+A7T*&! zT#gmeJD#oIg(=AOrJ%Vb%x#Zi6R5vP5mPf?B-Wq{V&jX+resFbhrdD=&n%8Z*ZkUA zc4mm@m50Y_AWu7mG(*Zw7Nb-wb5fkI!R=~i@8$95RS!&Q@Hn@V5AEKQOL@hG4Y&g3 zNTHn(^hboQJWB|Q4S;%8oLq_zT8%Rh#7E}usMPrgJ21~E547DHb)p3$)A#QN-y4_6Ov2mNtve zDqhH|CW*g&gg)TlBe3+=1ExXVv?MEy2r3}gQj2*9+KA!uUn>cR`cQM>yO=xNrlm`n zvN1GYV`5hS>YTbWaWP>3-L&y0UE%{8H*INXJDZL=|7&2i1H+jq%MFCyljie)l^z;V z`j1VPfIkM@`x2!lC9b~`?L1W8Q1)>QZT{rq4Jg}%qa;H~iQ*{_)2^PM>kYoy**du& z8LHt+oBS3-PNmrgJ-(iQnm}a2C6G>K(ZL)fPa07qW08?MR%C0<>39mAaL;4-zb}kN z;;tRap289kHn#>!zL5;>DoR}kswN}?%CO8X)}xK*uC2{>KSWMy`kM~HAYRuB5PzY) zcQ&`CGz~V{xZ*rzUX>=M>FbObxs3fauPqMza!@mmxOUTwnMy8ct{tC1-on`6T@k1( zFGMD54<-*K5xk=-9Os(eZV0MQG_4pd8OpPWcJwBT%a}gB2O=$hhUHj(f7!rLD={f( zAQe$U(C`&tSW>C~+;do?MFg69oggslc z`HA3OORe}|k{s?kQLy)E`)r3f(ldmup{EvlwhA;aY}Zs(DDnWnIc{wLWi20JIqmH& zXhG@`k z*Wvt4VQdn;vdcthI6z>Ho^_z*zwmuU5wrH@J1Oq^QsbU$egtk6B{86xQPX0Bv*p>(MN2Se3+#EF6AYn zZg6%Jf6y^K(#yrI_WE1<)wx(JvcG&J88MYBKY4y&07(qxk^)kr7d^{iHQCXVoE|P( zkxe$ci#=V0d_Wxedm`17^P=HS_ifo~9M#`C`+-(5f5!agreYCfWde1_nz*H@jwzCu%u6;)S%F4iQ4z1f^3OobRY*_u0H;_Y=)k zme$d!3S>k!o~YTrb7dpYLGbyWnmTGKS#)`zoY2~4g48fg!_>gIBpXL44YT|3vo0o= z2ufJ3gl)we|Immt{gsL330sMYY2fXZA!DS3*yhLpQF>B$*(t?dSTI?-@q8t~sJSVP zaWUDt&N>K-JQjlMoo<8K=ZFTK;uhit2N-kp zbN`?}S;r1Fqm_>{?QCnZ&A;^^Xj~5F*=O2*oUhI1Q;f6JhYV0#GQ&l<1?4%#>VNR) z-_H7Ku9q~{^Ju&~C0PERIvYcS3;iW4GnJu;r508cwEfYtdAKG$FsifCo#}lLJj=yR ztb6>`SzV9{SF;c>x<-#$l|-B@Er>l`0IQw8Sx18I1$M1-5mKYS?E)t%wH&@1C&L# z^F#kaJtavd(-_wa-ejB~Hf57qWJ&zt?Wsb=!QRxmT&`6#3m8+RpfDs)AT7fnbH^_| zRVo?b^C$W?6k4m{mq12S@6J3z`?Bw}iW1NXYsuhb#`TW&?ZI`2^FkaOWOMo9JZ02kCgSzakon*nhTEcUzn#o{62)P-zZc7bY)Y=s!QI7voW zxyFiFog#Xuuj0RP1g#{?K3Je=K_F}}@D}yvg3p_>Gu`E10fa>%Dg#-WBClqFD{lJI z3&ntAtVkj#EjhGeHL4aDst~GhZ*Y(xzz^KZyhQ6H?Gs> z6il;JjqG$u9xlyBB$QD?1wTY*Zk(&Gm7{~y{W~HIwc%*RlU6(Dpul7hCW-z+SP7SA zV)7=QGL@d&3A%h9Edj+SJi=pY_ewiRr|VC60cLo;^-!xP%aPiUsCV%!Qc%wQ4Wbps ziqsq=k7bV9T)Q95f-^#trO?`_ga-v%f0Gfsl?ou#+mMEK0!~qkZ-4teGi$R86dihz zpwddSHa$7~2)PRf2RE?1{KZ8M6&{Zx`Te2}aHc6{^xT9%(D4)QL^1IS(cn%lQL1r_ zg1P!brRzVEyso<%CcS}Rv}jD~UHqExxphnKXsv6X;ifyb0EXK6`aaqo?plj6>HYQ2 z35^9KCso#_4joQ2&WgSLEu^gannna=n><&7+weVpvy3jYAvlSCJJxD{Y!`ZO+r4Uf z0?lx4Id9HYJ{vQgy5VoX-9w5}Rw({NDWe}^r%$>o6N#kPwLG?sKb9yZBRmqxDKXYS zx^f>^#>O2g<6B#wpYuOCm9t@>>!w4{s!~NO8l*8w-&C**7(=!-B=kMn{}- ziLfUSGq_|zDj82iv=Qa!T<1}V0?rxB4kt$$L6f-Nkl`|dTl96W#(UIHW39hlH%cUT zx|SU7d=1(>*KPD}U(gSw>b#{I9iMz*48IpQb72DEv0e?u{k@2MrRJaFQ~w6k3sw&6DjI=Qx<1*WhWegD~>vNsMEDst4kc*D4wO`7APuzRqBw}E&nQ(l)4bdj(dw& zs+AV;0TsT6Gbgt^!jy9`w0X0o{i9iGyQL*45>4%N8>G6>Q7pLrI{y%b2P%Z_zhIL; zrO@y+1{dBd`0IAJ!UNiH&EFhm0H=~WQ=9!kv%+(~q0+->d)OA`tBz++a3kf%I0=G7 zkj-_lB*xbT7S)tCjkM4eAP5ya1PmGC^NlU!m{N_XyIybYZj3!QN~M98R%K>HI+o^qhT(ZLuRTL&19edE7 zL~Zh?WHqI{@KA@R6|`b}a8L(O%Qdoma+=U={S}pX5ORH zPMtQo>Ev6NNix#&q~>{i>{s?4%f=QQjO>?Ld7H)2UO~0n@DsJ6{txN>cksKU1lNti zD1-0I#X^CSITRHNiS+>TncE72zucSmz*WlZEICquDUG`>VUYG6JOP^_UyCyV#3WIgtY{3|`<*>%XFCD9se=kj&Q>XXY}n=+lmyi%#6~ zBNni1rlMkf!z$Xv2xNsm$}&)GlMI^{Ej)QRo`wp+SUFoksa18IRV5Kry6zbC3wp)G z1WyDjcWzJ?+d*P$jWrIw!V?-D;5(HE)&tn-MF$si2X~0NxRT=uPv*W;VL22%s003< zckU=ly3ZXfkHrC(#!J(`Za73`8t;+YSK};CA&~tvZ#axKf*5~f1MBI~!*2dqd>2SM z!&28bw206ljFE#}|Fbf0PkioA(GV z1{DKK9|XNrX13=OKJK)2L2}boeh7 z8ts+I#iYpfsAcFq6Khie%Q!9w%z5We-}8^ip!!meIsX~Z1oK$B3bFx+do5iVw^}(PK+|dYFln+3jVFP0^9#yeXbK}TMLAEB_&>R$m{KBab zi+ev52a(+@*!jLlO79w1R<<7tyS9}AXpz;2RP1&*fh7cBYI8*=Blw**8{oH>ZMo9$ zj@S0`GdqJ+YV}zB(cUcaWFS4>k!szJ^fgP8?0i{=8kL{=JzDeCJK_6lgRnsPtJgEK zACM|CuN)#sU_z4m;gIPZudFA1{PQ)75!7mg>-Q(zNQ~}CkbE61RYTZAXw%$)w4_qS z2LyS49i7du-ZD_j_o5*0X3U%NS_y?qRJ_0s9$>GioOB zU_u@=h|iO7abvDj8?E0>VGqP5Ubc7vWqI1^U3_qJFt!%^wlC@HrC?ICuI!Tn!rk<9 z$6JM7;@~w+_3{;mB_p-f`x4baS1M$k?D}Vdn}2qkbHjRMXGa+91kfVHZ21;-jafVL zA#(jgM`||(N_&hijn#oIfuki1?GYAs`0s?b;<1#46ECb$#P5>Pk#k;s+*%5f#5+UK zFKPcE$d z2Eh#wzF2=nyIemkJDb!=4z?YJy>nRU5A1uCflRn5D{s6A`iw)*t)kWx}cQQFRrudoB z)P6JVN;i~1|1|zjMKK`tSm49bE`WWG!dC>NvFHkndH6z>uroWOfTK6A(jw<$`7{ z110R1jE@TLluCaGU<;3$1q|x@k}Q@-Fwuhcl`uX;5?KbHBl7l@K@6(8+-#{lCHM5r_wt@sgv4 z1`&Xn0n5Sif5NK?yUQMA%6L27o)Ec+Irf*&MRmZh`y3%x^FGeszD3CK*jX@Xy{<6f z3$>UVeQNISlDEJXa~hbWoS~Yv9~ujP$+CCQ1tVb;;v#2B-Rieoh!wSLUEECDs% zHcfju^P5vs=f}vB^4pX;e zqzxMe2}Bbwl;U+E67F^`D4E$r|7o0IQ1NTIF7g?ykOXHxe&2}4F;H$M<{M`()czw{ z4kuS3<^)bmSLWg7K=NB8)oIUh$99NULMU;z{@= z1+{Aq{G6nPF6R9l-Nx&0f?F`Z>sHy$AjolotD4B)bsR1h@mK4{UB!BOk$MhFYPnwx z64C#Mbq}{ry6Q4nR=E`RXNpWFg0d8kQ0tTxI+ZM*YNQY;$)F%SBMYRdmuL=3L&WM$E~|u0?htX6h1C;e}>3 z-SW`RH_E%hgZZ3x#GYSLDs)^iq;i;lTe6A^FoNJx)>7?0jLS3^a(GBz=8D}k@#I{E zk_RH=3eGgHc@hsV$#o6}gSg!?!e{=3vTs;BTOH+qou(AHo@RKU(M1##piWJR)sE1K zc)C+3TZPQjYV(x$WD+>i1gdXpOb*Z$5|cA+=ZRu-8JWL1I*Fn?2kPPmv_9#G3)Qr< zUb_wm{#5#puExTTz+edZi1NJ4)Qgl0l(}u=npBxNOq+9OKSZ-q;h;CSNLrPofl;XA zX;WSCVnHS=KgI!_ zD;*W!Mi*gd&GWmi#H;o+24&br+Y@-hx`#m>OVLBWp`k%}0b zuJ*9iOSR;rmh`z?ymy4*#2zQ}jNrx+v%dz-6W5gZK%;MDylo?OyXqcD$P)Fy_weJV zJ+$hT}b$uy&Y=6bdJwzrVU)S4xB78d# zoLQLB*@&i7_2&%Dy|u1rs&^(6LkF~$3UsS}Al?3=*$z+R;fnv<@=QzQVs54@a0@B` z%Wsa!o1wvv!N-bPb4Lu3HrU#UUT(CPnaQbkEp#v(g^_kUyNiCU2;;nk6nTv@UueTD zbxt=_&HYxrNxwI{AVjZ}kZ}|8bR=nakujLZHixypqwue=46fXGIJLNF3ddxbHFLPv z?DM^6y+&qa6Q4n~GiGVHC~M~uT!GbQ zi%u)6Qkn84`P>`^@g)Kc&EEYb1fc^SfXMjSnbecMpY+_{N1~_}eK111#%3xUmAQ}Y zjWwOMZCmruf*9uL#FwH=95p$AOZnRzj6`FSmCs8$VHxgf1}?r2F}BvBwz1+BPfTRm zMSkY@j)KFTp7*1qR?FfnB}b$f(Pf{}vt6)VOS6qVY3u;`mrG-IRaHo=G>LIyGDf3d zYF6edz)=xY&E@Y|LHw%s2_nWBGiGDRpkg0OJ!9QB^=8aq%CDQa6F!^c5Kv4jJW_iOW=eRTfP=DC0vZ#pQ<=~0&<;NX7_^ku}re>RF{q~ z>&8haKdBYE{&bD=VB5AOhvR|@URJjS@s^dLdOJ{vYO_`s$364xdePcAv*7ZuYU@7w_;3Lw;b z?u4s3T&z^+2>H+W_#PdF6oSu4fL$+K=|8bK=#JLZ(zoC1p>e8MAIv$%{^$SxU5l}f zzxIl^QTDeG5+D7sqfna#F9WcJz?YbT8WoVl>~IDD44_JOb}(9wLNwE#hc(E5*P`Vb z9Q}EkhNt+$IGvx|i@{tcx^jz63n?gytUvG738RHZdTQEb;xje~FZgE~H<>r0>Iht8 z{_C$sMem_x8i{a%LyxsGVQlZ{{SBUNjT@>!7=eEu%IGNB32(D~KY3^XzK0TX&4&nj zjVDoq?#YKHXy<kw9 zD#_^I$Z!wn4yr#v_MGOd!^17+tC`JbP#@s0_9sas!z0abJ$F?73>y%rZ-+!LV4}>X znhfhK3Kbep)Lh_a(VPxPSc~^#N&`>Xn^qA^ya-&wd4Y$D?M(|BL0@2d@>gIWj+Y~l zYi;qb;IR6+z*3N?~Xg%$Y&0;3&b*(ksI_wU~u8}03G`PJ3$4cbc= z7ftBKgW})8!_#?s1YF$fjIklIZaoQdB+Ns+x3ELKr@1bk>aL>P08EY#t^AEtv!k8*Xe zzJXNha~ESrixFV)*W}c*_lku%^qSbTkgefnyUH+*W!4i>nk+G^ferXj%vjk;YgVZ0 z?u&A}bs%6#F<6sjepEje6g=GG1lkiSzq%Ck4N!qb1Hu%*2eJk)5wEl8BA0Hd)L9m*GNt0!N^8WJ)a;@*5c!j6l>-vcsdqE0;1)hw z!cPNnfmB^z0(JY9Vp?ir#k+QFBZ7Um*^%b@r>$~2-uREn^ky$^HfNIr?;Cen1{4LN zpV1JveR(dII-&V(bi@}F-sUkzYY*Oc7P#ZLoY3jfxOV;=V05rMH!jq}%BzaEG?ZE+ zwiUPIohLd z1f;2tf%x#=3{SMbLbYne4x9CY!sLNEHw12+y5j#huT+V{9#2Z`t@BgZQh!j@-kcJ* zJ(c+1tgxCaUqG3yTjgYQToD-(E~@6$L5)H zRJ9i$*ju4mYvEYHa5dO|p`5ohENO7~Dl*7Ni&4Sr3>L_|*n51IS!q0k;~?OdFtrew zdK;v|Tu)+``#Az=|Aj5AfTDl{1j>~z+Oxk4f9N5gNgmI4fxSP2sXF}#FT>fxSTuR% z*(PBb_@~PH2$J#HPoNZxu}vpFi?N!z{(0z`_GYgoB^`4(y1`PZH=FokU42{V!C)3m z71gDb;XGn80&hF2pHD`xn8V}FT(+5=w#Z3%ppU)Z!NjA2KdEv!URwXhL=4~s+dxrG z#9j(+hd%2UO-^u;IT#cS>0yB?sL`^R^t@@UHcksr>;gAK@LqO5!I^Ob*n2QN;%_nAG#uw z4_-r@5j>FQ?J|>`y4le5>E!RAcr3P7Bqp(bFz*X85T~g z_9MLxn!^5u_XKxs*;7+QWWR;sJwCHzNB>^rr(Ygerh36%j1r#i`q}BNmOazp2G5p1 z*SBx8@6l1(mQp!kpB~2Q`i5$^4?3mK0>vTAmbR#MNpmG(wv0LW@x3N8w@;B>zNL7q zpxba91MqQ-N~8G)xw{*wLpdfE+%_)HxAM6OM8&Qh(*!(aXHwtg0Xd|*tPeP}Qikb5 z&1GOEPmP(CueYNwD!(+S0pfmQ3|QcW)+^9y@EP&xcoPgx9ztuV6?U6BRFgpHNBhfc z+!$Yi28x?((DD9C$xfyXpx6G5eW&lGCduMq`ZJg*5u<)r>+BWvRvzDUIfXCs#AV10>#6bbo7rzN9VA^@-+)x z35vqdB-A%{8w&5Y_Sv!^nr2IS^b<($G|nr`#jN(&^(H*{RdT?)xhULRIfFxY+AY|F9JhIN;a(pJAR2YLwnLsZq<>dDmtp z^7-hAUG=)^ui@Xr0}0AfkL2JRUk6E@$+z_q_DmlBq79Bc`D8X(80(D5dhC@32Rv3B-pE0^_U#HSI!p;@3@IDR}io)J)-a-$J9 zD7XH#y13*${TqJWz<^?YB9*PglD0DUIC*eEO^~A{VzTGAHz?2^BZAcJKdWDP1k6S* z=f@M^k|hIehVik5Uf90WAJr2-ztQ}yEXO3Em*-qwGqSV_%KME6U<=+G;4~r-AbD9- zr3VQJnP^BI$l4DcVHa2`4N!0FNQG}szv&M#T5cm$50-Dz%=n!g2>=*PzM2%~ZRAox z*%n8}B`rlGEGiS+#SDH@E8k_Xmucfj+)9qI8-HhXm?<9hr}PVdtAakj(?33ZCx z&|)`0dki9EL38k+*IHwyKlQF7LsPNLQ4UXS+W2qOfz1gJiPTgmpuCmE?15^Ct+G0B=o zavS?o{>m24`yS_r2xCvap_% z?y!*VpV*&m=b1sVK#g?6C*J$2;e^-;7t8`wBOec zCB2*y?mH$dS4Je3^1l2^Q=?o#B)!B#Dw#{w!{h7(*@#)Fe%7C~Ko>H(aW?}WL>uQ~lZXYNxi<-&dy3O$^fHeLxWdON~|r_dV6o- zl6}%shF%pj6IdGoE)&0@33J=M6JPy&H3SN0GNma#lBU?Ay3CbJ&&;9Hc2?Ye+*@;) zt;c^8PaUDgb;8-!GG?_lTkm(T(^~36m>IbjgA@k2$P(y!n(}{P zmm0?~b-fFUpXv59>`%%@=MDj+gHjb4wcj6f#p;++nVzt`C14QrzD+M!vM z)GCo61v=qTBO1S+ezah`-D^S1F0I zX{OPLG%DhTG{+03{q2}uW|-k1WKVDxguh9a{VfWBwg?w#*O6<>vH@NxHw$}_#WmHY zt>AG@ovz}V;TZ>{W-ul|&ZNSKL!e}oqlKK?eYohT9S#on>Lnub2USR%w8k5d_D`f(qxXy)HZmQ&yg@J zCc8hTL8Ex7S126_l-saq;Kba0l*?;;UvmGkul8Ju!<0BC7s~{wq_ZvboPeEtwZ*qv zuw8Vql>Btw40`tisj1%F?sGAQw^poaGFsxvQR5eX=3BB(rK%?2YsOBj;?NkAer(jQ zB-HQMU!RsI!rgnbvuwd$ z@4X&4N%CZQ)pxa}e=p7v+gHq~Q`T1eCl@1Scq%bGdjIVC7lR5jAx4N3XsklUw&_I` z#Kn``3ZFieLL;?zRVEW_m<_Pb_AB`suO{p?(C;Y+i{;{Aq+D(J1JyqNw2Jw51CEnY)`w#4 zB8zu=x(HF_$$dW{H_7=7lv~(or`SNguO!D9cWhFW-?-GC%Tbt|F(He+zKZv7F}B`T z-GZ))(AsE}*bT{**$EH+)n#^y#u!(%@98Y2gRBcA!4f`JCj;P9C1n?9Kx|vAucR95K9KL?jJPD1t!B@Qfx9RIZB`=wMv)97n zNtsD|O>Kn>8ym5gNMxd#q5k^SXTi~M+m<-If^B}tyEmE$iHV7+vvHHaQ3D%;LD-s2 z!#ZNBSvN<4++dDl%)U-?eie3btVB?@Fi=A%|EO)B`o?%=)z_*v$jmNFJTAS=mk_o= z;Btu@VE&>S>q)l{SMcMcuD^+XQoA|NbMo!j=ZBD_f5_0#<)nC0W|{#B$Kbk-zyY9K zZj8yGoySvF;B%G1=tS;yd&!UYu!c!<3d)bS^^mPA_g9jIFngF$exkL-sJv;b$ z@_clF&E+Uz;EpSrh2MfWdvtWgfjW^ec&1YxySgVy&{ATQ05)xFYWIDVGu*xHRU?Y@ zEBQe$ZR>EQDM@4jVqdwe|4y;*;3&Ei)8?@y;OXaLIAKT@pG^X@}CV4;x5~ zGX?PVYqkx89CtAsZ;DV&wIA}d7i=!O=#QT;9)`@9go3bzLekT*o14Y><6M5k8SelS zh>EBVNTD~i3>6WA_fw#818i!9}&%$Pi}cCnM^M_3ls;)ez#$CFa~hc&CJwjcX*=oX%G*?5`%Pzi|#1 zU_>Yit7Iq&!YO74nz4C33$Op20fb*X-j|g=MsO*F% zieq%O)7R-u#b2yA&VE+WLG`|BhUzZ#Z>GRCVmmQyRB!Enqdqr+fWRr(jylJNHjbnn3Y8nA z_p%isD^p)t$cSGzb4Fu=g~=1{NBzl>ZA+OvP>ykS4~mx#poDi`tWS<)=!#~nZEl}_ zCzo5}U9TT=>-AycwOuTk7s=cOXGpm64a80U87t8-w&S1`h(WAKR1qNqu<=9aj}+^1u@B?Qxlw!rG1E0d607M#aVX9q2y$AlL6b z#H2!cUpW%FFt;6zx-a2U{F~&bfiDI64x)x5pgPOw8s&)0JCnnU8SY>b+EV=wFW-ozlE zKc$PfWJq+nVBj1;C8xFQIqN~~A8p^ez)CSkSoVhrKR5ExNqmAJ{C9He!ZiJLBQ?%1 zVfes-{86M6BYX9s#asCniNu&Y+`M{&>sL;*clm67*JRD4v)s@Oi+8T^DpNz`GEf?s zVQFQhkDF8qUr6ETMjmrZa!$O(y5?3SJh;q>1N+#!Z$AeP9pd=Lxg1!l0hGj@zYe5h z;^`l9EIcaFZfqIy#<>%;*%goEos4QUlR@?ca86O9an{0V1>vh`&}cLy-#yIQrH4QG ziU$j(v;QMMZB)I1_Cm{OiR9CY1McOcR;LilSoK5i07t@^Ho2Fp_ObQ>uuN~?# zp;Sg+fCWLwnv~@IArI2>Wz0X{gr0>ywr)I`D|3f3@6zkqDl$u}j0;gu=}qG4<)VgE zzdL{({k`<(O@9TMp*eQh%yk{cXQ^+^q*0OH+-6L8MJNbD`mrk1gz@Wxxv*>` zeQGVkyW>cD*K~hVjz^BEtt;LoUGXkii8?iH_$%yt-QP|SKEb9gJv&XI#qPa4Y+45g zM=#3N_o7_=4gjRYT;ceE!yG^V5QiFtGbAK=&Z>;w-W#V|yID4G4m0LlCT3Ynd>+@Q zS<6;5uUQNSF}5OPI2rbZs!%(3Hf$`-Fg7y4K&eEbkn?_lJq?oj^@^v|lvlirdq%9Q zjSgbg5<^c)_&c)Y+E29mxfEq{_%h>ReWq`3%dF}d+eb=V-;ZX)mJw?f$mq=x*!&hj zlek%|>+b!@6%0aVAd!-oKys>-X4SSt^0SL9m>$WY23>R*+rLD6@_VM?)&5=-&OMua z?s;C9P0W*rJb7GjadE{hZ(j1cIP&4`ygJY&X#{f`zrTG!`iN!YjNgfJZq53w)2V7B zCwcE;lyBW|6y$06GgbOFX5Y@MP|90Nu?T|jeNo^XRGnf2deg7GKZhFCCZIqrVxtm~ zi00ziW4yd|j=ihrFmuIeo=5;P3_ZMb9r$-oZ*nklSqjHThtSk~4!^b!z)`f?-=Zkc zlg-O@9mVGA0Ye zjPV=vKZdkzNaOw%EFD=1hcqh%3~lpMx>kNl*UIR)I1;HG3J` zWHv+WdFrskRSqxUC*G@}c z&d{?2{*GI?_ES54E>)HszB71Oe>&US&LV?zV8Rzsack{BB8Dwu|D}h-r>Obx`XD1} zgc@XUY@Z_9liwqyTL|65_t9(CKF%Jy!-c~sq)Kn?=7r3_6kEq!IOlf$Co$#hWX_|F z+j!Jyl=gyC-QeQYMBHjMBk+TJ1iWFG6DK=3{4_>;u?T|j-BIKVqhGVx)SPpH_0un~ z{-0;M;k)$%KOnQ9Os%RJ7oeWfo5Yhw(qQhAi`a$rDLAD7^*eT_TkC3g=x(LE@GUHY z>D{vojjzP>3f`IZrzY-6JSh*iFlFHxT94F+jppUp=gLX8ABq#&pcvNg<=P|?u5D() zN$EpBEC@nYX5mG{F{=r>^gqV*t;=%naEAA&PTs%A3*@#G@V3=yh=QOqGCRum8%NBr zZd9v(i5YV`;s2>Y4jnM^Xu#AJ^_d*ChvoC<^83y`AQDf4pc~Q?b`EV!>j}GwRyg41 zRf(>XC)2K2#$Pv-1v;_iUMJLvvAoWK6{hQ~!RR0dCVTIZxVI$7E!mN zxP9w3x9;2~>eOz|97>xgHKJyy7KaFBrWhN^P^G9o{kr74+9O|yn+wTHZfu`Mm+IcQ`?qA_UmjGe zluyTTW*kMXVpJ>ZiPZ-ec*!wy^PzMBZR}qm2tsCHQJ_8}SFU7Wfn)Rw31#@EC^Gu4 zmJ#Icp-fq|lHtL2`qOw3zD?XNdKPoS(Y*}e3r})pbyq4B|B0}HlUcIkEcX*L*JKQH zxAL?ev4s6cC+j*CLC{~Xb~0T za?3}lpJ#E!)DdfO^UIW^`!~3qXhYD{b3A%o>Xk_%17(W9|t*e^&Za?;&~Evo=fK@{^Vsz0W7pOcF3z6Gws;4Mm(-sz9YGM%iA5=fZvBHPjlHl| zd}OkROiA_<-B`9}5dLN#eu$x0?h$4Tm!?IxZwgrjMDPIdPHyZ?NFnVUc5%a^1`UR$`mo4F&p z5c<=Pgm6G0HZkx3x!dW29dv>zQSSzuPMHB(x{uKgL`hJLkk z787^f;gx+8e!p^>IVE?~qxU9skOLFGfZWj;CsQ{{R`B5Ci_&Ze>@uD(zs%l-`TpCJ z`o)SuO~$i+%^>n0?nA8xgIRwg&4`!W6kAtsN>-{v%idF1*0(&0)D$hoV?^1`Jt+Tj z39YJzF?Gic;?;jYr$H5Sp4EeE5!8P_l5cxD1ZMW%7eNp*C9C3eSaOC-2NyA_QwV{+ zh4655$E##j8no%fxMjz=a$r2wbL&kJIGvJdv^u3B^N?OX=BdmcdozHS+}yr^DO0EO z`}V8Es@{AAGDGZ(1kp6C109+N;;OZB21zU~ZB5gQ!Q6{kMb50A{!4jAOtLk$7IILX zV!)4OI2?A3ot<(bN6qtRFR-$){>m(83WvITQ|{MmsO84kx);XRuLS-jN>Vx?0KWnb z7~Yso?TXzwVp5hS?OO43<6w&B(6`OIBp&Wv#G&jBsq1C*!RKR7FK7N$Pr5ZKn&Ht2 zf}kxDi4U)G=Hw|(pE=99bLTjB;R2U#J|n4yLXv6 zb7uO6E(qF|u$k8RLU}&+E~}foo`{n4=psk=@8`gw!yGwslw)Ua@;pUB-iX~?pA?|Q zVANb&J(}O{m!fNj^4QA(5;z(;g3Tt47#vzif9hTfg78J8$2%F(X(BgE4`pVjVwg$~ zSsXqV^Is-XOMm9pWgXIAMAj_Fjz%Z=Ut^n(zb-kBIIOVxP?t?-wBMeLh=?FtwrmU; zG9+Ci7rx$$KbJFd@Ne8H)PdnWYw+%NUQ)~@E+)9+?X1l)6^Z*>`_r(+cn&^Nqck)? zQYpyhXhrhlN4!XtVO6*_v)4?gftzR{34-wDq-R$-epQ2qUw%GcVO>Hk$x&qW@%Su2 zZ?5DoR<@=3g{BP3e~fuEe`C|RC#3$JZ<3qhTsDls!oc{pV%k3KqfYtz}QiJUqFPmD{hA=<2Df@B~5l&ytC`d5)7OPjlw% zSS*>{YQ(zV7O-~rNv_?GC0SvPonLiIRclJ?&;W90ssybd2w6eW&OuZOy-bJ0rx{u7 zQ|S(gzh+mb)bAx&wQB&rVsWKb=}qEEsnBq4VqJpMJSH>AMTxqt2=CO65MKuj0ZRK& zu8a+(z5CIt({w8C?MeRcFrSgQWeTG=Um?|RILDV3Wl>l-(_GgO@zrluflHhDMBc1H zlk%0hJh#v5hf{8{tX*e1Zp==vH4DBn>GYa;p$dfc2x3@^yeI%E@c|c)9pupAqZ~Va zjAJJ@aPnaS>Ru&q?Qco00zMQk?u)N~8G`Fpp`hLrLYGLqx{d$sw4hPNyqL=X)l)8P zUCrjx4@ow%!!xhg<4F**B=uFsSMZ_tfdr(qg90)+hE~pa74*W(%bP-l3sa7%^_;YP50+xN{Kt9@CH+W9EpM#SKK1-48;{yixoTd-7)r)6F4T-p z9+hZRgi{%y8tNQt|}u^ksFFjYs@IYfI>_=g1r>W^e)wacs;(~po9UbG+9 zli&<4Wv#F&MBVPcQn!1Co>mZq?_LTish_J&EGI|)ycit+g@N-!*&gna5rOF~y-7UD z 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 P91k5$eU02(mM{MY^cH(` literal 0 HcmV?d00001 diff --git a/doc/pq_obfs/pq_obfs_step-1.png b/doc/pq_obfs/pq_obfs_step-1.png new file mode 100644 index 0000000000000000000000000000000000000000..7cbd0916795880ebcb9b2dc9a6f5728cd8978a55 GIT binary patch literal 148976 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≪Qgh?@YSHOcD*x{y#Lyl=yxnA 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

7lmYW;4C9s^o(> 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 literal 0 HcmV?d00001 diff --git a/doc/pq_obfs/pq_obfs_step-2.png b/doc/pq_obfs/pq_obfs_step-2.png new file mode 100644 index 0000000000000000000000000000000000000000..d2fe287b083563c9bcef2640e6ceeb61c313e345 GIT binary patch literal 166757 zcmb@Obx<7LyXT`2++BmayN2MdK?a%N?hXSaKyY_=*WeDpT?Th|9~j)0yzlRB-KxER zY}M{m&$OL$`Z-Vc(eGzESV=(=2_7H*&6_t!(o$k7Z{ECHdi^ecf_Xi{8{6ld|%Xsv6sovazsnkg~Gzv9a;7bCN2_lgf*!W#MLLym>?V zMp{fn%`NSC#Z^aR=H(A$&XnZ?8cw4KVG$`j-TEIvhh3Vw5r@3wYsdT@8u`)q#oH8m z$zeHmPSex2H#k}EsNSVuU@3{*{@J^9e|i4%HY5c8t4Btphrpr3*;DIT)6Mcj`(B1; zg@o7#ab?VZmg;n_hWASUZpS6Y%hY52dxkQw$VmG?VH|?~pAN@a#l|E_$=JYV(}d*E zxCaUSz2J`UP})E*#@pkij!eJjpC3MaK*zKv3Kta@X!C+xLGoQzJZ|sQ^YhA^D>YuN z)04-)YH|@*uI_RoPsxS7w*T`&`uzNpkdN@Ikq*2sHvPk-T9L{}?zv679g?r2-9bD) z@BQ#N5`NL_DP!2KE#A&n$m@1APutNJokCx;7^mU;H&5;qTZ6_R$Vw)mfKw28_MY^_ zylTl;tZ;=*m9_|~bDxZd76Xb(KH;t4~J3sgHdOv=k78Qj<2wi_fV!xC9 z);GKq*qjc-*5rAmv%vM&f9_~%)#Wrpwp=*! zuJL{KLI&}Wgzm}*T<>Kfc>|mN{MSIO(7%_KiD1!1GQJ5A)@0doym$3VErzYO|8Tlp z2cu1=|ZsYLpgP7j9qRW7)cqL%}{?atQYLCudt z9A~&d9EMn(8sX!(63ii5+}levH#wwEIViKnuy)L0%Tf6kgMQDY_Vgh+0s;75vdVFU z_WU4z9|p}olg|B3`V0QaYpsn_@&@ZxLik+iSa0ny%NOFfME5RN2r8$F95!lWGiWnZ zTjnn24(rNNmk7@6uWz01lg!sp3M#x5Buv&Pe8CJt`Vy6M*}Y;H<(d_JI+R?UVb0kq zY8U36{DNye!y<{XKaGZPp%~;igjCYGBDsT-;j6LxCs*q{>?ll_eUtVz^NuTs__6|? z3Wb^D7zu;w629K}gTCF;W*qn&cNP<#Dz+Jf*D8IZi=u$}3~1VFWPgD5Cw+yr16<*| zU=d<1fdq`)`MOP4b*tt6-~rj50)R@9(Z`Y*ukf+6R%yTLdaYF%apmV0wc+|48s4so z=PxE+bFmg46B=crCkD)?PO%=tVXBF?^WMAYU|0>-hnftImQ=I%`|v8ogPvh&O}=E@9taj)0n1yDFeq1H(F^QfuWBd&u&{U6A6ntx&nmo&?Q@ZHD?pT+wSuI&DR{+|2y#`%qxxmpzk(+ZC8OafiV#abTV zwU7<678kyJ9?Hv?k_Rs9tuGXOpZX~`a1rD?8&@{-Gty$mNX*roRn81a|aDI{I-M9h=7KElB}5p*#YIA=GW&@Te^Cgx4!Z)!ls~hZY9_6 zGGo4G_o>CUB+(gb=Udi4+51d2_JMGxdI7((S!i1UKY<%>{DVE)YFK*+P6i&lge2S? zJmzFl@Dp{~Wm8lrUZkylW;SlG(^msCmh8x53!l*RSX0NLDqKEY+M$He(Ru>%{)Xdj zr7~PTX$lUWILW}a*ufgb4NbYg3N@_^-1<9oAJ8?qIE+tF;OfY)b0q_knOf`ik>;P) z`;gFNVjn9bn{lUL7d~~Hr`rp^lKG`QvrI~H<%>^$D~}js`=yR7`L=|xH7|Yy$2C$G z7R20k`1ZQcqF8yp;LgrR!)fKA?pSmbOu5bY;bl}L^ zq{I*G%_?I8w8!%u9qUKhXY9|SwnIDb4aI0Sij!eF7kc0CbH6YUlY1Me*3@!qDyhasnFlJB7P6x%ie;ao_pzR_A_Ns_l(Te zU8(xWqDS?;m+cw3UE~)x?4`}9FG@MYWt&O8d}$OC`jvJq!s$#Yz3ZT|WS2+5O0)0q z>BVkT=fh3H*||+DThHl3ytrle;G7YusCL3eZ^!d>Ys^B68*%Dm9cByq;B_W<_0jD| zo29tU!Y9vGt>MpGTzC=dJ`8ZyRe)({dDjxwe)L)cv|$v=t(hYXzLvIiE?ZRwYOd$O z!?ukc3!%CKI#c}X<0CvG4Yx_wLVI0e|px6uU6xH!1`fcKZq}Ff`>gk zL^w*OzhdJOY#B`ZBqWRs@z{hI&Dg;#5eUugX}BQRrZdc^futsKxhpL$=<}K~{LIQo;387k{^MKW5B>K1v>#X2iq&}8q5(G+!O2PC z-R4)F#1dZX-`?Ii^7o*2Qil(g-ul_>Ba5a$l@8%{O#dps^B@3 z<7@mudv0ud>ELpq?&6K(5@r*33vE{>xyHzRZH4G4KX31es?UXcrpU;mPqJEB5%7_S zuPNSBpPRTr)W_H?lJ%H*D*f$BiZZJm-4lS}kB{@GOKstjNLwy;AT`Y`163RSOsVOy z#CM^Fu#c98zb^;}_f}-u&kNt~mM+bEmosImReqJj;;-#zvM0Mm-=#91>NVJ1qXbsh z_2H^Fr5XQm$5>=DwjZl24Nfjys&_0urB}N_Ry^TqJjS-)92TTAp#p4^Q zZ#cNT*^>th#W{PAh)?{fvX!V_*h9E>*LsI#$7l+tkLDkc{}loat`0sIU#mWh!EOMP zOfb*~#*D$oThI@cicl^M4a;jpAZPjn${xO*{UxT{P3emQ810(yq(#$S(Og>%_Ffu8 zvv*K2V=!PQ`Iy9GRM zxguuzII06+i$SxroqTMt-Jh!_P13z{n&K0hx9ojkOjcNnnPSZyO{SpJN5J6o`BPAa zELp}VcY}qaxy)*5-3&)PTg|x~)czI4dx103h0^H@e18WtcNQn`?#gF4d8y!~?QZM+ zdpPz(NRckAr<~3_Pk^iB?H2F0Mm=&Q8R_Cr7cV`X9BZKl|5e5ZjOk78`saygHoivd zwwTXASUVb0bby9pDj0JZQWvV(cu%8Yv$8&!pSta8DN{&%c4_mzP_hFz@msM7Ap(0& zm2-E^#gnStrm*F0^|(|$&f&;$zG1QT<+?9b1+m^(SLU1@3tNJ=JvYm?Yk|pBMC+x3 zCunG1;KttBaZf#`)l+47GURfGKKEfI^L+ig3XNxF{w!h3Pw8Qq^8*KFC`n#|ax8)+WA;^!_g0aKSJ3)P~SWm0} z?0Mq@Y~hy$Pi2f2ee_`&(2xVOAOtqIiE4J*h3RQvYuw3#IP+0GM$wg%`Xpf>AOuS` zn>~|KfCJlc3;kwz33IfW^C!hYn%Q#KRufZML1~~?`?={XVHm}=Iw3dWoqfeZT*O(c zsAnddfU7-i$VFGNk+%EC48&= zU)7wM!(Fz}kcp+UZKaRWEXx@liHDh8WC)@^({ljIE=(!GT&R$K)K%i&LF6z>gKCe2KEM8U#YU1%lj{ z#tFy|N%6%*w@;SgpT4dKWmIi~@K1AyXszjZ2oSK;b{P*X4K@ z>GZaoZhK9!)~Ze{)CO`YkGjg6=!bfsUV zvl+jxMED3T<_{z@;I)g4dg^Dw;^j_08DdF|AbDM=xMKgvclM4T)0X9y+~zwlC%zmi(g*0|EIz(ez0@(QUb)JMw%CS#HIA`{-r! z1oi;NZJ(nGo)tuI`P8`$V;8UPDIy& zLzf&pGTCxou2Ev~2#IEzES$$NQ96xA1#W#Zmg1u~RqfdbdZD@1;#xZVjY}2dSUBwE z<)o$pH%k7W%XUlCPv0-~HB#hdkKXGmm-EF#@tHD^sVLA&7DZ*w<=WdHxoVa$B@pt& zB<%q(sSE1IIEWwFWepXl1Zw{{!XO3w7$tPEmH^CS ztCi}(we6A>`iV;A(Ou`E3S3$;bqJ<%{i^!{4^~cOF}GCanrde@si+|C#yMh&vMXcP z>sVc*jj?-6Zo>2{&|ziSzs0=~VuiV<^3fV%5a(7f_5wN1oX8lHO-rgb7hX9#GqOr2 zV87kV@5!)H*mpcL5?6Nclc|qS%z$M25k{~Yelx{H5N>O3ivc2=VO8fgmp55kh_4ecH;JQ?|moR6+%=;*@83)U2DkMz6yaZ_aqW zZz{4B#l^@+xjT!^OMk^h%FLzi$;`wmh!O`khAnz(QMS}w3Wvo5mG0t9XD<`CUNMJ$ zt!-}uJpk=aL_F+%2qm1spxN#xeU8YU+Uau-!B0YXZUg1~kGdd5cCT47DyCDBr_ZNN zc9X33Hd`jXs?cc&bTj%u=0Z=sOfa;OS8)1e{#k(8|-e9 zym#~Lv%a@^_$->^6&VkkzIbPM=k8jaL(}y2wX+~QHge_n)}P?2k=s(b$w^}@6&Be+ z;9I0;=&V|+1_mPGD#id(IRa9O8mLIPuzZ|m_Kcw~>s0j4_{@l}L)YIcHE{Xvdnodp zUiSgt9^*Nd{-R{&)XD)Gj*KXUB^BcLTiYrQT&{TY;S{A=>@a(M zs}%MSkv0OBJ}(AZ$v#1ERU~RnK_3FJmbVBSN&M1vw((s*C4|e(>A5Pkh=hUWd5vLR-Stp6cN*w0kZCx`mzH|9xkYQjRBqc>MhmRISTT0;+EDBa_Yagb z5L49e&xt(k%dP4fQV~6DKf`OOc<;EB*xK+?_iMRGm4@FSn4E$KJ$Eema0WrRN>=$X zfE85zby(XnVCzzeYy#PTUs0;o?yA1ENJGYy-&sH_FMl}M0nR>GbzV$O$ zMrpy1XXF%<2t-Bq4BnU4F1lV|I}IcfpLWM+R!MG~PL}&qtEi>rg83k9p11*e`{Q%` zAtiOy*;gL@xe*T8mZLAg)(^e4_+1si^))fK5^j<$ZkF9xEVDI0_qpVmkwCyx-}K(n zU`Wn3`s?73xyk6=lb_UVLY~W$%mK37`@kC#DrN0=zz(OW@R#5HF9MtAOyMM8^z;sZ zEw&9~Nc}3oW1}e(!V~Oy_*%NVv-*5onP29WgGa+HQYx8o5xXHlCiH@GYFwj-#ON?J zJ;^1Ppo8c!WR~(wvWQvjSA8a9uBM7^3Ji~syDA0>Gq?Z#kL9R_O&{_ z4;TMWG*4%VyLIan@C+&N&e5h7xhIRL`_6E{3$wzYLT;8=jc$D-Y z`@z;*XX7J^rx}^hDU2`aZa;@G;0{~}wDx`h2_v-J+BL7?_W4Z4!WdUqSw?K|^nXSA zz7nUiCPri+v|XKadG?m^72vNR=yoM`$7tEj&YJqI$GANe-bjb#e7eqd)Q2*fa z(XZa|R#c9|Q4ow((X;7OdPD&RzH8?wif1xs%P@G!9!@%Gg~)QRfUJdKzlP7>bLH6# z=@o=Og_~he1eWhU@DlJkn&zQcS0zBr_I$?(`>&2%`3=`h#{DA~HhBYp304N<8AMk1 zM>qxTXR-yl@$#mc)43Ri-2~@PLkD>1Cl6(i!$soAclC;^vt4bPSgBvWe#L%ibC38{ zX_}uuA}9Bq6iq_#8_2S-Wj!_M-dzAefp=n~w7Av%EE+`kGq8*Ga0LRXdJ9$aDP^Bw zjG2GwCPb!qPk}*_nf7aK44IFRC^Rcxt;^T9QCL%!ZKLBlPx^(^Rp^JoueqQ)tBgCQ z87romhX)jMwS{mOjCzO9sqNcl?U+4~P%0=^sp=D4%QVQEfZ!>XW^*nGe_Zgx5Qg{B z5Vp(md9L^lv_C6@Zl>gWDXaa)xG>Aj6J`gLm0%pzeKoA!3@`0Wp4-uSN#Zd!WPPrv z?=o`v;PA(VEr4jyy(S^YIE`JdAG7mOABZt! z%tqoVxCtYx9S6TdG?83kcW8uoqt`v*IavxcJZ|a&u05Y8RodVOJsx4K5_BXkVFOrz zhD#DYF(J2Ln!KvMD(`-WSI3jc%h*wplp4fb_3YOs|l=>|a zn(oi~R3166n!{x5L`$g4;T!pKW*zYCO?mRpviZvdWH`uB6)@N27|jt-?QDuUr+B=v z-b)?cVM^w)@g=}ks^B2Wy!EMwi7HRf1}NBZRD&(TB}FwMoP=3x7A{Tk_B)x$9*z?U z(U*MX4)zzK!UyWurMHAUDgI-{R6?!+PZKRy#&%0NN#x!JUCW|`_Z#m$K#p-E?V`z` z&di-P#qAn>QCwDIxWEdbv($X`+j>g{>GbHS&;S;v4G9+;z)+a?=mE=IG}_kE3dyC8 zHg0C5_s)PY?47x$stiG{rf>y05jBxJbg!dkWMpQ=lh{AIV_Rf3s;uvk#O5Z9Cee|5a2Z}MPRUZ*ktzIN2>8^F)-G-N^f z>Us{Q9S1H8IpxPDfhZLl8x)GGyYus+A9@;T3K-N;tX3FcSQPuQyw3KhrzdrgBjH2G zajz-=Fxc|@R(~za5zV0zDx-w2>ltYu$j9Rj#pF_VuNwC{B44$#>9!yDjM+qi)MCw` z&&fR;rNNW!pkIHQ=@YIZh6f*>wKUWr_^a%(MfUYiyj)_i$xiSnq=NHVgW4)S@DYZ;TBg<+Vb%gP1E zA!t)=`IW=XLQDqPA{^Ks^IL8C-F>DTs+V7UDTHw~FKqC1M3@2nr`3n*$krei)(-ir%!V*Z}+e>%yMGOz&OOgJUaN{P16K zR)VS#!kRP%N7b$X&tkQFKe;7bx;^rjn073NJf#+Kl>WF{2@gJiw4ZIxS$qd%J8{!` zhvBI~P;HT{K(<=njmZA@#3xexqshsvm#@5pFXv@9`9sCYqxo6bRp+;I$oWD7l9MSJ zn`Sd#+JoD1ex*H5YL}%w3_r1`P&$EOC!0k$X_L>!&a|;(OOOCEdzIHhAgkr*N7qHx zLw;Vlut)@Ub}fd?>2>$X7I7q6<8rj{@|xTFOq!OM$#QD@I%wH6U{@?J^banrEKFSj zApbHLMl6?}rUHp?C{I_KEQZ17hL(~K0hmm9J*{lYda4GOF{cffrlFk051;3Ika-Ah zp)i~m%vU+$jbS~eWGixJq)k^O&qC7`(J-HY$lf`71I>?5X%g^1g#W^Hwxl7VIvx2f zgqADDghydb@U5c(1w1cxkaA*lk>TXYa+PM436?!lM?@UuM%C3Z2o&;uu}g|alvNn`9=AdqP#(U1r2`#@ zR`R{*wiW1pWPu{lH*#n}&ZP-5;smLg2og^(cA$$jqOlyT4`SsNL63>)jk3UuP3lQX zVUP}ni-~&NN2KR8N}K*YA${PjO`IGhtfD^LpTrO>Js4ww&YDjptMWC*sI`zq=4+Q< zd=Jea99&FN8lA*cy0vs8rF1bFSur|WMS$kMjBE#^B9U{#78ez@jEX}^QV&J(pmalzLo6CnV>QyU2#(b#m@3C^Zt6lK9xS z*flGp0hW^FxVnt_>kdFKjy_H6MOqfV$!&A4NT}VW_bjsdd;7p)BtB$yH30PFC5%63 zBf17bSO8rxP^(AoT{)O2RO0rnH=*S@KXE!j>`-6uo#PmQKN+BXW8b9Tz9m$gQ5l+x zgiqj#gP!-c$iQ6)UmWWP%8sTq8nMYG*MH}2wMZyj_hZh~1rFkDH8>2n;JnA*-nz)9 z1WlT=_~5vQ+IAeITQB7>@B1b;z$#qhNsem@n~-*-c{dumSQt^fgb;b_@ixN<0C+_J^U`gB-yTI;A zyp-wwcgADsui83JYjgDphJkGovc<$>+E}pLe|1$=rXv`Va&JV|H6Aq^s@mwq5BJvT zzEy}+3BLb*1bQUVsyAnbg;-6Yz1PawqZd}0!R)zms5MN=Amcf$M$w6@_{Uta%vtnn> zN%sfq+WK|~1WHszFozsYn-(~>olqCR)?~^%_QDaTIQJ~u_gk^r00fjccF7mrqDJw$ zy{O5Xofw2NxMpMqcn>Xx@h1~dYp}GReR64W$+Fj5d>tzY#J76qYs3kRiH#J0sz^4t zrGCUWS&KoTL@jB5=--Cefo?KF9j9oax`=2WKaJ9JY!w+LRbR z-9N1J>k%^=f55ogyx!sq4mBk8xV@a*uB8{rL~$=ozTa@R{wVnxOU-J|_B{#OkDgZS z2pwsiy>lHV-_9P$UFNwx)2V*V{&ty@neBBdNHsJmSEm)Le2Tbo@w)5iYhvlDV2w~E zXg9Y10&f>u^EtZ*voyr8-bX`JN}iJ}FDlMJA<--~2u>KOBHq2ot(Fqv{e+aJbLR6w z%(I3_{CpILs%<=Mf7R%=+kgN;YSsy{=S2Huft6gpkL0FnVOmV=s(|bZs;0 zmMhPj!4)=gU~lvEksjcq(6vL8Q%Mn9si~C~y65va$j?8#r?sDM{?rQ(@X7eIQ)E^_ zv6riQ(?v<$ur)^Mu{R5<%HhnU)}f-ihabEPQJ!t$QKVyfRl5l|$Sy`mlD}c@ zMEHMld9F(t^^A15cOYy)#4khOQR=JX^DbY@GZds|+byE?A3YI^6-fm*JViJQ`}mtS zSFTcIE)C|`VxwSQYMd*uXEPQ4)Sb;>hcEAJn`d3 z%@37}Hav$hjrQ~(kJ!9h`9Yu3>GsA?NP%HJ-Jq!^@?7q8YVllZpuHlW*CXdtAV=2i z@KRRsU!vmO-!k4bHgZyG%IgV%*?mVzbEJm2q`}t7VRtn`%ao7Z+4Pn6_?zXc>>qN0 z{wkEcuKzCEsGJE=|9ktd{Q7sN^&JziJ#3*&C<>bM*UZ20%?=ie2h_}DJR^Ncztur4 z)A}C@Cr;yw(rXVAQ2VOVMpYXR@4E0*BF?-T^EaIf_;V=KXt~jz!+J3;C@5$dc`rWN z6lSj3>%qk)FzeqiDn|=7)Nihi=1do=jXA95SzO^SnLX?)Gtm-w&jml^g)fUAvV-@Sit@8U9cVyA~k zx1jzHc;x;OdNdbV@~xE3ZvD?P@=knC%zx$oPdvQ_jam_ELPA0l(Ga~j< z>|f`+NYgEhG4;hVJZ$nm3%CV|N`B?d%<61c`$*T)v~_x_FjGRTb_wkoUitMk0fiwI zU2=Mm)Yn&($NQ0oS|I=(A6ug5jv(nWF{e6_TgaK8)y~SbM0;;&miFKD$G=c6E%g3Q zv<-ahMVc#dQ>%M2Q#M?d9T(KU2QLu+o|Ykwmzo~?1)42KHV(ziPXoI4JvOH9_bf-q{(a7> z6`aWj5#%)BR&WL&K3zQCP*l@2*vsL8W`SGc{0pG|_lF-ctz0*R>P%PWsvQD%&VY~( zu9!hx`fV4xWERvaXVy|z!tEqol!P#wHwB-baoOWX6G!v<(!ciybn9^NgMBV(cR9S; zUC}anoCN)yg~v@h6^G~X@k8s22)vP2CZ1{n1^W$Iuv~K8=Q3JfL{Ri9PqX@%pO{&! zOuyvMC3%j)C*E5Z0fmJ5tnKv(?kIKX_cN^H(X_Q%Jz!xY7plw#_pOj`JIKcq{XYAa zhicSpt+O6`JPz!`s5g0dE63@4mN{){k~F!tWhVYu=i3KJ0r}|3H4(*L5XKm5`akV+G}Sv1 zvM75m;#1A3o{fEvYdk->7>@gSA+h3MV5?8BaJ3qLcHO_HBPVk$wMzAr?wnI~M6vLV z5#F-%s1_E>BJu)|B@3D08ZBe^HTthaAL%(a+M?ODs$LKib6p`F4Z19A9NSJtGF;&O z@PPOYzQtV{sz@woO1CgTIKGkD@qHvLp0FcYY9v23$WLgFE^n3WB$1JU(Si1z zxVwx;XzjfLgu%8UDOeDrYhmeE(fVoF$`l9xPF3@R&d&FU9k~H58=R6KEj7Bxb?pbz z{B4@w&9fIP<27O}7REmRH?T+ca_ti$#YjS#Y&%=S$yI&QJ2^eyK_9Ty@u6s>)xFO7+5z8IPlwJeo)B1BTl2qMz804z-FEw0rlKvf3sg2tNK=3wyu4{M-~U( z?;nSsk#{A2apOJO$ioZO;zb_=>LOP9naT1&2lH+3XAlZIKBNTmSN$|Dy}2CcWEWr7 zz8Gtfr@?561mcua3IH)+kgcVYajKuV8aXW!uQLaK(O4D!to5l@CIdgrR=G&BfU9V? z9cdK9cTdcZR6}6bZsxY{V5l*wsJSlo4%__uE$oZ#@z0zr{T(9&KYH*U_M8mpmH`@4 zw{U)`v=beyX7k~dh-H*un4{<3RN0&$`{o)-5AJ=r!yh$Yn+;TP-_07;cIIxNuVkh2 zw_duo|1#CWcF_lmm_|{i@A8?1=8*yxzlx<{gJC;4ve*OkpHJHCGmLqu(67_z@ zsX2Ie6u|wbbm1W^?G|fm?QArxyARQlz29nk>mCWOT|3nC1YSoIiY%mOduchn@>TY; z)pM%b%uARka`^uAWbki1>*AfIq=Yl(&F$osN9d^S?V5-3Ql?%#u$UFNGMdMAs%Fg{ zovy)XZ#ObNntOS$r}67>Wf$#{tiL2;ZFriSVB)ro_XDMH_eF!~T^-Q6b@e{l@mHJq zuBE|NKcgAP{+SgD=jgB!^+=D^W70iRV2$>X!U;T%CNu&?&-P`gjV^lb(EpCEg}Sb@ z&4Qomv^6B(kNnP-*w|ZGxJ2!&uNB8*!emBP&y|G!XVfpjVy(f{jJ4y>5`}w*sJGtDdB@e) z<5v|4iYwrWhwZ&2D2EH?K_# zWI_{CJt5VJ3>;jxvDtj?LtJnMld@iFhtx?hSBR<)1K%G>t$26HYJQEedKnOR!Y4Rr zq+neEAUd2+(HUqRdM!lJkQv0(AS_Air>8sJaw>?4$>I3K%^@7-DedJun1<-+%}X5D ze$2aiL@+={Q>_nga5LQ(w*Guj&vr0aLtUP@N?Du32-co8)xV~eL5e*~#X(E2OAK3f zWnUpd-X@1P>RQqhT8`lw@H~ZmNR_M+tOobc-h>I(3Y{D9irFX<ID^C!lBr6LIjhrG`XdKPuN#R0Dsn4XTi1C_U;)$ZP=xr4HY8kgU_8V z_CrJz>`^(@+OuN9`VWy}+!p0FeWK=H<+ZK11pgSG+Z6P?CtDqW%Lk&<0&UTNzgsy)pSiR`0=+aoQ*0F~zeyK}|)- z+E{xkU`XAbT-f{)v*b|0-1?m)GV$k+6YUgr8?yxmaw}-E&)9yrfPSVGpw;=Y@Q;LR zDh1|@&KMjHkgxOBTM)QKkVqK6`++lamy(G+F%fxdE56w2_JW>o^<JK(QpNM*S}g6k``#OSjSUFsy*;{YZVP z7To%c+Q!=8ewwIf*S0e&+j+ol+T+^vi>#+yAr8CYU=t3e(&>Pu^G!557rQ-_j%ojh z%?ZFvw{|r4Eh-?EtH#x#W;skj`GRo9lz$2LllDY7_byJpc7Mo+7hG{?U?w8)=QJjr z)LYUmZ4C(pSi+4EX}e{9_%&gb{aPn>RRWwru#gb9i_h56%AO;cv|_eyu9=$t^kt>m z*;p25DV_>t>G%o~A)lK+1sc?N%@lk*7B}-g4;9}9CiW9dV8gBVE`hn1#OT~7gpRO< zNfhRBD5a$=BM^mwtL(ed!-nP)TXe*ZHH~uT-6~~qXS-7^t>|2tf&v}?2=AuS<{Kf5LSiuYQ%uOAdf16^fzF5Vo>^1=rBHVax3BA^ zd<(Eq;bfz`{p_?P5w_OKzY_KeY)rQHm;s>g08#K;@zxgcFifU?A?TnX@fA886s(e-EAdE#($(&74j&xU zXmZ%I3Lc_#3c}t*q+9A9Hg0e2+tYm8L*i2#3*a8Dr7Tk4r{!b8f7w{yz#UO{#;rS7 zZ9NV6exK;~6P#2A!fX2eq3#s9Iju3%OQd+elq*je0;MeNH{54vpPvmGcl8lX z)9ee8Cwf&W>JquXF={w6-4hl!X1_-#AGhm_i%b#H6X3#;73$B(7p}3|`kZ4+<-pE` zCLetzI?Yp~(Tlcm6Ks#MFqd zA$qivcK^t2^C}7AZflJ{*s?V~WqiZ8>e5j|T_;}j0C@ph>_j+`^t!humMHB1PbiIQ z|HGw#V!D)2Ltwrzv*A{@nGMw{1(&jD^aZE+^tF6*ZK+@A%G69ysxr7I>5J;X&m0tz zT1+~lNSKZ5_)x{V)!N<@ngc*G9XI8Q7)GKWGn!{EsX~0I63-LUWPB%>k6Z6xc%iwp ziaywKht7y0VE6+tWJf}TnofgOuFt@Z;?jTx!{?e|ZX}Bq5N5zUh#?|A_;)bM^?!mI zy_RGKTVs^i%)|AqPHZn5_`*GdL)XSAalV{6Zwtd__OLV%jiIF$`&)(+MO2X zjwtA23j=aQ?~xC}zS>1^2IuG;3OcHd*x71W!p@{_nl17AIz$b6%4ntw@y5ePKKpzg zfSm{%rDeB`QPrS#f_R3{FmuN4fmk0Lf*{v=JeWDamm@7DHVUcU*FfHJtG zX*t$M0Zzz;&Q760g`Z%^=H$NrIbRF1W(g~vN&x4TG2(80TH**)_Vbwf9>#Bo0?SeX zATE|M>125K369&AG;ZM5wVZQS-CRQnVYuZW4zFe~>d8;{T@lF?-(4wd zTzdgyAp{CzD97(x=5TBN5Ct+I6FpbYz-ebHm#t}qiL3-(46hD4dAEFe;6m9r<*vyn zR=_3GV%LAu?Gu{c`MX$7d)B{}4y~_%Hy3xh<*ngze~g3C@{|>)K|<{o^9B{SKWqem zarV`c;P1^-{vcs)Rvd9)@R6G9mC{s~TIR;Aj-YjQ0S7x`?@E++xK-TR<` z;LbEsc(3LV?5w#Emlu)AIqcbxrL{NssA>wc zR4<>cZvv#D&hS%RQmUN8UVd?ndLIgtPr3N!{;Qh#1K#j6ZbYH8J|WSi66fTiY8431 zDT&APo&&{eVELALk11J1!*}T0>DowsK|#2Y{*dT<+0@Og#?PcNF62?XNb2edW-2$3 zr+H^Q$zw2fS9t_1vSO8|UOiv*KfH{tT;&B|^Jc_2+vgtnSW%056NRl#UeLqZe$NLM z<+qs<;PqcQ|57nqksBGBINpoQ9u`%Vni=SPEa`%y2Z1PnXF*puc0L)k3I`tt3p$DQ zd_2S_ydxW%I6v#1A)bRyC%Pa*#m6`?I`cvtPMfxi!y!?vuHirbz!t7T3ab07P8iC< zk*1xruzVoSc%D=Xg1SZr(1qVS(VS&>809HwJ)%{gi#~QXB~HaUCwa-dy-wgkLT7(^tz$1*wX`w{eo3s1F-pE*Ya2xH3U4H7~rfr z&u`7pA)ZRg8#c2xuD_McpGalR3b-~43>}kOzB*c7Nn7%yI)`8@_B~en%X?n`Hk<-J zvR!$B*q?l(g4shoCd{pPklKNR&{;}$uMb8iGx68NAAgU&q|FSZNp)HO+}@TvHQm}V zv|7RL`Zg6?psieJ={a;TsJEHIY!VbX z5|Fl!ie5>CS?Njx065-?nOw4+ir9L0053O4|AobV#YCN|JNqc(KWaoa@I=qqxcEXh)UuTP@}E7DA8v(9aApmk)}?03v}2uEFb zd=swV<=|WG?N_(l`+iXBiJ8QD@Cj|v-6s?gjJ|2)y~Fm zch_l5646Un7X;>-fn|3#VA+Dt?*ew&jtQvZ88~tVfwFx>9wFH;Ha1Z=!}}k~+oq2@ zzC5p1DSKx=|GfQH!kB3#L((B#0Xq`oT8e|24kKbnzOxvS$hgN&V8U?poa)>~`ViO@ zqG!l_;@z62F3~5IyfCfc)VmgAtZ~Zp!r|OSqkIXF7SR`km4vq_&z}sm+>yB-1x|?))&;d+ocBw_H67#KGv6GY zIwo|pqdb|$$kKaC^CE|cw6IS30}noeUf z&Ft#cbDF#}2*3`%?JL$0%WJ4}g`7Oa&@tbXP#@Gjrx`^Q$ zm-(TVZ^7maJ&smUc|z{d{BjQF-FC%W-#_D{a?GkUi}+}{@d#ZmgtMaGUb2`2`cyc~ zdS*Ra3B8B(+Z?}f&A=H>!{be6)nYQtiFrUzXo)~WQdL7l#zPfh+*?`|7=tawb|2f! zh+2kgG=ixqm&nK@ntoe{IF)bEsH= z5Z?*{tJ7T%|9K>+Ut_`qYjS=Cs56jyAmxB9#7pZERFGf?tIwS*Ltms9wJbka+aI(s z)udO(Snuo<#++Cg{m;CHAk|A7p1UTp***ixJ^Z!(K0 zCc#A~ac3nYbgUqF1f-&Bl@U#+p#UQ_&}%~i{~<& zb>RV?ca8!YWI8WZ&sV3XP{6?j$5=^W@3kH%*ie(0E34+CP{ysXNI5`GjEyK2Kz@(bL{ssfTE9w9~#5z{=u0HFElg~9LXDZXjVQ@`y*|?iT!Gl&% zUrvOa;1x($T2Dw(n_3S2%K3ej7;}8U$v9MkTQ=iWvD0Jx`{V6y)LNY=@*k8T{K>+| z{!_lGoflEZ%PYzN|9dwV+p5a$Pp-YstiN+l%k2~>{R|7WAqDL{wm!&~SvQS6A~a#` z%DJzC0oK{#{N?qP2O#;Izpp%KA`eCkj-D4m{rnjYD;p43nNkj(#OBm4$q&i-rdH=v zgwI&MqEb?4@l823M+V)K@><9;N|rW2E2U`o#!~`r|XK&*L=)28^rHPZwYAqfzI1qm*}-Q9z`y9IZ5IXJ=H-QC?SxVs+Q^&kg#8oqyY-+M>D z^h4LEm)bQ-cI~lhuf676a|Juh|0-P_>$jwqPn>~d2BGH$Khjaqd?Jn^0`xRL7I$Sc z-Y^f!kgOU-8)lo1FDBPI!=tP`t@ozMW!&GZ^>{rd!ZVm5+J1*FiZE!YVbPI36*T&3 zQ51K_s+TVWoI#xeX$6Nq%BuhQL=650=&9VNpo+Lmev<8?3%xXz<5{`$qlwHb>(oD^ zg^m7q6f7u&4*Tx}uib~1sAgU4%22#fR~AL=a9Wf-lFkcJapC}aObu+bZq65%3Hx{{ z)kf4lTS4OVWn^dXGmOa{_$hokyzK%X?Am77ZeG6`fd1Nz_wduRwPn+kS?(E_6MiJepmX<-IW1dldtdbI zH5{oHCr-H#ivH&!KTvf&Pt{;cfAy(}?L;e5vd`AzJI&|UeD&Go`{tDpE^ipg2XyuN zJgS_2rTmQPwR)Jlfl07bj*fb#83R?W&Tay=w*hs!2Cr{|bro2pcZ}w99y*Ig`#;#X zrI6=R#5FA(2CUF4(A2bJaq-0L8`s^%ov=I}WNNVc)JxV9UA5^&+E^H)Vzv*F$n><8 zK!UX*=JedoI=aiNX6n<8UPcXX-Xe{j7(9x+MG?KnrFiCh;Dqj}_^If+(m{VmA@QX% zp<|E^DJeR1U+KprW9QceiwRh(%s#GO>6pC>rDfjPs10eFlxlqh8>j-eUeOUu)(M=+ zaC)0ZkA*BU*s`=VXbD;3M-V2hmUs{7NU)$bz}{oL`Lml13L1i})hN@8*WjG}XR7^n z@ki2{n3NrpANy-TlaG8M=E(18>rsjBQ%u}YCYWw!|Ai&J&NTTuDp~RAr_SeGK3R0t zj?Z@zBhw@vm#<`FtG2#`-8o7(jIkap5Mhd#$4+=cZ;f8fyoVB$Bc5?R( z+njIRIm%#0QU{i9KgASxN4&YLMz2!gcMCBThFpm%p7WNmzs^k{G@?=%(Y|?S33rXaoOyT@J1$EC?lBY46z$Vf}vz+Ig>g3JV z^okNq27eIR#&L5`)k9Is}hnk5# zXf}-2;_Porm$iCasxDHy6)xzuLc*)>gA&D^VDgk%_ny~Dh)=^6V9cn;jPz%J6G(7KT^qI|r$3qD=m3fckuNVMp^)ga@-}fhV1|E6H*zx1SfxWQj zrB0^LTF`&o8yT&E6{*z$!$e7T8eghJ&KZl{La5IWP?lIuQP6N2wvJZiZ_NNwAp3U%_Z8oY~v&XX+vsxBhXrH;U& zz;+Lc(Znj<`Nyti5T3vaL>AM-X>0R_-U-`M$g9;aZQ}=eXBizotxGGDkAZ$B9pN#F z;3ec*oQ#8TTJ87Y=Qh7dr0B9vtY(6FqjlJeE_W>oOpXZ1*J$fz+!|y-b|%<^Sm4Ch zLQDd_2MFkjaus$0n)dRlyyFYHXk+n7qoOn4%7`nWpefXwqQ-cVlgA&g3Np$_H-ANR zwvf9QLMrSHT`wq%7{=$y!YA?3o~W0Xh14ZQDV1&#?X^ov!b}P%Oab}BQ%O@TxKgr| zr$fRD43PYrd6~ostz6c}yU-oYLi%1;qB9o&%rO(CwxqTWH|(Q!8_UY_+{as%U~_{b#9CuZSS^~*435Wm~w4%Gtfj_R;#Yq zYoz;2dbO__BDi;sMQdD7l?KqI_gsnrT556Khik!4E!)!i2Llfe4P7K9sErdkUocr7 zL5;71eH9YW{@_7}me~>p9z(2I(h0iiUY58%#1+_Qif4Nq)&_ML4pKDJ5=1Hb+r#C! zAnLqgfFUFe@T#t=-uwO*@V)U$(jG%k)Cyx%iLCg(qStcgI<}J;U_duHsXY;N6Smrg zl6|sT6>iuVEDo3DiL;hR;rTQ-wq@Mod+Zr>sW1LzA#Q`|GA$UcyA-AlX-W!X{4FpK z%*C5y^)#$y!IZXf;G8Fs2)U}Uh(uOYE^1|>2tW|U>1{C-$6?8U4J*2w1zP&y0GK5^ zlZPoxRN6?mY)2?+wowC+jO2R*Y)x z6M}=o=I|aFtlHtkdY}r&m$Hna8m!)wI#(6^b8Lci7ru_BkWcIqocx`R4+~BCe7N?; z5sC%UQh%U8aW;xE>BXCzmgc)UUAn_$b|uys-?GPGzRUDL2pQ`Gxq8~M9m01GHI&O-FNZeG2k(Atkzl`Zl7E?*lZ(8 zslK42HFDs#3_`25Ri!L2|0_p|UgNB=OS&(O(;rQM&uAvjeiWCOe|b0INsJu|7Si5e zmX!zf1-^`-pLdNO>L9E&DY?6YAXL2W7zEcb{{ak)YmTnHseo#QXx#ozaB+|M0Jh|f_)mTXOCS~%cmFZJU=@lmcKpXzYE0En!Wzuu3#h6L$ z@VZsw z-pF)%N~#3581B2c_RaG;Qx&;6lYT?=-mkJUFq_V%s=Li3F<;~s=~PJiCqe{_H@o+r zDA`y*)?-qbSVVV-1lW*0HbHPJd;ds-fBmb%JvkOh@U`pti+q!_EMNCT7oCAirFcdv z+ltDJyceb%{#$es2KTKbZ^|<^`sIrZQ-~nnH6imoiE##nRK-BUv^VzeIH(u3j0=2L zi`xQw4x$DBuDZv+$1CrIOt)R`L;jtpB2@Lo70vL}xH%A~mOBeIQ6#AjX7wqbvDOfk zMf~$zziK*nW_(m_s!uXL^1cK%y7WKl9D~SRa|PAy9)#^mg5=VnHt#|Xkp*qWxea2B zP>J3%T$1W+{%|Ark<#!uf;xK(?Q!aW5tYP|&V+mcHyesQWic&W>Fwz)lVNkb3@>*- z<_ptzp0ki;Ok6=s8mX!EjH$h0t7pyGn~*@qE18bya-Xwp{Tw3^J99Kliww42g0|pG z|6lobK-H+5U-oHsxK|Ig5BuDkgvA8a!Au6A5%*VJAfrY96Hv<+ZlWisjyru z-d(s+I2x|U^;$B=Km_HY17p4<-O1y(l&TO9j~&*kEW|2{1) z+PWUA!EqL2bEtp(an13-!;I``xJp3(;ev)&a9hh*g8IyiFp9&W8izSbO@=1TIZHVy z{6-3e1shG=Id9r8Nrb(-o2tgPcOCz8YDq`bO5vBjkG3*6O>$Gx#|KD29GwbHa^8!(K0*q{aWpo zE^9d42+)#ln-GRxwWZO3WYu<^eKot@GTLj^_3yH?;*fVkqOIi$6V2Wm`DVGQAIYX8 zrgbfP6pRgpj-Jla92!YemZ>-H+p|Zh>o`-Ll{T2&Jt@DFrh+;teNeqGqMOEBPgNBc zn=YlW?Nq59K{VVXg%-!!jf^+IP$hBS>Q`e+_SpCoFYQ2E{g7s}1a!cW<%H;~IUYT4 zo^giK9>He#Lnmt{8qpOyX?vOfb7Xag41Hi5waaZ<%!9hd`GR$cgYTS(6eON2loZqc zc3lA)hmvTtlI``9ymuStP897LJL!kldV4Wg*RjV_T%)^hPuu9)IpjIM8a~$yv9o)1 zc|m(gQE5PZu>>`F63d$OxTHBYqe=#a|n?4ZHEXkS=bke`0GuaO}0(GSSn-4>8 z+1E%Av1*&jyP9=9U;uW!%zTDIPz!Ik@!+*k+}}qb?rxBBI_{W?RY`d5SiW9*q0Zv) zHv-Vb+1?PMSG6cK$ZNJ28xLP($Lya1&k~mM$86_Yy1o`+hyE&Ix^?sP zv`jkiX!Op~|9FIs5PyRQ0izM3^H!{IRW zs1^N+{6{9GSfPCU@HRx=I4ixkUDVeU4p)GX1C7twDYnhC{h-UQ4P`0n4aNAAi1xcr zQ7dxYEnk0*u50`o0Bd_YsH3+xc8Z<`pe@thXUJmjGe59ro*HmXd744;rt^gOzMf%# z7(f^|+~ZHO|LzKkj*^RXR|d8)QPk}U=yCs8%EWk6$@T{LUr0GmN^iB8{1_1bXK0+m)o=og}w!#kyShOOXK%7pa>+kfoeN zZA*BP?K-@2hWqlQ@UJm(o1zHjILcU1)R^j-@+KNgu0oT*T@Nmca{07h*3AdD;R77p zdR8wgG=nZ7Z)>v@=FAqcx&YA#<8rx=8R+)Ke{Ix>a27al@kGiyZgJhSooKUKe&_m3 zmvMF*)xnOleCJ~d)ai`O<)7@g#J>5gEoo(_*A#kpLD(syb}t^PQvP>voHNZ&C(mU^ zydA6wS4JwmvpM?0&Sd@FL_;RO?R>m7bwr^tA0iSM%mGnNHThuKUy!{Kmm{j`7*0?q@ys&#E0IeMDTC*a8_%9< z(1QF}jm^Nc$W!BN^FgY5Y#XQ1Ba%&oOIFg9(NpF zmiPCK&lYYK0#q`6$@E1X-yB9t$;F9_K0}#sbI*Lufs$?ijy=`qM{+YkHb}C|qhd`h z(j{|#@v^|ses7P|__Cf=O8V=D&iPETTdk2{4Jy3f%Z?HNP>lQ9)|$#wUkMrCSU4jP+hj{7aZ2tMG`W@K zdcB-zP{^K#Z*USDv$Xr#Z&Z;6fBo@pgFF%x!Dhw%fxG5RMeb0v9t8W)s%;id0i8V4 z@+Iqhn2>Dk)X7SXrX{TLH0ch>tMSKA$^yjowX~bUxGGF(zQH?BQDl`ncz4J`_#~-# z>Z1UpZe+Lkot7~%{klEUy1yB9Vf!_-f9Mk|CM_zgp`rsBU6Yt|Lnc}jsiY32z@Pz*=$uInd5dpk2G+FLuO7F&uTO3jss4BASKHYlQT2Mbjo+8;%> zbJ>@2z*~*s22d-rnzMCy=wrM#u!}@BV?xe=nroh6?vkk(6N4wastkby;?Ocr%_Blc zO|Xg+ttRyBMlIC{G6$krlF-sZFt{sLxKDGde1s+4rj)8ZtAKPUjc+*4arpecX807? zLoLP*s{R^09zejhHBV3YEdle{9j@ktv6N3bI;jWegke7$dtX~ZjjW@^9}6u`x8?yNer|05U6N0Uj7_`>Hketa1IWV&;m7=a@JVVkY8l6apC>Z{D`UL6AY zKhJrd06o+PcU6RLyV%5x%Kk*@|YW-K>y`|&pJ;h@LXy07jS z!e6G-J@fa98|-P>IIe3GsGm%{$TvW(QD(i@7{FIyDvE>RkbN}~EW}h2Y((wO4Er

I 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

j8 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

Dr;}nZFLv+)adi+@oLUZ@^-e= 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 z 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 z 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 z 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�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 Date: Sat, 12 Oct 2024 16:43:54 -0600 Subject: [PATCH 3/3] update dependencies --- crates/lyrebird/Cargo.toml | 2 +- crates/o5/Cargo.toml | 8 ++++---- crates/obfs4/Cargo.toml | 10 +++++----- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/crates/lyrebird/Cargo.toml b/crates/lyrebird/Cargo.toml index eec093b..8c48fec 100644 --- a/crates/lyrebird/Cargo.toml +++ b/crates/lyrebird/Cargo.toml @@ -38,7 +38,7 @@ anyhow = "1.0" clap = { version = "4.4", features = ["derive"]} fast-socks5 = "0.9.1" futures = "0.3.29" -safelog = "0.3.5" +safelog = "0.4.0" thiserror = "1.0.56" tokio = { version = "1.34", features = ["io-util", "net", "macros", "sync", "signal"] } tokio-util = "0.7.10" diff --git a/crates/o5/Cargo.toml b/crates/o5/Cargo.toml index 6fa7f38..60a8622 100644 --- a/crates/o5/Cargo.toml +++ b/crates/o5/Cargo.toml @@ -52,10 +52,10 @@ tokio-util = { version = "0.7.10", features = ["codec", "io"]} bytes = "1.5.0" ## ntor_arti -tor-cell = "0.22.0" -tor-llcrypto = "0.22.0" -tor-error = "0.22.0" -tor-bytes = "0.22.0" +tor-cell = "0.23.0" +tor-llcrypto = "0.23.0" +tor-error = "0.23.0" +tor-bytes = "0.23.0" cipher = "0.4.4" zeroize = "1.7.0" thiserror = "1.0.56" diff --git a/crates/obfs4/Cargo.toml b/crates/obfs4/Cargo.toml index ef59b93..f599277 100644 --- a/crates/obfs4/Cargo.toml +++ b/crates/obfs4/Cargo.toml @@ -54,10 +54,10 @@ tokio-util = { version = "0.7.10", features = ["codec", "io"]} bytes = "1.5.0" ## ntor_arti -tor-cell = "0.22.0" -tor-llcrypto = "0.22.0" -tor-error = "0.22.0" -tor-bytes = "0.22.0" +tor-cell = "0.23.0" +tor-llcrypto = "0.23.0" +tor-error = "0.23.0" +tor-bytes = "0.23.0" cipher = "0.4.4" zeroize = "1.7.0" thiserror = "1.0.56" @@ -81,7 +81,7 @@ filetime = {version="0.2.25", optional=true} [dev-dependencies] tracing-subscriber = "0.3.18" hex-literal = "0.4.1" -tor-basic-utils = "0.22.0" +tor-basic-utils = "0.23.0" # benches # criterion = "0.5"

vtytY^}FF#dRf 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�nzdjoHwy>ajqlGL!iA~rXS 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