1#![allow(non_snake_case)]
23
24use crate::crypto::handshake::KeyGenerator;
25use crate::crypto::ll::kdf::{Kdf, ShakeKdf};
26use crate::util::ct;
27use crate::{Error, Result};
28use std::result::Result as StdResult;
29use tor_bytes::{Reader, SecretBuf, Writer};
30use tor_hscrypto::{
31 Subcredential,
32 ops::{HS_MAC_LEN, hs_mac},
33 pk::{HsIntroPtSessionIdKey, HsSvcNtorKey},
34};
35use tor_llcrypto::pk::{curve25519, ed25519};
36use tor_llcrypto::util::ct::CtByteArray;
37
38use cipher::{KeyIvInit, StreamCipher};
39
40use subtle::ConstantTimeEq as _;
41use tor_error::into_internal;
42use tor_llcrypto::cipher::aes::Aes256Ctr;
43use zeroize::{Zeroize as _, Zeroizing};
44
45#[cfg(any(test, feature = "hs-service"))]
46use tor_hscrypto::pk::HsSvcNtorKeypair;
47
48type EncKey = Zeroizing<[u8; 32]>;
52type MacKey = [u8; 32];
54type MacTag = CtByteArray<HS_MAC_LEN>;
56type AuthInputMac = MacTag;
58
59pub struct HsNtorHkdfKeyGenerator {
62 seed: SecretBuf,
64}
65
66impl HsNtorHkdfKeyGenerator {
67 pub fn new(seed: SecretBuf) -> Self {
69 HsNtorHkdfKeyGenerator { seed }
70 }
71}
72
73impl KeyGenerator for HsNtorHkdfKeyGenerator {
74 fn expand(self, keylen: usize) -> Result<SecretBuf> {
76 ShakeKdf::new().derive(&self.seed[..], keylen)
77 }
78}
79
80#[derive(Clone)]
85#[cfg(any(test, feature = "hs-client"))]
86pub struct HsNtorServiceInfo {
87 B: HsSvcNtorKey,
90
91 auth_key: HsIntroPtSessionIdKey,
101
102 subcredential: Subcredential,
104}
105
106#[cfg(any(test, feature = "hs-client"))]
107impl HsNtorServiceInfo {
108 pub fn new(
110 B: HsSvcNtorKey,
111 auth_key: HsIntroPtSessionIdKey,
112 subcredential: Subcredential,
113 ) -> Self {
114 HsNtorServiceInfo {
115 B,
116 auth_key,
117 subcredential,
118 }
119 }
120}
121
122#[cfg(any(test, feature = "hs-client"))]
124pub struct HsNtorClientState {
125 service_info: HsNtorServiceInfo,
127
128 x: curve25519::StaticSecret,
130 X: curve25519::PublicKey,
132
133 Bx: curve25519::SharedSecret,
137
138 intro1_target_len: usize,
140}
141
142#[cfg(any(test, feature = "hs-client"))]
149const INTRO1_TARGET_LEN: usize = 490;
150
151#[cfg(any(test, feature = "hs-client"))]
152impl HsNtorClientState {
153 pub fn new<R>(rng: &mut R, service_info: HsNtorServiceInfo) -> Self
159 where
160 R: rand::Rng + rand::CryptoRng,
161 {
162 let x = curve25519::StaticSecret::random_from_rng(rng);
163 Self::new_no_keygen(service_info, x)
164 }
165
166 #[cfg(test)]
168 fn set_intro1_target_len(&mut self, len: usize) {
169 self.intro1_target_len = len;
170 }
171
172 fn new_no_keygen(service_info: HsNtorServiceInfo, x: curve25519::StaticSecret) -> Self {
174 let X = curve25519::PublicKey::from(&x);
175 let Bx = x.diffie_hellman(&service_info.B);
176 Self {
177 service_info,
178 x,
179 X,
180 Bx,
181 intro1_target_len: INTRO1_TARGET_LEN,
182 }
183 }
184
185 pub fn client_send_intro(&self, intro_header: &[u8], plaintext_body: &[u8]) -> Result<Vec<u8>> {
196 const ENC_OVERHEAD: usize = 32 + 32;
198
199 let state = self;
200 let service = &state.service_info;
201
202 let (enc_key, mac_key) = get_introduce_key_material(
204 &state.Bx,
205 &service.auth_key,
206 &state.X,
207 &service.B,
208 &service.subcredential,
209 )?;
210
211 let padded_body_target_len = self
212 .intro1_target_len
213 .saturating_sub(intro_header.len() + ENC_OVERHEAD);
214 let mut padded_body = plaintext_body.to_vec();
215 if padded_body.len() < padded_body_target_len {
216 padded_body.resize(padded_body_target_len, 0);
217 }
218 debug_assert!(padded_body.len() >= padded_body_target_len);
219
220 let (ciphertext, mac_tag) =
221 encrypt_and_mac(&padded_body, intro_header, &state.X, &enc_key, mac_key);
222 padded_body.zeroize();
223
224 let mut response: Vec<u8> = Vec::new();
226 response
227 .write(&state.X)
228 .and_then(|_| response.write(&ciphertext))
229 .and_then(|_| response.write(&mac_tag))
230 .map_err(into_internal!("Can't encode hs-ntor client handshake."))?;
231
232 Ok(response)
233 }
234
235 pub fn client_receive_rend(&self, msg: &[u8]) -> Result<HsNtorHkdfKeyGenerator> {
241 let state = self;
242
243 let mut cur = Reader::from_slice(msg);
245 let Y: curve25519::PublicKey = cur
246 .extract()
247 .map_err(|e| Error::from_bytes_err(e, "hs_ntor handshake"))?;
248 let mac_tag: MacTag = cur
249 .extract()
250 .map_err(|e| Error::from_bytes_err(e, "hs_ntor handshake"))?;
251
252 let xy = state.x.diffie_hellman(&Y);
254 let xb = state.x.diffie_hellman(&state.service_info.B);
255
256 let (keygen, my_mac_tag) = get_rendezvous_key_material(
257 &xy,
258 &xb,
259 &state.service_info.auth_key,
260 &state.service_info.B,
261 &state.X,
262 &Y,
263 )?;
264
265 let okay = my_mac_tag.ct_eq(&mac_tag)
267 & ct::bool_to_choice(xy.was_contributory())
268 & ct::bool_to_choice(xb.was_contributory());
269
270 if !bool::from(okay) {
272 return Err(Error::BadCircHandshakeAuth);
273 }
274
275 Ok(keygen)
276 }
277}
278
279#[cfg(any(test, feature = "hs-client"))]
283fn encrypt_and_mac(
284 plaintext: &[u8],
285 other_data: &[u8],
286 public_key: &curve25519::PublicKey,
287 enc_key: &EncKey,
288 mac_key: MacKey,
289) -> (Vec<u8>, MacTag) {
290 let mut ciphertext = plaintext.to_vec();
291 let zero_iv = Default::default();
293 let mut cipher = Aes256Ctr::new((&**enc_key).into(), &zero_iv);
294 cipher.apply_keystream(&mut ciphertext);
295
296 let mut mac_body: Vec<u8> = Vec::new();
299 mac_body.extend(other_data);
300 mac_body.extend(public_key.as_bytes());
301 mac_body.extend(&ciphertext);
302 let mac_tag = hs_mac(&mac_key, &mac_body);
303
304 (ciphertext, mac_tag)
305}
306
307#[cfg(any(test, feature = "hs-service"))]
320pub fn server_receive_intro<R>(
321 rng: &mut R,
322 k_hss_ntor: &HsSvcNtorKeypair,
323 auth_key: &HsIntroPtSessionIdKey,
324 subcredential: &[Subcredential],
325 intro_header: &[u8],
326 msg: &[u8],
327) -> Result<(HsNtorHkdfKeyGenerator, Vec<u8>, Vec<u8>)>
328where
329 R: rand::Rng + rand::CryptoRng,
330{
331 let y = curve25519::StaticSecret::random_from_rng(rng);
332 server_receive_intro_no_keygen(&y, k_hss_ntor, auth_key, subcredential, intro_header, msg)
333}
334
335#[cfg(any(test, feature = "hs-service"))]
337fn server_receive_intro_no_keygen(
338 y: &curve25519::StaticSecret,
341 k_hss_ntor: &HsSvcNtorKeypair,
342 auth_key: &HsIntroPtSessionIdKey,
343 subcredential: &[Subcredential],
344 intro_header: &[u8],
345 msg: &[u8],
346) -> Result<(HsNtorHkdfKeyGenerator, Vec<u8>, Vec<u8>)> {
347 let mut cur = Reader::from_slice(msg);
349 let X: curve25519::PublicKey = cur
350 .extract()
351 .map_err(|e| Error::from_bytes_err(e, "hs ntor handshake"))?;
352 let ciphertext = &mut cur
353 .take_all_but(HS_MAC_LEN)
354 .map_err(|e| Error::from_bytes_err(e, "hs ntor handshake"))?
355 .to_vec();
356 let mac_tag: MacTag = cur
357 .extract()
358 .map_err(|e| Error::from_bytes_err(e, "hs ntor handshake"))?;
359
360 let bx = k_hss_ntor.secret().as_ref().diffie_hellman(&X);
362
363 let mut found_dec_key = None;
369
370 for subcredential in subcredential {
371 let (dec_key, mac_key) =
372 get_introduce_key_material(&bx, auth_key, &X, k_hss_ntor.public(), subcredential)?; let mut mac_body: Vec<u8> = Vec::new();
377 mac_body.extend(intro_header);
378 mac_body.extend(X.as_bytes());
379 mac_body.extend(&ciphertext[..]);
380 let my_mac_tag = hs_mac(&mac_key, &mac_body);
381
382 if my_mac_tag == mac_tag {
383 found_dec_key = Some(dec_key);
385 }
386 }
387
388 let Some(dec_key) = found_dec_key else {
389 return Err(Error::BadCircHandshakeAuth);
390 };
391
392 let zero_iv = Default::default();
394 let mut cipher = Aes256Ctr::new((&*dec_key).into(), &zero_iv);
395 cipher.apply_keystream(ciphertext);
396 let plaintext = ciphertext; let Y = curve25519::PublicKey::from(y);
400
401 let xy = y.diffie_hellman(&X);
403 let xb = k_hss_ntor.secret().as_ref().diffie_hellman(&X);
404
405 let okay =
407 ct::bool_to_choice(xy.was_contributory()) & ct::bool_to_choice(xb.was_contributory());
408 if !bool::from(okay) {
409 return Err(Error::BadCircHandshakeAuth);
410 }
411
412 let (keygen, auth_input_mac) =
413 get_rendezvous_key_material(&xy, &xb, auth_key, k_hss_ntor.public(), &X, &Y)?;
414
415 let mut reply: Vec<u8> = Vec::new();
417 reply
418 .write(&Y)
419 .and_then(|_| reply.write(&auth_input_mac))
420 .map_err(into_internal!("Can't encode hs-ntor server handshake."))?;
421
422 Ok((keygen, reply, plaintext.clone()))
423}
424
425fn get_introduce_key_material(
441 bx: &curve25519::SharedSecret,
442 auth_key: &ed25519::PublicKey,
443 X: &curve25519::PublicKey,
444 B: &curve25519::PublicKey,
445 subcredential: &Subcredential,
446) -> std::result::Result<(EncKey, MacKey), tor_error::Bug> {
447 let hs_ntor_protoid_constant = &b"tor-hs-ntor-curve25519-sha3-256-1"[..];
448 let hs_ntor_key_constant = &b"tor-hs-ntor-curve25519-sha3-256-1:hs_key_extract"[..];
449 let hs_ntor_expand_constant = &b"tor-hs-ntor-curve25519-sha3-256-1:hs_key_expand"[..];
450
451 let mut secret_input = SecretBuf::new();
454 secret_input
455 .write(bx) .and_then(|_| secret_input.write(auth_key)) .and_then(|_| secret_input.write(X)) .and_then(|_| secret_input.write(B)) .and_then(|_| secret_input.write(hs_ntor_protoid_constant)) .and_then(|_| secret_input.write(hs_ntor_key_constant))
462 .and_then(|_| secret_input.write(hs_ntor_expand_constant))
464 .and_then(|_| secret_input.write(subcredential))
465 .map_err(into_internal!("Can't generate hs-ntor kdf input."))?;
466
467 let hs_keys = ShakeKdf::new()
468 .derive(&secret_input[..], 32 + 32)
469 .map_err(into_internal!("Can't compute SHAKE"))?;
470 let enc_key = Zeroizing::new(
472 hs_keys[0..32]
473 .try_into()
474 .map_err(into_internal!("converting enc_key"))?,
475 );
476 let mac_key = hs_keys[32..64]
477 .try_into()
478 .map_err(into_internal!("converting mac_key"))?;
479
480 Ok((enc_key, mac_key))
481}
482
483fn get_rendezvous_key_material(
497 xy: &curve25519::SharedSecret,
498 xb: &curve25519::SharedSecret,
499 auth_key: &ed25519::PublicKey,
500 B: &curve25519::PublicKey,
501 X: &curve25519::PublicKey,
502 Y: &curve25519::PublicKey,
503) -> StdResult<(HsNtorHkdfKeyGenerator, AuthInputMac), tor_error::Bug> {
504 let hs_ntor_protoid_constant = &b"tor-hs-ntor-curve25519-sha3-256-1"[..];
505 let hs_ntor_mac_constant = &b"tor-hs-ntor-curve25519-sha3-256-1:hs_mac"[..];
506 let hs_ntor_verify_constant = &b"tor-hs-ntor-curve25519-sha3-256-1:hs_verify"[..];
507 let server_string_constant = &b"Server"[..];
508 let hs_ntor_expand_constant = &b"tor-hs-ntor-curve25519-sha3-256-1:hs_key_expand"[..];
509 let hs_ntor_key_constant = &b"tor-hs-ntor-curve25519-sha3-256-1:hs_key_extract"[..];
510
511 let mut secret_input = SecretBuf::new();
513 secret_input
514 .write(xy) .and_then(|_| secret_input.write(xb)) .and_then(|_| secret_input.write(auth_key)) .and_then(|_| secret_input.write(B)) .and_then(|_| secret_input.write(X)) .and_then(|_| secret_input.write(Y)) .and_then(|_| secret_input.write(hs_ntor_protoid_constant)) .map_err(into_internal!(
522 "Can't encode input to hs-ntor key derivation."
523 ))?;
524
525 let ntor_key_seed = hs_mac(&secret_input, hs_ntor_key_constant);
527 let verify = hs_mac(&secret_input, hs_ntor_verify_constant);
528
529 let mut auth_input = Vec::new();
531 auth_input
532 .write(&verify)
533 .and_then(|_| auth_input.write(auth_key)) .and_then(|_| auth_input.write(B)) .and_then(|_| auth_input.write(Y)) .and_then(|_| auth_input.write(X)) .and_then(|_| auth_input.write(hs_ntor_protoid_constant)) .and_then(|_| auth_input.write(server_string_constant)) .map_err(into_internal!("Can't encode auth-input for hs-ntor."))?;
540
541 let auth_input_mac = hs_mac(&auth_input, hs_ntor_mac_constant);
543
544 let mut kdf_seed = SecretBuf::new();
546 kdf_seed
547 .write(&ntor_key_seed)
548 .and_then(|_| kdf_seed.write(hs_ntor_expand_constant))
549 .map_err(into_internal!("Can't encode kdf-input for hs-ntor."))?;
550 let keygen = HsNtorHkdfKeyGenerator::new(kdf_seed);
551
552 Ok((keygen, auth_input_mac))
553}
554
555#[cfg(test)]
558mod test {
559 #![allow(clippy::bool_assert_comparison)]
561 #![allow(clippy::clone_on_copy)]
562 #![allow(clippy::dbg_macro)]
563 #![allow(clippy::mixed_attributes_style)]
564 #![allow(clippy::print_stderr)]
565 #![allow(clippy::print_stdout)]
566 #![allow(clippy::single_char_pattern)]
567 #![allow(clippy::unwrap_used)]
568 #![allow(clippy::unchecked_time_subtraction)]
569 #![allow(clippy::useless_vec)]
570 #![allow(clippy::needless_pass_by_value)]
571 #![allow(clippy::string_slice)] use super::*;
574 use hex_literal::hex;
575 use tor_basic_utils::test_rng::testing_rng;
576
577 #[test]
578 fn hs_ntor() -> Result<()> {
581 let mut rng = testing_rng();
582
583 let intro_b_privkey = curve25519::StaticSecret::random_from_rng(&mut rng);
585 let intro_b_pubkey = curve25519::PublicKey::from(&intro_b_privkey);
586 let intro_auth_key_privkey = ed25519::Keypair::generate(&mut rng);
587 let intro_auth_key_pubkey = ed25519::PublicKey::from(&intro_auth_key_privkey);
588 drop(intro_auth_key_privkey); let client_keys = HsNtorServiceInfo::new(
592 intro_b_pubkey.into(),
593 intro_auth_key_pubkey.into(),
594 [5; 32].into(),
595 );
596
597 let k_hss_ntor = HsSvcNtorKeypair::from_secret_key(intro_b_privkey.into());
598 let auth_key = intro_auth_key_pubkey.into();
599 let subcredentials = vec![[5; 32].into()];
600
601 let state = HsNtorClientState::new(&mut rng, client_keys);
603 let cmsg = state.client_send_intro(&[66; 10], &[42; 60])?;
604 assert_eq!(cmsg.len() + 10, INTRO1_TARGET_LEN);
605
606 let (skeygen, smsg, s_plaintext) = server_receive_intro(
608 &mut rng,
609 &k_hss_ntor,
610 &auth_key,
611 &subcredentials[..],
612 &[66; 10],
613 &cmsg,
614 )?;
615
616 assert_eq!(s_plaintext[0..60], vec![42; 60]);
619
620 let ckeygen = state.client_receive_rend(&smsg)?;
622
623 let skeys = skeygen.expand(128)?;
625 let ckeys = ckeygen.expand(128)?;
626 assert_eq!(skeys, ckeys);
627
628 Ok(())
629 }
630
631 #[test]
632 fn ntor_mac() {
634 let result = hs_mac("who".as_bytes(), b"knows?");
635 assert_eq!(
636 &result,
637 &hex!("5e7da329630fdaa3eab7498bb1dc625bbb9ca968f10392b6af92d51d5db17473").into()
638 );
639
640 let result = hs_mac("gone".as_bytes(), b"by");
641 assert_eq!(
642 &result,
643 &hex!("90071aabb06d3f7c777db41542f4790c7dd9e2e7b2b842f54c9c42bbdb37e9a0").into()
644 );
645 }
646
647 #[test]
649 fn testvec() {
650 let kp_hs_ipt_sid =
651 hex!("34E171E4358E501BFF21ED907E96AC6BFEF697C779D040BBAF49ACC30FC5D21F");
652 let subcredential =
653 hex!("0085D26A9DEBA252263BF0231AEAC59B17CA11BAD8A218238AD6487CBAD68B57");
654 let kp_hss_ntor = hex!("8E5127A40E83AABF6493E41F142B6EE3604B85A3961CD7E38D247239AFF71979");
655 let ks_hss_ntor = hex!("A0ED5DBF94EEB2EDB3B514E4CF6ABFF6022051CC5F103391F1970A3FCD15296A");
656 let key_x = hex!("60B4D6BF5234DCF87A4E9D7487BDF3F4A69B6729835E825CA29089CFDDA1E341");
657 let key_y = hex!("68CB5188CA0CD7924250404FAB54EE1392D3D2B9C049A2E446513875952F8F55");
658
659 let kp_hs_ipt_sid: HsIntroPtSessionIdKey = ed25519::PublicKey::from_bytes(&kp_hs_ipt_sid)
661 .unwrap()
662 .into();
663 let subcredential: Subcredential = subcredential.into();
664 let kp_hss_ntor: HsSvcNtorKey = curve25519::PublicKey::from(kp_hss_ntor).into();
665
666 let service_info = HsNtorServiceInfo {
667 B: kp_hss_ntor,
668 auth_key: kp_hs_ipt_sid.clone(),
669 subcredential: subcredential.clone(),
670 };
671
672 let key_x: curve25519::StaticSecret = curve25519::StaticSecret::from(key_x);
674
675 let intro_header = hex!(
678 "000000000000000000000000000000000000000002002034E171E4358E501BFF
679 21ED907E96AC6BFEF697C779D040BBAF49ACC30FC5D21F00"
680 );
681 let intro_body = hex!(
682 "6BD364C12638DD5C3BE23D76ACA05B04E6CE932C0101000100200DE6130E4FCA
683 C4EDDA24E21220CC3EADAE403EF6B7D11C8273AC71908DE565450300067F0000
684 0113890214F823C4F8CC085C792E0AEE0283FE00AD7520B37D0320728D5DF39B
685 7B7077A0118A900FF4456C382F0041300ACF9C58E51C392795EF870000000000
686 0000000000000000000000000000000000000000000000000000000000000000
687 000000000000000000000000000000000000000000000000000000000000"
688 );
689 let mut client_state = HsNtorClientState::new_no_keygen(service_info, key_x);
691 client_state.set_intro1_target_len(0);
694 let encrypted_body = client_state
695 .client_send_intro(&intro_header, &intro_body)
696 .unwrap();
697
698 let mut cell_out = intro_header.to_vec();
699 cell_out.extend(&encrypted_body);
700 let expected = &hex!(
701 "000000000000000000000000000000000000000002002034E171E4358E501BFF
702 21ED907E96AC6BFEF697C779D040BBAF49ACC30FC5D21F00BF04348B46D09AED
703 726F1D66C618FDEA1DE58E8CB8B89738D7356A0C59111D5DADBECCCB38E37830
704 4DCC179D3D9E437B452AF5702CED2CCFEC085BC02C4C175FA446525C1B9D5530
705 563C362FDFFB802DAB8CD9EBC7A5EE17DA62E37DEEB0EB187FBB48C63298B0E8
706 3F391B7566F42ADC97C46BA7588278273A44CE96BC68FFDAE31EF5F0913B9A9C
707 7E0F173DBC0BDDCD4ACB4C4600980A7DDD9EAEC6E7F3FA3FC37CD95E5B8BFB3E
708 35717012B78B4930569F895CB349A07538E42309C993223AEA77EF8AEA64F25D
709 DEE97DA623F1AEC0A47F150002150455845C385E5606E41A9A199E7111D54EF2
710 D1A51B7554D8B3692D85AC587FB9E69DF990EFB776D8"
711 );
712 assert_eq!(&cell_out, &expected);
713
714 let ks_hss_ntor = curve25519::StaticSecret::from(ks_hss_ntor).into();
720 let k_hss_ntor = HsSvcNtorKeypair::from_secret_key(ks_hss_ntor);
721 let key_y = curve25519::StaticSecret::from(key_y);
722 let subcredentials = vec![subcredential];
723
724 let (service_keygen, service_reply, service_plaintext) = server_receive_intro_no_keygen(
725 &key_y,
726 &k_hss_ntor,
727 &kp_hs_ipt_sid,
728 &subcredentials[..],
729 &intro_header,
730 &encrypted_body,
731 )
732 .unwrap();
733
734 assert_eq!(&service_plaintext, &intro_body);
736
737 let expected_reply = hex!(
738 "8fbe0db4d4a9c7ff46701e3e0ee7fd05cd28be4f302460addeec9e93354ee700
739 4A92E8437B8424D5E5EC279245D5C72B25A0327ACF6DAF902079FCB643D8B208"
740 );
741 assert_eq!(&service_reply, &expected_reply);
742
743 let client_keygen = client_state.client_receive_rend(&service_reply).unwrap();
745 let bytes_client = client_keygen.expand(128).unwrap();
746 let bytes_service = service_keygen.expand(128).unwrap();
747 let mut key_seed =
748 hex!("4D0C72FE8AFF35559D95ECC18EB5A36883402B28CDFD48C8A530A5A3D7D578DB").to_vec();
749 key_seed.extend(b"tor-hs-ntor-curve25519-sha3-256-1:hs_key_expand");
750 let bytes_expected = HsNtorHkdfKeyGenerator::new(key_seed.into())
751 .expand(128)
752 .unwrap();
753 assert_eq!(&bytes_client, &bytes_service);
754 assert_eq!(&bytes_client, &bytes_expected);
755 }
756}