ping-rust 0.3.0

Menu-driven installer and manager for the shoes proxy server
use super::*;
use crate::{
    client::{self, ClientFormat},
    vless_encryption::{CredentialPair, VlessEncAuth, VlessEncMode},
};

fn sample(vision: bool) -> (ServerConfig, ManagedProfile) {
    let request = GenerationRequest {
        name: None,
        protocol: Protocol::VlessEnc,
        port: 24444,
        output: "unused.yaml".into(),
        server_address: Some("example.test".into()),
        server_name: String::new(),
        reality_dest: None,
        certificate: None,
        certificate_key: None,
        options: GenerationOptions {
            vless_enc_vision: vision,
            ..Default::default()
        },
    };
    let pair = CredentialPair {
        encryption: format!(
            "mlkem768x25519plus.native.0rtt.{}",
            URL_SAFE_NO_PAD.encode([7; 32])
        ),
        decryption: format!(
            "mlkem768x25519plus.native.600s.{}",
            URL_SAFE_NO_PAD.encode([9; 32])
        ),
    };
    let generated = presets::vless_enc::from_pair(&request, pair);
    let profile = ManagedProfile {
        id: Uuid::new_v4(),
        name: "VLESS-ENC-24444".into(),
        port: request.port,
        server_address: request.server_address,
        credentials: generated.credentials,
        certificate_path: None,
        certificate_key_path: None,
        self_signed_certificate: false,
        naive_certificate_validity: None,
        h2mux: Default::default(),
    };
    (generated.server, profile)
}

#[test]
fn vless_enc_yaml_is_native_tcp_with_default_limits_and_secret_only_in_runtime() {
    for vision in [false, true] {
        let (server, profile) = sample(vision);
        let yaml = crate::yaml::to_value(&server).unwrap();
        assert_eq!(yaml["protocol"]["type"], "vless");
        assert_eq!(
            yaml["protocol"]["vision"].as_bool().unwrap_or(false),
            vision
        );
        assert!(yaml["protocol"]["decryption"]
            .as_str()
            .unwrap()
            .contains(".600s."));
        assert!(yaml.get("transport").is_none());
        assert!(yaml.get("quic_settings").is_none());
        assert!(yaml["protocol"].get("encryption_limits").is_none());
        assert!(profile.certificate_path.is_none());
        assert!(!profile.h2mux_eligible());
        let state = serde_json::to_string(&profile).unwrap();
        assert!(!state.contains("decryption"));
        assert!(!state.contains(&URL_SAFE_NO_PAD.encode([9; 32])));
        assert!(ensure_servers_match_state(&[server], &[profile]).is_ok());
    }
    assert_eq!(Protocol::from_menu_number(14), Some(Protocol::VlessEnc));
    assert!(commit::is_managed_profile_file_name("VLESS-ENC-24444.yaml"));
}

#[test]
fn vless_enc_links_exports_and_details_never_expose_server_secret() {
    for vision in [false, true] {
        let (_, mut profile) = sample(vision);
        let link = client::share_uri(&profile, "example.test").unwrap();
        let url = url::Url::parse(&link).unwrap();
        let query: BTreeMap<_, _> = url.query_pairs().into_owned().collect();
        assert_eq!(query["security"], "none");
        assert_eq!(query["type"], "tcp");
        assert!(query["encryption"].contains(".0rtt."));
        assert_eq!(
            query.get("flow").map(String::as_str),
            vision.then_some("xtls-rprx-vision")
        );
        assert_eq!(url.fragment(), Some("VLESS-ENC-24444"));
        assert!(client::share_uri(&profile, "::1")
            .unwrap()
            .contains("@[::1]:24444?"));
        let exported = client::render(&profile, ClientFormat::ClashMeta, "example.test").unwrap();
        let mihomo: serde_json::Value = crate::yaml::from_str(&exported).unwrap();
        assert_eq!(mihomo["proxies"][0]["encryption"], query["encryption"]);
        assert_eq!(mihomo["proxies"][0]["tls"], false);
        assert_eq!(
            mihomo["proxies"][0].get("flow").and_then(|v| v.as_str()),
            vision.then_some("xtls-rprx-vision")
        );
        for format in [ClientFormat::SingBox, ClientFormat::Nekobox] {
            let error = client::render(&profile, format, "example.test").unwrap_err();
            assert!(error.to_string().contains("不支持 VLESS Encryption"));
        }
        let details = crate::cli::profile_details_text(&profile, Some(&link));
        assert!(details.contains("Encryption"));
        assert!(details.contains("native"));
        for output in [&link, &exported, &details] {
            assert!(!output.contains("decryption"));
            assert!(!output.contains(&URL_SAFE_NO_PAD.encode([9; 32])));
        }
        profile.h2mux.enabled = true;
        assert!(profile.validate_h2mux().is_err());
    }
}

