1use std::borrow::Borrow;
4use std::marker::PhantomData;
5
6use super::{AuxDataReply, KeyGenerator, RelayHandshakeError, RelayHandshakeResult};
7use crate::util::ct;
8use crate::{Error, Result};
9use subtle::{Choice, ConstantTimeEq};
10use tor_bytes::{EncodeResult, Reader, SecretBuf, Writer};
11use tor_error::into_internal;
12use tor_llcrypto::d;
13use tor_llcrypto::pk::curve25519::*;
14use tor_llcrypto::pk::rsa::RsaIdentity;
15use tor_llcrypto::util::ct::ct_lookup;
16
17use digest::{KeyInit, Mac};
18use rand_core::{CryptoRng, Rng};
19
20pub(crate) struct NtorClient;
22
23impl super::ClientHandshake for NtorClient {
24 type KeyType = NtorPublicKey;
25 type StateType = NtorHandshakeState;
26 type KeyGen = NtorHkdfKeyGenerator;
27 type ClientAuxData = ();
28 type ServerAuxData = ();
29
30 fn client1<R: Rng + CryptoRng, M: Borrow<()>>(
31 rng: &mut R,
32 key: &Self::KeyType,
33 _client_aux_data: &M,
34 ) -> Result<(Self::StateType, Vec<u8>)> {
35 client_handshake_ntor_v1(rng, key)
36 }
37
38 fn client2<T: AsRef<[u8]>>(state: Self::StateType, msg: T) -> Result<((), Self::KeyGen)> {
39 let keygen = client_handshake2_ntor_v1(msg, &state)?;
40 Ok(((), keygen))
41 }
42}
43
44pub(crate) struct NtorServer<K: NtorServerKeys> {
46 _phantom: PhantomData<K>,
49}
50
51impl<K: NtorServerKeys> super::ServerHandshake for NtorServer<K> {
52 type KeyType = K;
53 type KeyGen = NtorHkdfKeyGenerator;
54 type ClientAuxData = ();
55 type ServerAuxData = ();
56
57 fn server<R: Rng + CryptoRng, REPLY: AuxDataReply<Self>, T: AsRef<[u8]>>(
58 rng: &mut R,
59 reply_fn: &mut REPLY,
60 keys: &[Self::KeyType],
61 msg: T,
62 ) -> RelayHandshakeResult<(Self::KeyGen, Vec<u8>)> {
63 let _reply_msg = reply_fn
64 .reply(&())
65 .ok_or(RelayHandshakeError::BadClientHandshake)?;
66
67 server_handshake_ntor_v1(rng, msg, keys)
68 }
69}
70
71pub(crate) trait NtorServerKeys {
73 fn ident(&self) -> &RsaIdentity;
75
76 fn public_key(&self) -> &PublicKey;
78
79 fn secret_key(&self) -> &StaticSecret;
81
82 fn matches_pk(&self, pk: &PublicKey) -> Choice {
88 self.public_key().as_bytes().ct_eq(pk.as_bytes())
89 }
90}
91
92#[derive(Clone, Debug)]
94pub(crate) struct NtorPublicKey {
95 pub(crate) id: RsaIdentity,
98 pub(crate) pk: PublicKey,
100}
101
102pub(crate) struct NtorHandshakeState {
104 relay_public: NtorPublicKey,
107 my_sk: StaticSecret,
112 my_public: PublicKey,
114}
115
116pub(crate) struct NtorHkdfKeyGenerator {
118 seed: SecretBuf,
121}
122
123impl NtorHkdfKeyGenerator {
124 pub(crate) fn new(seed: SecretBuf) -> Self {
126 NtorHkdfKeyGenerator { seed }
127 }
128}
129
130impl KeyGenerator for NtorHkdfKeyGenerator {
131 fn expand(self, keylen: usize) -> Result<SecretBuf> {
132 let ntor1_key = &b"ntor-curve25519-sha256-1:key_extract"[..];
133 let ntor1_expand = &b"ntor-curve25519-sha256-1:key_expand"[..];
134 use crate::crypto::ll::kdf::{Kdf, Ntor1Kdf};
135 Ntor1Kdf::new(ntor1_key, ntor1_expand).derive(&self.seed[..], keylen)
136 }
137}
138
139type Authcode = digest::CtOutput<hmac::Hmac<d::Sha256>>;
141
142fn client_handshake_ntor_v1<R>(
144 rng: &mut R,
145 relay_public: &NtorPublicKey,
146) -> Result<(NtorHandshakeState, Vec<u8>)>
147where
148 R: Rng + CryptoRng,
149{
150 let my_sk = StaticSecret::random_from_rng(rng);
151 let my_public = PublicKey::from(&my_sk);
152
153 client_handshake_ntor_v1_no_keygen(my_public, my_sk, relay_public)
154}
155
156fn client_handshake_ntor_v1_no_keygen(
158 my_public: PublicKey,
159 my_sk: StaticSecret,
160 relay_public: &NtorPublicKey,
161) -> Result<(NtorHandshakeState, Vec<u8>)> {
162 let mut v: Vec<u8> = Vec::new();
163
164 v.write(&relay_public.id)
165 .and_then(|_| v.write(&relay_public.pk))
166 .and_then(|_| v.write(&my_public))
167 .map_err(|e| Error::from_bytes_enc(e, "Can't encode client handshake."))?;
168
169 assert_eq!(v.len(), 20 + 32 + 32);
170
171 let state = NtorHandshakeState {
172 relay_public: relay_public.clone(),
173 my_public,
174 my_sk,
175 };
176
177 Ok((state, v))
178}
179
180fn client_handshake2_ntor_v1<T>(msg: T, state: &NtorHandshakeState) -> Result<NtorHkdfKeyGenerator>
182where
183 T: AsRef<[u8]>,
184{
185 let mut cur = Reader::from_slice(msg.as_ref());
186 let their_pk: PublicKey = cur
187 .extract()
188 .map_err(|e| Error::from_bytes_err(e, "v3 ntor handshake"))?;
189 let auth: Authcode = cur
190 .extract()
191 .map_err(|e| Error::from_bytes_err(e, "v3 ntor handshake"))?;
192
193 let xy = state.my_sk.diffie_hellman(&their_pk);
194 let xb = state.my_sk.diffie_hellman(&state.relay_public.pk);
195
196 let (keygen, authcode) =
197 ntor_derive(&xy, &xb, &state.relay_public, &state.my_public, &their_pk)
198 .map_err(into_internal!("Error deriving keys"))?;
199
200 let okay = ct::bool_to_choice(authcode == auth)
201 & ct::bool_to_choice(xy.was_contributory())
202 & ct::bool_to_choice(xb.was_contributory());
203
204 if okay.into() {
205 Ok(keygen)
206 } else {
207 Err(Error::BadCircHandshakeAuth)
208 }
209}
210
211fn ntor_derive(
216 xy: &SharedSecret,
217 xb: &SharedSecret,
218 server_pk: &NtorPublicKey,
219 x: &PublicKey,
220 y: &PublicKey,
221) -> EncodeResult<(NtorHkdfKeyGenerator, Authcode)> {
222 let ntor1_protoid = &b"ntor-curve25519-sha256-1"[..];
223 let ntor1_mac = &b"ntor-curve25519-sha256-1:mac"[..];
224 let ntor1_verify = &b"ntor-curve25519-sha256-1:verify"[..];
225 let server_string = &b"Server"[..];
226
227 let mut secret_input = SecretBuf::new();
228 secret_input.write(xy)?; secret_input.write(xb)?; secret_input.write(&server_pk.id)?; secret_input.write(&server_pk.pk)?; secret_input.write(x)?; secret_input.write(y)?; secret_input.write(ntor1_protoid)?; use hmac::Hmac;
237 use tor_llcrypto::d::Sha256;
238 let verify = {
239 let mut m =
240 Hmac::<Sha256>::new_from_slice(ntor1_verify).expect("Hmac allows keys of any size");
241 m.update(&secret_input[..]);
242 m.finalize()
243 };
244 let mut auth_input = Vec::new();
245 auth_input.write_and_consume(verify)?; auth_input.write(&server_pk.id)?; auth_input.write(&server_pk.pk)?; auth_input.write(y)?; auth_input.write(x)?; auth_input.write(ntor1_protoid)?; auth_input.write(server_string)?; let auth_mac = {
254 let mut m =
255 Hmac::<Sha256>::new_from_slice(ntor1_mac).expect("Hmac allows keys of any size");
256 m.update(&auth_input[..]);
257 m.finalize()
258 };
259
260 let keygen = NtorHkdfKeyGenerator::new(secret_input);
261 Ok((keygen, auth_mac))
262}
263
264fn server_handshake_ntor_v1<R, T, K: NtorServerKeys>(
268 rng: &mut R,
269 msg: T,
270 keys: &[K],
271) -> RelayHandshakeResult<(NtorHkdfKeyGenerator, Vec<u8>)>
272where
273 R: Rng + CryptoRng,
274 T: AsRef<[u8]>,
275{
276 let ephem = EphemeralSecret::random_from_rng(rng);
281 let ephem_pub = PublicKey::from(&ephem);
282
283 server_handshake_ntor_v1_no_keygen(ephem_pub, ephem, msg, keys)
284}
285
286fn server_handshake_ntor_v1_no_keygen<T, K: NtorServerKeys>(
288 ephem_pub: PublicKey,
289 ephem: EphemeralSecret,
290 msg: T,
291 keys: &[K],
292) -> RelayHandshakeResult<(NtorHkdfKeyGenerator, Vec<u8>)>
293where
294 T: AsRef<[u8]>,
295{
296 let mut cur = Reader::from_slice(msg.as_ref());
297
298 let my_id: RsaIdentity = cur.extract()?;
299 let my_key: PublicKey = cur.extract()?;
300 let their_pk: PublicKey = cur.extract()?;
301
302 let keypair = ct_lookup(keys, |key| key.matches_pk(&my_key));
303 let keypair = match keypair {
304 Some(k) => k,
305 None => return Err(RelayHandshakeError::MissingKey),
306 };
307
308 if &my_id != keypair.ident() {
309 return Err(RelayHandshakeError::MissingKey);
310 }
311
312 let xy = ephem.diffie_hellman(&their_pk);
313 let xb = keypair.secret_key().diffie_hellman(&their_pk);
314
315 let okay =
316 ct::bool_to_choice(xy.was_contributory()) & ct::bool_to_choice(xb.was_contributory());
317
318 let relay_pk = NtorPublicKey {
320 id: *keypair.ident(),
321 pk: *keypair.public_key(),
322 };
323 let (keygen, authcode) = ntor_derive(&xy, &xb, &relay_pk, &their_pk, &ephem_pub)
324 .map_err(into_internal!("Error deriving keys"))?;
325
326 let mut reply: Vec<u8> = Vec::new();
327 reply
328 .write(&ephem_pub)
329 .and_then(|_| reply.write_and_consume(authcode))
330 .map_err(into_internal!(
331 "Generated relay handshake we couldn't encode"
332 ))?;
333
334 if okay.into() {
335 Ok((keygen, reply))
336 } else {
337 Err(RelayHandshakeError::BadClientHandshake)
338 }
339}
340
341#[cfg(test)]
342pub(crate) mod tests {
343 #![allow(clippy::unwrap_used)]
344 use super::*;
345 use crate::crypto::testing::FakePRNG;
346 use tor_basic_utils::test_rng::testing_rng;
347
348 pub(crate) struct NtorSecretKey {
350 pk: NtorPublicKey,
352 sk: StaticSecret,
355 }
356
357 impl NtorSecretKey {
358 pub(crate) fn new(sk: StaticSecret, pk: PublicKey, id: RsaIdentity) -> Self {
360 NtorSecretKey {
361 pk: NtorPublicKey { id, pk },
362 sk,
363 }
364 }
365 }
366
367 impl NtorServerKeys for NtorSecretKey {
368 fn ident(&self) -> &RsaIdentity {
369 &self.pk.id
370 }
371
372 fn public_key(&self) -> &PublicKey {
373 &self.pk.pk
374 }
375
376 fn secret_key(&self) -> &StaticSecret {
377 &self.sk
378 }
379 }
380
381 #[test]
382 fn simple() -> Result<()> {
383 use crate::crypto::handshake::{ClientHandshake, ServerHandshake};
384 let mut rng = testing_rng();
385 let relay_secret = StaticSecret::random_from_rng(&mut rng);
386 let relay_public = PublicKey::from(&relay_secret);
387 let relay_identity = RsaIdentity::from_bytes(&[12; 20]).unwrap();
388 let relay_ntpk = NtorPublicKey {
389 id: relay_identity,
390 pk: relay_public,
391 };
392 let (state, cmsg) = NtorClient::client1(&mut rng, &relay_ntpk, &())?;
393
394 let relay_ntsk = NtorSecretKey {
395 pk: relay_ntpk,
396 sk: relay_secret,
397 };
398 let relay_ntsks = [relay_ntsk];
399
400 let (skeygen, smsg) =
401 NtorServer::server(&mut rng, &mut |_: &()| Some(()), &relay_ntsks, &cmsg).unwrap();
402
403 let (_extensions, ckeygen) = NtorClient::client2(state, smsg)?;
404
405 let skeys = skeygen.expand(55)?;
406 let ckeys = ckeygen.expand(55)?;
407
408 assert_eq!(skeys, ckeys);
409
410 Ok(())
411 }
412
413 fn make_fake_ephem_key(bytes: &[u8]) -> EphemeralSecret {
414 assert_eq!(bytes.len(), 32);
415 let mut rng = FakePRNG::new(bytes);
416 EphemeralSecret::random_from_rng(&mut rng)
417 }
418
419 #[test]
420 fn testvec() -> Result<()> {
421 use hex_literal::hex;
422
423 let b_sk = hex!("4820544f4c4420594f5520444f474954204b454550532048415050454e494e47");
424 let b_pk = hex!("ccbc8541904d18af08753eae967874749e6149f873de937f57f8fd903a21c471");
425 let x_sk = hex!("706f6461792069207075742e2e2e2e2e2e2e2e4a454c4c59206f6e2074686973");
426 let x_pk = hex!("e65dfdbef8b2635837fe2cebc086a8096eae3213e6830dc407516083d412b078");
427 let y_sk = hex!("70686520737175697272656c2e2e2e2e2e2e2e2e686173206869732067616d65");
428 let y_pk = hex!("390480a14362761d6aec1fea840f6e9e928fb2adb7b25c670be1045e35133a37");
429 let id = hex!("69546f6c64596f7541626f75745374616972732e");
430 let client_handshake = hex!(
431 "69546f6c64596f7541626f75745374616972732eccbc8541904d18af08753eae967874749e6149f873de937f57f8fd903a21c471e65dfdbef8b2635837fe2cebc086a8096eae3213e6830dc407516083d412b078"
432 );
433 let server_handshake = hex!(
434 "390480a14362761d6aec1fea840f6e9e928fb2adb7b25c670be1045e35133a371cbdf68b89923e1f85e8e18ee6e805ea333fe4849c790ffd2670bd80fec95cc8"
435 );
436 let keys = hex!(
437 "0c62dee7f48893370d0ef896758d35729867beef1a5121df80e00f79ed349af39b51cae125719182f19d932a667dae1afbf2e336e6910e7822223e763afad0a13342157969dc6b79"
438 );
439
440 let relay_pk = NtorPublicKey {
441 id: RsaIdentity::from_bytes(&id).unwrap(),
442 pk: b_pk.into(),
443 };
444 let relay_sk = NtorSecretKey {
445 pk: relay_pk.clone(),
446 sk: b_sk.into(),
447 };
448
449 let (state, create_msg) =
450 client_handshake_ntor_v1_no_keygen(x_pk.into(), x_sk.into(), &relay_pk).unwrap();
451 assert_eq!(&create_msg[..], &client_handshake[..]);
452
453 let ephem = make_fake_ephem_key(&y_sk[..]);
454 let ephem_pub = y_pk.into();
455 let (s_keygen, created_msg) =
456 server_handshake_ntor_v1_no_keygen(ephem_pub, ephem, &create_msg[..], &[relay_sk])
457 .unwrap();
458 assert_eq!(&created_msg[..], &server_handshake[..]);
459
460 let c_keygen = client_handshake2_ntor_v1(created_msg, &state)?;
461
462 let c_keys = c_keygen.expand(keys.len())?;
463 let s_keys = s_keygen.expand(keys.len())?;
464 assert_eq!(&c_keys[..], &keys[..]);
465 assert_eq!(&s_keys[..], &keys[..]);
466
467 Ok(())
468 }
469
470 #[test]
471 fn failing_handshakes() {
472 use crate::crypto::handshake::{ClientHandshake, ServerHandshake};
473 let mut rng = testing_rng();
474
475 let relay_secret = StaticSecret::random_from_rng(&mut rng);
477 let relay_public = PublicKey::from(&relay_secret);
478 let wrong_public = PublicKey::from([16_u8; 32]);
479 let relay_identity = RsaIdentity::from_bytes(&[12; 20]).unwrap();
480 let wrong_identity = RsaIdentity::from_bytes(&[13; 20]).unwrap();
481 let relay_ntpk = NtorPublicKey {
482 id: relay_identity,
483 pk: relay_public,
484 };
485 let relay_ntsk = NtorSecretKey {
486 pk: relay_ntpk.clone(),
487 sk: relay_secret,
488 };
489 let relay_ntsks = &[relay_ntsk];
490 let wrong_ntpk1 = NtorPublicKey {
491 id: wrong_identity,
492 pk: relay_public,
493 };
494 let wrong_ntpk2 = NtorPublicKey {
495 id: relay_identity,
496 pk: wrong_public,
497 };
498
499 let (_, handshake1) = NtorClient::client1(&mut rng, &wrong_ntpk1, &()).unwrap();
502 let (_, handshake2) = NtorClient::client1(&mut rng, &wrong_ntpk2, &()).unwrap();
503 let (st3, handshake3) = NtorClient::client1(&mut rng, &relay_ntpk, &()).unwrap();
504
505 let ans1 = NtorServer::server(&mut rng, &mut |_: &()| Some(()), relay_ntsks, &handshake1);
506 let ans2 = NtorServer::server(&mut rng, &mut |_: &()| Some(()), relay_ntsks, &handshake2);
507
508 assert!(ans1.is_err());
509 assert!(ans2.is_err());
510
511 let (_, mut smsg) =
514 NtorServer::server(&mut rng, &mut |_: &()| Some(()), relay_ntsks, &handshake3).unwrap();
515 smsg[60] ^= 7;
516 let ans3 = NtorClient::client2(st3, smsg);
517 assert!(ans3.is_err());
518 }
519}