1use crate::FlowCtrlParameters;
4use crate::ccparams::{
5 AlgorithmDiscriminants, CongestionWindowParams, FixedWindowParams, RoundTripEstimatorParams,
6 VegasParams,
7};
8use crate::channel::Channel;
9use crate::circuit::celltypes::{CreateRequest, CreateResponse};
10use crate::circuit::circhop::{HandshakeParamsError, HopSettings};
11use crate::circuit::{
12 CircuitRxSender, HandshakeSubprotocols, InvalidHandshakeSubprotocolError, UniqId,
13};
14use crate::client::circuit::padding::PaddingController;
15use crate::crypto::binding::CircuitBinding;
16use crate::crypto::cell::CryptInit as _;
17use crate::crypto::cell::{
18 CgoRelayCrypto, InboundRelayLayer, OutboundRelayLayer, RelayLayer, Tor1RelayCrypto,
19};
20use crate::crypto::handshake::RelayHandshakeError;
21use crate::crypto::handshake::ServerHandshake as _;
22use crate::crypto::handshake::fast::CreateFastServer;
23use crate::crypto::handshake::ntor::{NtorServer, NtorServerKeys};
24use crate::crypto::handshake::ntor_v3::{NtorV3Server, NtorV3ServerKeys};
25use crate::memquota::SpecificAccount as _;
26use crate::memquota::{ChannelAccount, CircuitAccount};
27use crate::relay::channel_provider::ChannelProvider;
28use crate::relay::reactor::Reactor;
29use crate::relay::{IncomingStreamRequestFilter, RelayCirc};
30use crate::stream::IncomingStream;
31use futures::channel::mpsc;
32use futures::{SinkExt, Stream};
33use smallvec::SmallVec;
34use std::sync::{Arc, RwLock, Weak};
35use tor_cell::chancell::ChanMsg as _;
36use tor_cell::chancell::CircId;
37use tor_cell::chancell::msg::{
38 CreateFast, Created2, CreatedFast, Destroy, DestroyReason, HandshakeType,
39};
40use tor_cell::relaycell::RelayCmd;
41use tor_cell::relaycell::extend::{
42 CcRequest, CcResponse, CircRequestExt, CircResponseExt, SubprotocolRequest,
43};
44use tor_error::{ErrorKind, HasKind, debug_report, internal, into_internal, warn_report};
45use tor_linkspec::OwnedChanTarget;
46use tor_llcrypto::pk::curve25519;
47use tor_llcrypto::pk::ed25519::Ed25519Identity;
48use tor_llcrypto::pk::rsa::RsaIdentity;
49use tor_memquota::mq_queue::ChannelSpec as _;
50use tor_memquota::mq_queue::MpscSpec;
51use tor_relay_crypto::pk::{RelayNtorKeypair, RelayNtorKeys};
52use tor_rtcompat::SpawnExt as _;
53use tor_rtcompat::{DynTimeProvider, Runtime};
54use tracing::{debug, trace};
55
56#[derive(derive_more::Debug)]
58pub struct CreateRequestHandler {
59 chan_provider: Weak<dyn ChannelProvider<BuildSpec = OwnedChanTarget> + Send + Sync>,
61 circ_net_params: RwLock<CircNetParameters>,
63 #[debug(skip)]
65 ntor_keys: RwLock<RelayNtorKeys>,
66 #[debug(skip)]
76 incoming_filter_factory: Box<dyn IncomingStreamRequestFilterFactory + Send + Sync>,
77 allowed_stream_cmds: SmallVec<[RelayCmd; 3]>,
85 #[debug(skip)]
98 circuit_stream_tx: mpsc::Sender<Box<dyn Stream<Item = IncomingStream> + Send + Sync + Unpin>>,
99}
100
101#[expect(clippy::unused_async)]
104impl CreateRequestHandler {
105 pub fn new(
108 chan_provider: Weak<dyn ChannelProvider<BuildSpec = OwnedChanTarget> + Send + Sync>,
109 circ_net_params: CircNetParameters,
110 ntor_keys: RelayNtorKeys,
111 incoming_filter_factory: Box<dyn IncomingStreamRequestFilterFactory + Send + Sync>,
112 allowed_stream_cmds: &[RelayCmd],
113 ) -> (Self, CircuitIncomingStreamReceiver) {
114 const CIRC_STREAM_BUF_SIZE: usize = 1024;
120
121 #[allow(clippy::disallowed_methods)]
125 let (stream_tx, stream_rx) = mpsc::channel(CIRC_STREAM_BUF_SIZE);
126
127 let handler = Self {
128 chan_provider,
129 circ_net_params: RwLock::new(circ_net_params),
130 ntor_keys: RwLock::new(ntor_keys),
131 incoming_filter_factory,
132 allowed_stream_cmds: allowed_stream_cmds.into(),
133 circuit_stream_tx: stream_tx,
134 };
135
136 let circuit_stream_rx = CircuitIncomingStreamReceiver {
137 circuit_stream_rx: stream_rx,
138 };
139
140 (handler, circuit_stream_rx)
141 }
142
143 pub fn update_params(&self, circ_net_params: CircNetParameters) {
145 *self.circ_net_params.write().expect("rwlock poisoned") = circ_net_params;
146 }
147
148 pub fn update_ntor_keys(&self, ntor_keys: RelayNtorKeys) {
152 *self.ntor_keys.write().expect("rwlock poisoned") = ntor_keys;
153 }
154
155 #[allow(clippy::too_many_arguments)]
163 pub(crate) async fn handle_create<R: Runtime>(
164 &self,
165 runtime: &R,
166 channel: &Arc<Channel>,
167 our_ed25519_id: &Ed25519Identity,
168 our_rsa_id: &RsaIdentity,
169 circ_id: CircId,
170 msg: &CreateRequest,
171 memquota: &ChannelAccount,
172 circ_unique_id: UniqId,
173 ) -> Result<(CreateResponse, RelayCircComponents), Destroy> {
174 let result = self
175 .handle_create_inner(
176 runtime,
177 channel,
178 our_ed25519_id,
179 our_rsa_id,
180 circ_id,
181 msg,
182 memquota,
183 circ_unique_id,
184 )
185 .await;
186
187 match result {
188 Ok(x) => Ok(x),
189 Err(e) => {
190 let cmd = msg.cmd();
192 debug_report!(&e, %cmd, "Failed to handle circuit create request");
193
194 Err(Destroy::new(DestroyReason::NONE))
198 }
199 }
200 }
201
202 #[allow(clippy::too_many_arguments)]
204 async fn handle_create_inner<R: Runtime>(
205 &self,
206 runtime: &R,
207 channel: &Arc<Channel>,
208 our_ed25519_id: &Ed25519Identity,
209 our_rsa_id: &RsaIdentity,
210 circ_id: CircId,
211 msg: &CreateRequest,
212 memquota: &ChannelAccount,
213 circ_unique_id: UniqId,
214 ) -> Result<(CreateResponse, RelayCircComponents), HandleCreateError> {
215 let handshake_components = match msg {
217 CreateRequest::CreateFast(msg) => self.handle_create_fast(msg).await?,
218 CreateRequest::Create2(msg) => match msg.handshake_type() {
219 HandshakeType::NTOR_V3 => {
220 self.handle_create2_ntorv3(msg.body(), our_ed25519_id)
221 .await?
222 }
223 HandshakeType::NTOR => self.handle_create2_ntor(msg.body(), our_rsa_id).await?,
224 x @ HandshakeType::TAP | x => {
225 return Err(HandleCreateError::Create2HandshakeType(x));
226 }
227 },
228 };
229
230 let memquota = CircuitAccount::new(memquota)?;
231
232 let time_provider = DynTimeProvider::new(runtime.clone());
238 let account = memquota.as_raw_account();
239 let (sender, receiver) =
240 MpscSpec::new(10_000_000).new_mq(time_provider.clone(), account)?;
241 let (sender, receiver) = crate::circuit::circ_sender::channel(sender, receiver);
242
243 let (padding_ctrl, padding_stream) =
245 crate::client::circuit::padding::new_padding(DynTimeProvider::new(runtime.clone()));
246
247 let Some(chan_provider) = self.chan_provider.upgrade() else {
249 return Err(internal!("Unable to upgrade weak `ChannelProvider`").into());
250 };
251
252 let incoming_filter = self.incoming_filter_factory.current_filter();
259
260 let (reactor, circ, incoming_streams) = Reactor::new(
262 runtime.clone(),
263 channel,
264 circ_id,
265 circ_unique_id,
266 receiver,
267 handshake_components.crypto_in,
268 handshake_components.crypto_out,
269 &handshake_components.hop_settings,
270 chan_provider,
271 padding_ctrl.clone(),
272 padding_stream,
273 incoming_filter,
274 &self.allowed_stream_cmds,
275 &memquota,
276 )
277 .map_err(into_internal!("Failed to start circuit reactor"))?;
278
279 let mut circuit_stream_tx = self.circuit_stream_tx.clone();
280 let () = runtime.spawn(async move {
282 if let Err(e) = circuit_stream_tx.send(Box::new(incoming_streams)).await {
283 warn_report!(e, "IncomingStream handler disappeared?!");
284 drop(reactor);
291 } else {
292 match reactor.run().await {
295 Ok(()) => {}
296 Err(e) => {
297 debug_report!(e, "Relay circuit reactor exited with an error");
298 }
299 }
300 }
301 })?;
302
303 Ok((
304 handshake_components.response,
305 RelayCircComponents {
306 circ,
307 sender,
308 padding_ctrl,
309 },
310 ))
311 }
312
313 async fn handle_create_fast(
315 &self,
316 msg: &CreateFast,
317 ) -> Result<CompletedHandshakeComponents, HandleCreateError> {
318 let (keygen, handshake_msg) = CreateFastServer::server(
320 &mut rand::rng(),
321 &mut |_: &()| Some(()),
324 &[],
326 msg.handshake(),
327 )?;
328
329 let circ_net_params = self
330 .circ_net_params
331 .read()
332 .expect("rwlock poisoned")
333 .clone();
334
335 let subprotos = HandshakeSubprotocols::default();
337
338 let hop_settings = HopSettings::from_handshake_params(
339 circ_net_params,
340 AlgorithmDiscriminants::FixedWindow,
342 subprotos,
343 )?;
344
345 let crypt = Tor1RelayCrypto::construct(keygen)
346 .map_err(into_internal!("Circuit crypt state construction failed"))?;
347
348 let (crypto_out, crypto_in, _binding) = split_relay_layer(crypt);
349
350 let response = CreatedFast::new(handshake_msg);
351 let response = CreateResponse::CreatedFast(response);
352
353 trace!("Completed CREATE_FAST handshake");
354
355 Ok(CompletedHandshakeComponents {
356 response,
357 hop_settings,
358 crypto_out,
359 crypto_in,
360 })
361 }
362
363 async fn handle_create2_ntor(
365 &self,
366 msg_body: &[u8],
367 our_rsa_id: &RsaIdentity,
368 ) -> Result<CompletedHandshakeComponents, HandleCreateError> {
369 let ntor_keys = self.with_ntor_keys(|k| NtorSecretKey::new(our_rsa_id, Arc::clone(k)));
370
371 let (keygen, handshake_msg) = NtorServer::server(
373 &mut rand::rng(),
374 &mut |_: &()| Some(()),
377 ntor_keys.as_ref(),
378 msg_body,
379 )?;
380
381 let circ_net_params = self
382 .circ_net_params
383 .read()
384 .expect("rwlock poisoned")
385 .clone();
386
387 let subprotos = HandshakeSubprotocols::default();
389
390 let hop_settings = HopSettings::from_handshake_params(
391 circ_net_params,
392 AlgorithmDiscriminants::FixedWindow,
394 subprotos,
395 )?;
396
397 let crypt = Tor1RelayCrypto::construct(keygen)
398 .map_err(into_internal!("Circuit crypt state construction failed"))?;
399
400 let (crypto_out, crypto_in, _binding) = split_relay_layer(crypt);
401
402 let response = Created2::new(handshake_msg);
403 let response = CreateResponse::Created2(response);
404
405 trace!("Completed ntor handshake");
406
407 Ok(CompletedHandshakeComponents {
408 response,
409 hop_settings,
410 crypto_out,
411 crypto_in,
412 })
413 }
414
415 async fn handle_create2_ntorv3(
417 &self,
418 msg_body: &[u8],
419 our_ed25519_id: &Ed25519Identity,
420 ) -> Result<CompletedHandshakeComponents, HandleCreateError> {
421 let ntor_keys =
422 self.with_ntor_keys(|k| NtorV3SecretKey::new(our_ed25519_id, Arc::clone(k)));
423
424 let circ_net_params = self
425 .circ_net_params
426 .read()
427 .expect("rwlock poisoned")
428 .clone();
429
430 let mut cc_algorithm = AlgorithmDiscriminants::FixedWindow;
432
433 let mut subprotos = SubprotocolRequest::default();
436
437 let mut ext_reply_fn = |client_exts: &[CircRequestExt]| {
440 let mut response_exts = Vec::new();
441
442 let mut handled_cc_request = false;
453 let mut handled_subproto_request = false;
454
455 for ext in client_exts {
456 match ext {
457 CircRequestExt::CcRequest(CcRequest { .. }) => {
458 if handled_cc_request {
459 continue;
460 }
461 handled_cc_request = true;
462
463 cc_algorithm = AlgorithmDiscriminants::Vegas;
464
465 let sendme_inc: u8 = circ_net_params.cc.cwnd.sendme_inc();
466 let response = CcResponse::new(sendme_inc);
467 response_exts.push(CircResponseExt::CcResponse(response));
468 }
469 CircRequestExt::SubprotocolRequest(subproto_request) => {
474 if handled_subproto_request {
475 continue;
476 }
477 handled_subproto_request = true;
478
479 subprotos = subproto_request.clone();
481 }
482 CircRequestExt::Unrecognized(ext) => {
483 debug!(
487 ?ext,
488 "CREATE2 ntor-v3 handshake requested unrecognized extension",
489 );
490 }
491 ext => {
492 debug!(
501 ?ext,
502 "CREATE2 ntor-v3 handshake requested unsupported extension",
503 );
504 }
505 }
506 }
507
508 Some(response_exts)
509 };
510
511 let (keygen, handshake_msg) = NtorV3Server::server(
513 &mut rand::rng(),
514 &mut ext_reply_fn,
515 ntor_keys.as_ref(),
516 msg_body,
517 )?;
518
519 let subprotos = HandshakeSubprotocols::try_from_request(subprotos)?;
521
522 let hop_settings =
523 HopSettings::from_handshake_params(circ_net_params, cc_algorithm, subprotos)?;
524
525 let (crypto_out, crypto_in, _binding) = if subprotos.relay_crypt_cgo {
526 let crypt = CgoRelayCrypto::construct(keygen)
527 .map_err(into_internal!("Circuit crypt state construction failed"))?;
528 split_relay_layer(crypt)
529 } else {
530 let crypt = Tor1RelayCrypto::construct(keygen)
531 .map_err(into_internal!("Circuit crypt state construction failed"))?;
532 split_relay_layer(crypt)
533 };
534
535 let response = Created2::new(handshake_msg);
536 let response = CreateResponse::Created2(response);
537
538 trace!(?cc_algorithm, ?subprotos, "Completed ntor-v3 handshake");
539
540 Ok(CompletedHandshakeComponents {
541 response,
542 hop_settings,
543 crypto_out,
544 crypto_in,
545 })
546 }
547
548 fn with_ntor_keys<T>(&self, map: impl FnMut(&Arc<RelayNtorKeypair>) -> T) -> impl AsRef<[T]> {
556 let ntor_keys = self.ntor_keys.read().expect("rwlock poisoned");
557 let ntor_keys = [Some(ntor_keys.latest()), ntor_keys.previous()];
558 ntor_keys
559 .into_iter()
560 .flatten()
561 .map(map)
562 .collect::<SmallVec<[T; 2]>>()
563 }
564}
565
566#[derive(derive_more::Constructor)]
568struct NtorSecretKey<'a> {
569 ident: &'a RsaIdentity,
571 keys: Arc<RelayNtorKeypair>,
573}
574
575impl<'a> NtorServerKeys for NtorSecretKey<'a> {
576 fn ident(&self) -> &RsaIdentity {
577 self.ident
578 }
579
580 fn public_key(&self) -> &curve25519::PublicKey {
581 self.keys.public_raw()
582 }
583
584 fn secret_key(&self) -> &curve25519::StaticSecret {
585 self.keys.secret()
586 }
587}
588
589#[derive(derive_more::Constructor)]
591struct NtorV3SecretKey<'a> {
592 ident: &'a Ed25519Identity,
594 keys: Arc<RelayNtorKeypair>,
596}
597
598impl<'a> NtorV3ServerKeys for NtorV3SecretKey<'a> {
599 fn ident(&self) -> &Ed25519Identity {
600 self.ident
601 }
602
603 fn public_key(&self) -> &curve25519::PublicKey {
604 self.keys.public_raw()
605 }
606
607 fn secret_key(&self) -> &curve25519::StaticSecret {
608 self.keys.secret()
609 }
610}
611
612pub struct CircuitIncomingStreamReceiver {
628 circuit_stream_rx: mpsc::Receiver<<Self as Stream>::Item>,
633}
634
635impl Stream for CircuitIncomingStreamReceiver {
636 type Item = Box<dyn Stream<Item = IncomingStream> + Send + Sync + Unpin>;
640
641 fn poll_next(
642 mut self: std::pin::Pin<&mut Self>,
643 cx: &mut std::task::Context<'_>,
644 ) -> std::task::Poll<Option<Self::Item>> {
645 use futures::StreamExt as _;
646
647 self.circuit_stream_rx.poll_next_unpin(cx)
648 }
649}
650
651fn split_relay_layer<F, B>(
653 crypt: impl RelayLayer<F, B>,
654) -> (
655 Box<dyn OutboundRelayLayer + Send>,
656 Box<dyn InboundRelayLayer + Send>,
657 CircuitBinding,
658)
659where
660 F: OutboundRelayLayer + Send + 'static,
661 B: InboundRelayLayer + Send + 'static,
662{
663 let (crypto_out, crypto_in, binding) = crypt.split_relay_layer();
664 let (crypto_out, crypto_in) = (Box::new(crypto_out), Box::new(crypto_in));
665
666 (crypto_out, crypto_in, binding)
667}
668
669#[derive(Debug, thiserror::Error)]
671enum HandleCreateError {
672 #[error("Circuit relay handshake failed")]
674 Handshake(#[from] RelayHandshakeError),
675 #[error("Failed to process the circuit relay handshake parameters")]
677 HandshakeParameters(#[from] HandshakeParamsError),
678 #[error("Client requested subprotocol(s) which aren't supported")]
680 HandshakeSubprotocols(#[from] InvalidHandshakeSubprotocolError),
681 #[error("Unsupported handshake type {0}")]
683 Create2HandshakeType(HandshakeType),
684 #[error("Memquota error")]
686 Memquota(#[from] tor_memquota::Error),
687 #[error("Runtime task spawn error")]
689 Spawn(#[from] futures::task::SpawnError),
690 #[error("Internal error")]
695 Internal(#[from] tor_error::Bug),
696}
697
698impl HasKind for HandleCreateError {
699 fn kind(&self) -> ErrorKind {
700 match self {
701 Self::Handshake(e) => e.kind(),
702 Self::HandshakeParameters(e) => e.kind(),
703 Self::HandshakeSubprotocols(e) => e.kind(),
704 Self::Create2HandshakeType(_) => ErrorKind::NotImplemented,
705 Self::Memquota(e) => e.kind(),
706 Self::Spawn(e) => e.kind(),
707 Self::Internal(_) => ErrorKind::Internal,
708 }
709 }
710}
711
712struct CompletedHandshakeComponents {
714 response: CreateResponse,
716 hop_settings: HopSettings,
718 crypto_out: Box<dyn OutboundRelayLayer + Send>,
720 crypto_in: Box<dyn InboundRelayLayer + Send>,
722}
723
724pub(crate) struct RelayCircComponents {
726 pub(crate) circ: Arc<RelayCirc>,
728 pub(crate) sender: CircuitRxSender,
730 pub(crate) padding_ctrl: PaddingController,
732}
733
734#[derive(Debug, Clone)]
736#[allow(clippy::exhaustive_structs)]
737pub struct CongestionControlNetParams {
738 pub fixed_window: FixedWindowParams,
740
741 pub vegas_exit: VegasParams,
746
747 pub cwnd: CongestionWindowParams,
749
750 pub rtt: RoundTripEstimatorParams,
752
753 pub flow_ctrl: FlowCtrlParameters,
755}
756
757impl CongestionControlNetParams {
758 #[cfg(test)]
759 pub(crate) fn defaults_for_tests() -> Self {
761 Self {
762 fixed_window: FixedWindowParams::defaults_for_tests(),
763 vegas_exit: VegasParams::defaults_for_tests(),
764 cwnd: CongestionWindowParams::defaults_for_tests(),
765 rtt: RoundTripEstimatorParams::defaults_for_tests(),
766 flow_ctrl: FlowCtrlParameters::defaults_for_tests(),
767 }
768 }
769}
770
771#[derive(Debug, Clone)]
779#[allow(clippy::exhaustive_structs)]
780pub struct CircNetParameters {
781 pub cc: CongestionControlNetParams,
783}
784
785pub trait IncomingStreamRequestFilterFactory {
791 fn current_filter(&self) -> Box<dyn IncomingStreamRequestFilter>;
794}
795
796impl<F> IncomingStreamRequestFilterFactory for F
797where
798 F: Fn() -> Box<dyn IncomingStreamRequestFilter>,
799{
800 fn current_filter(&self) -> Box<dyn IncomingStreamRequestFilter> {
801 (self)()
802 }
803}
804
805#[cfg(test)]
806mod test {
807 #![allow(clippy::bool_assert_comparison)]
809 #![allow(clippy::clone_on_copy)]
810 #![allow(clippy::dbg_macro)]
811 #![allow(clippy::mixed_attributes_style)]
812 #![allow(clippy::print_stderr)]
813 #![allow(clippy::print_stdout)]
814 #![allow(clippy::single_char_pattern)]
815 #![allow(clippy::unwrap_used)]
816 #![allow(clippy::unchecked_time_subtraction)]
817 #![allow(clippy::useless_vec)]
818 #![allow(clippy::needless_pass_by_value)]
819 #![allow(clippy::string_slice)] use tor_cell::chancell::msg::{AnyChanMsg, Create2, CreateFast, HandshakeType};
823 use tor_cell::chancell::{AnyChanCell, ChanCmd, ChanMsg as _};
824 use tor_rtcompat::test_with_one_runtime;
825
826 use crate::channel::test_utils;
827 use crate::circuit::CircParameters;
828
829 #[test]
831 fn create_fast() {
832 test_with_one_runtime!(|rt| async move {
833 let mut conn_inspector = test_utils::ConnInspector::new();
834
835 let (client_chan, relay_chan, _circuit_stream_rx, _target_builder) =
836 test_utils::new_channel_pair_with_keys(&rt, &conn_inspector);
837
838 let pending_tunnel = test_utils::new_pending_tunnel(&rt, &client_chan).await;
839
840 let circ_params = CircParameters::default();
841
842 let tunnel = pending_tunnel
843 .create_firsthop_fast(circ_params)
844 .await
845 .unwrap();
846
847 assert_eq!(
849 conn_inspector.try_client_cell().unwrap().msg().cmd(),
850 ChanCmd::CREATE_FAST,
851 );
852 assert_eq!(
853 conn_inspector.try_relay_cell().unwrap().msg().cmd(),
854 ChanCmd::CREATED_FAST,
855 );
856
857 drop(tunnel);
858
859 assert_eq!(
860 conn_inspector.client_cell().await.unwrap().msg().cmd(),
861 ChanCmd::DESTROY,
862 );
863
864 let wait_fut =
866 futures::future::join(client_chan.wait_for_close(), relay_chan.wait_for_close());
867 drop((client_chan, relay_chan));
868 let _ = wait_fut.await;
869
870 assert!(conn_inspector.try_client_cell().is_none());
872 assert!(conn_inspector.try_relay_cell().is_none());
873 });
874 }
875
876 #[test]
878 fn create_fast_fail() {
879 test_with_one_runtime!(|rt| async move {
880 let mut conn_inspector = test_utils::ConnInspector::new();
881
882 conn_inspector.set_client_cell_modifier(|cell: &mut AnyChanCell| {
885 let circ_id = cell.circid();
886 if let AnyChanMsg::CreateFast(msg) = cell.msg() {
887 let mut new_handshake = msg.handshake().to_vec();
888
889 for byte in &mut new_handshake {
891 *byte = !*byte;
892 }
893
894 let new_msg = CreateFast::new(new_handshake);
896 *cell = AnyChanCell::new(circ_id, AnyChanMsg::CreateFast(new_msg));
897 }
898 });
899
900 let (client_chan, relay_chan, _circuit_stream_rx, _target_builder) =
901 test_utils::new_channel_pair_with_keys(&rt, &conn_inspector);
902
903 let pending_tunnel = test_utils::new_pending_tunnel(&rt, &client_chan).await;
904
905 let circ_params = CircParameters::default();
906
907 assert!(matches!(
915 pending_tunnel.create_firsthop_fast(circ_params).await,
916 Err(crate::Error::BadCircHandshakeAuth),
917 ));
918
919 assert_eq!(
921 conn_inspector.try_client_cell().unwrap().msg().cmd(),
922 ChanCmd::CREATE_FAST,
923 );
924 assert_eq!(
925 conn_inspector.try_relay_cell().unwrap().msg().cmd(),
926 ChanCmd::CREATED_FAST,
927 );
928
929 assert_eq!(
932 conn_inspector.client_cell().await.unwrap().msg().cmd(),
933 ChanCmd::DESTROY,
934 );
935
936 let wait_fut =
938 futures::future::join(client_chan.wait_for_close(), relay_chan.wait_for_close());
939 drop((client_chan, relay_chan));
940 let _ = wait_fut.await;
941
942 assert!(conn_inspector.try_client_cell().is_none());
944 assert!(conn_inspector.try_relay_cell().is_none());
945 });
946 }
947
948 #[test]
951 fn tap() {
952 test_with_one_runtime!(|rt| async move {
953 let mut conn_inspector = test_utils::ConnInspector::new();
954
955 let (client_chan, _relay_chan, _circuit_stream_rx, mut target_builder) =
956 test_utils::new_channel_pair_with_keys(&rt, &conn_inspector);
957
958 let pending_tunnel = test_utils::new_pending_tunnel(&rt, &client_chan).await;
959
960 let circ_params = CircParameters::default();
961
962 let protocols = "Relay=1".parse().unwrap();
965 let target = target_builder.protocols(protocols).build().unwrap();
966
967 let _tunnel = pending_tunnel
971 .create_firsthop(&target, circ_params)
972 .await
973 .unwrap();
974
975 assert_eq!(
977 conn_inspector.try_client_cell().unwrap().msg().cmd(),
978 ChanCmd::CREATE2,
979 );
980 assert_eq!(
981 conn_inspector.try_relay_cell().unwrap().msg().cmd(),
982 ChanCmd::CREATED2,
983 );
984 });
985 }
986
987 #[test]
989 fn ntor() {
990 test_with_one_runtime!(|rt| async move {
991 let mut conn_inspector = test_utils::ConnInspector::new();
992
993 let (client_chan, relay_chan, _circuit_stream_rx, mut target_builder) =
994 test_utils::new_channel_pair_with_keys(&rt, &conn_inspector);
995
996 for relay_version in [2, 3] {
1000 let pending_tunnel = test_utils::new_pending_tunnel(&rt, &client_chan).await;
1001
1002 let circ_params = CircParameters::default();
1003
1004 let protocols = format!("Relay=2-{relay_version}").parse().unwrap();
1005 let target = target_builder.protocols(protocols).build().unwrap();
1006
1007 let tunnel = pending_tunnel
1008 .create_firsthop(&target, circ_params)
1009 .await
1010 .unwrap();
1011
1012 let client_cell = conn_inspector.try_client_cell().unwrap().msg().clone();
1013 let relay_cell = conn_inspector.try_relay_cell().unwrap().msg().clone();
1014
1015 assert_eq!(client_cell.cmd(), ChanCmd::CREATE2);
1017 assert_eq!(relay_cell.cmd(), ChanCmd::CREATED2);
1018
1019 let AnyChanMsg::Create2(client_cell) = client_cell else {
1021 unreachable!("CREATE2 checked above");
1022 };
1023 assert_eq!(client_cell.handshake_type(), HandshakeType::NTOR);
1024
1025 drop(tunnel);
1026
1027 assert_eq!(
1028 conn_inspector.client_cell().await.unwrap().msg().cmd(),
1029 ChanCmd::DESTROY,
1030 );
1031
1032 assert!(conn_inspector.try_client_cell().is_none());
1034 assert!(conn_inspector.try_relay_cell().is_none());
1035 }
1036
1037 let wait_fut =
1039 futures::future::join(client_chan.wait_for_close(), relay_chan.wait_for_close());
1040 drop((client_chan, relay_chan));
1041 let _ = wait_fut.await;
1042
1043 assert!(conn_inspector.try_client_cell().is_none());
1045 assert!(conn_inspector.try_relay_cell().is_none());
1046 });
1047 }
1048
1049 #[test]
1051 fn ntor_fail() {
1052 test_with_one_runtime!(|rt| async move {
1053 let mut conn_inspector = test_utils::ConnInspector::new();
1054
1055 conn_inspector.set_client_cell_modifier(|cell: &mut AnyChanCell| {
1057 let circ_id = cell.circid();
1058 if let AnyChanMsg::Create2(msg) = cell.msg() {
1059 let mut new_body = msg.body().to_vec();
1060
1061 new_body[10] = !new_body[10];
1063
1064 let new_msg = Create2::new(msg.handshake_type(), new_body);
1066 *cell = AnyChanCell::new(circ_id, AnyChanMsg::Create2(new_msg));
1067 }
1068 });
1069
1070 let (client_chan, relay_chan, _circuit_stream_rx, mut target_builder) =
1071 test_utils::new_channel_pair_with_keys(&rt, &conn_inspector);
1072
1073 for relay_version in [2, 3] {
1077 let pending_tunnel = test_utils::new_pending_tunnel(&rt, &client_chan).await;
1078
1079 let circ_params = CircParameters::default();
1080
1081 let protocols = format!("Relay=2-{relay_version}").parse().unwrap();
1082 let target = target_builder.protocols(protocols).build().unwrap();
1083
1084 assert!(matches!(
1087 pending_tunnel.create_firsthop(&target, circ_params).await,
1088 Err(crate::Error::CircRefused(_)),
1089 ));
1090
1091 assert_eq!(
1093 conn_inspector.try_client_cell().unwrap().msg().cmd(),
1094 ChanCmd::CREATE2,
1095 );
1096 assert_eq!(
1097 conn_inspector.try_relay_cell().unwrap().msg().cmd(),
1098 ChanCmd::DESTROY,
1099 );
1100
1101 assert!(conn_inspector.try_client_cell().is_none());
1103 assert!(conn_inspector.try_relay_cell().is_none());
1104 }
1105
1106 let wait_fut =
1108 futures::future::join(client_chan.wait_for_close(), relay_chan.wait_for_close());
1109 drop((client_chan, relay_chan));
1110 let _ = wait_fut.await;
1111
1112 assert!(conn_inspector.try_client_cell().is_none());
1114 assert!(conn_inspector.try_relay_cell().is_none());
1115 });
1116 }
1117
1118 #[test]
1120 fn ntor_v3() {
1121 test_with_one_runtime!(|rt| async move {
1122 let mut conn_inspector = test_utils::ConnInspector::new();
1123
1124 let (client_chan, relay_chan, _circuit_stream_rx, mut target_builder) =
1125 test_utils::new_channel_pair_with_keys(&rt, &conn_inspector);
1126
1127 for relay_version in [4, 5, 6] {
1132 let pending_tunnel = test_utils::new_pending_tunnel(&rt, &client_chan).await;
1133
1134 let circ_params = CircParameters::default();
1135
1136 let protocols = format!("Relay=4-{relay_version}").parse().unwrap();
1137 let target = target_builder.protocols(protocols).build().unwrap();
1138
1139 let tunnel = pending_tunnel
1140 .create_firsthop(&target, circ_params)
1141 .await
1142 .unwrap();
1143
1144 let client_cell = conn_inspector.try_client_cell().unwrap().msg().clone();
1145 let relay_cell = conn_inspector.try_relay_cell().unwrap().msg().clone();
1146
1147 assert_eq!(client_cell.cmd(), ChanCmd::CREATE2);
1149 assert_eq!(relay_cell.cmd(), ChanCmd::CREATED2);
1150
1151 let AnyChanMsg::Create2(client_cell) = client_cell else {
1153 unreachable!("CREATE2 checked above");
1154 };
1155 assert_eq!(client_cell.handshake_type(), HandshakeType::NTOR_V3);
1156
1157 drop(tunnel);
1161
1162 assert_eq!(
1163 conn_inspector.client_cell().await.unwrap().msg().cmd(),
1164 ChanCmd::DESTROY,
1165 );
1166
1167 assert!(conn_inspector.try_client_cell().is_none());
1169 assert!(conn_inspector.try_relay_cell().is_none());
1170 }
1171
1172 let wait_fut =
1174 futures::future::join(client_chan.wait_for_close(), relay_chan.wait_for_close());
1175 drop((client_chan, relay_chan));
1176 let _ = wait_fut.await;
1177
1178 assert!(conn_inspector.try_client_cell().is_none());
1180 assert!(conn_inspector.try_relay_cell().is_none());
1181 });
1182 }
1183
1184 #[test]
1186 fn ntor_v3_fail() {
1187 test_with_one_runtime!(|rt| async move {
1188 let mut conn_inspector = test_utils::ConnInspector::new();
1189
1190 conn_inspector.set_client_cell_modifier(|cell: &mut AnyChanCell| {
1192 let circ_id = cell.circid();
1193 if let AnyChanMsg::Create2(msg) = cell.msg() {
1194 let mut new_body = msg.body().to_vec();
1195
1196 new_body[10] = !new_body[10];
1198
1199 let new_msg = Create2::new(msg.handshake_type(), new_body);
1201 *cell = AnyChanCell::new(circ_id, AnyChanMsg::Create2(new_msg));
1202 }
1203 });
1204
1205 let (client_chan, relay_chan, _circuit_stream_rx, mut target_builder) =
1206 test_utils::new_channel_pair_with_keys(&rt, &conn_inspector);
1207
1208 for relay_version in [4, 5, 6] {
1213 let pending_tunnel = test_utils::new_pending_tunnel(&rt, &client_chan).await;
1214
1215 let circ_params = CircParameters::default();
1216
1217 let protocols = format!("Relay=4-{relay_version}").parse().unwrap();
1218 let target = target_builder.protocols(protocols).build().unwrap();
1219
1220 assert!(matches!(
1223 pending_tunnel.create_firsthop(&target, circ_params).await,
1224 Err(crate::Error::CircRefused(_)),
1225 ));
1226
1227 assert_eq!(
1229 conn_inspector.try_client_cell().unwrap().msg().cmd(),
1230 ChanCmd::CREATE2,
1231 );
1232 assert_eq!(
1233 conn_inspector.try_relay_cell().unwrap().msg().cmd(),
1234 ChanCmd::DESTROY,
1235 );
1236
1237 assert!(conn_inspector.try_client_cell().is_none());
1239 assert!(conn_inspector.try_relay_cell().is_none());
1240 }
1241
1242 let wait_fut =
1244 futures::future::join(client_chan.wait_for_close(), relay_chan.wait_for_close());
1245 drop((client_chan, relay_chan));
1246 let _ = wait_fut.await;
1247
1248 assert!(conn_inspector.try_client_cell().is_none());
1250 assert!(conn_inspector.try_relay_cell().is_none());
1251 });
1252 }
1253
1254 #[test]
1256 fn create2_invalid_handshake_fail() {
1257 test_with_one_runtime!(|rt| async move {
1258 let mut conn_inspector = test_utils::ConnInspector::new();
1259
1260 conn_inspector.set_client_cell_modifier(|cell: &mut AnyChanCell| {
1262 let circ_id = cell.circid();
1263 if let AnyChanMsg::Create2(msg) = cell.msg() {
1264 let new_msg = tor_cell::chancell::msg::Create2::new(99.into(), msg.body());
1266 *cell = AnyChanCell::new(circ_id, AnyChanMsg::Create2(new_msg));
1267 }
1268 });
1269
1270 let (client_chan, relay_chan, _circuit_stream_rx, mut target_builder) =
1271 test_utils::new_channel_pair_with_keys(&rt, &conn_inspector);
1272
1273 for relay_version in [2, 6] {
1280 let pending_tunnel = test_utils::new_pending_tunnel(&rt, &client_chan).await;
1281
1282 let circ_params = CircParameters::default();
1283
1284 let protocols = format!("Relay=2-{relay_version}").parse().unwrap();
1285 let target = target_builder.protocols(protocols).build().unwrap();
1286
1287 assert!(matches!(
1290 pending_tunnel.create_firsthop(&target, circ_params).await,
1291 Err(crate::Error::CircRefused(_)),
1292 ));
1293
1294 assert_eq!(
1296 conn_inspector.try_client_cell().unwrap().msg().cmd(),
1297 ChanCmd::CREATE2,
1298 );
1299 assert_eq!(
1300 conn_inspector.try_relay_cell().unwrap().msg().cmd(),
1301 ChanCmd::DESTROY,
1302 );
1303
1304 assert!(conn_inspector.try_client_cell().is_none());
1306 assert!(conn_inspector.try_relay_cell().is_none());
1307 }
1308
1309 let wait_fut =
1311 futures::future::join(client_chan.wait_for_close(), relay_chan.wait_for_close());
1312 drop((client_chan, relay_chan));
1313 let _ = wait_fut.await;
1314
1315 assert!(conn_inspector.try_client_cell().is_none());
1317 assert!(conn_inspector.try_relay_cell().is_none());
1318 });
1319 }
1320}