#[test]
fn vless_enc_vision_change_preserves_keys_and_updates_runtime_and_state() {
    let (mut server, mut profile) = sample(false);
    let before = crate::yaml::to_value(&server).unwrap();
    apply_profile_change(
        &mut server,
        &mut profile,
        ProfileChange::VlessEncVision(true),
    )
    .unwrap();
    let after = crate::yaml::to_value(&server).unwrap();
    assert!(before["protocol"]["decryption"] == after["protocol"]["decryption"]);
    assert_eq!(after["protocol"]["vision"], true);
    assert!(matches!(
        profile.credentials,
        Credentials::VlessEnc {
            vision: true,
            mode: VlessEncMode::Native,
            auth: VlessEncAuth::X25519,
            ..
        }
    ));
    assert!(ensure_servers_match_state(&[server], &[profile]).is_ok());
}

#[test]
fn vless_enc_rejects_options_on_other_protocols() {
    let request = GenerationRequest {
        name: None,
        protocol: Protocol::Socks5,
        port: 24444,
        output: "unused.yaml".into(),
        server_address: None,
        server_name: String::new(),
        reality_dest: None,
        certificate: None,
        certificate_key: None,
        options: GenerationOptions {
            vless_enc_vision: true,
            ..Default::default()
        },
    };
    assert!(validate_request(&request).is_err());
}

#[cfg(unix)]
#[tokio::test]
async fn vless_enc_dry_run_failure_does_not_echo_secret() {
    use std::os::unix::fs::PermissionsExt;
    let dir = tempfile::tempdir().unwrap();
    let binary = dir.path().join("shoes");
    fs::write(&binary, "#!/bin/sh\necho secret-sentinel >&2\nexit 1\n").unwrap();
    fs::set_permissions(&binary, fs::Permissions::from_mode(0o700)).unwrap();
    let config = dir.path().join("config.yaml");
    fs::write(
        &config,
        "- protocol: {type: vless, decryption: secret-sentinel}\n",
    )
    .unwrap();
    let error = validate_with_binary(&binary, &config).await.unwrap_err();
    assert!(!format!("{error:#}").contains("secret-sentinel"));
}

#[tokio::test]
async fn vless_enc_mode_auth_and_regeneration_use_shoes_and_keep_state_public() {
    let (mut server, mut profile) = sample(false);
    let binary = std::env::var_os("PING_RUST_TEST_SHOES")
        .map(PathBuf::from)
        .unwrap_or_else(|| PathBuf::from(crate::utils::SHOES_BIN));
    for change in [
        ProfileChange::VlessEncMode(VlessEncMode::Random),
        ProfileChange::VlessEncAuth(VlessEncAuth::Mlkem768),
        ProfileChange::RegenerateCredentials,
        ProfileChange::VlessEncVision(true),
    ] {
        apply_profile_change(&mut server, &mut profile, change).unwrap();
        assert!(ensure_servers_match_state(&[server.clone()], &[profile.clone()]).is_ok());
        let state = serde_json::to_string(&profile).unwrap();
        let ServerProtocol::Vless { decryption, .. } = &server.protocol else {
            panic!("VLESS required");
        };
        assert!(!state.contains(decryption));
        let dir = tempfile::tempdir().unwrap();
        let path = dir.path().join("profile.yaml");
        let yaml = crate::yaml::to_string(&vec![&server]).unwrap();
        crate::utils::atomic_write(&path, yaml.as_bytes(), 0o600).unwrap();
        assert!(validate_with_binary(&binary, &path).await.is_ok());
    }
}