ping-rust 0.3.2

Menu-driven installer and manager for the shoes proxy server
use super::*;
use crate::{
    cli::{Cli, Command},
    client::{self, ClientFormat},
    sudoku::{SudokuAscii, SudokuConfig},
};
use clap::Parser;

fn sample() -> (ServerConfig, ManagedProfile) {
    let protocol = Protocol::from_menu_number(16).expect("缺少 VLESS-Sudoku");
    let mut request = tests::request(protocol, "unused.yaml".into());
    request.server_name.clear();
    request.options.sudoku = Some(SudokuConfig {
        password: " test +&?/密码% ".into(),
        ascii: SudokuAscii::Ascii,
        padding_min: 0,
        padding_max: 10,
    });
    validate_request(&request).unwrap();
    let generated = presets::generate(&request, Path::new("."), Uuid::nil()).unwrap();
    let profile = ManagedProfile {
        id: Uuid::nil(),
        name: "sudoku-test".into(),
        port: request.port,
        server_address: Some("203.0.113.10".into()),
        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_sudoku_yaml_link_exports_and_info_agree() {
    let (server, profile) = sample();
    assert_eq!(profile.protocol().slug(), "vless-sudoku");
    assert_eq!(profile.protocol().advanced_label(), "VLESS-Sudoku");
    assert!(commit::is_managed_profile_file_name(
        "VLESS-SUDOKU-443.yaml"
    ));
    let yaml = crate::yaml::to_value(&server).unwrap();
    assert_eq!(yaml["protocol"]["type"], "sudoku_mask");
    assert_eq!(yaml["protocol"]["ascii"], "ascii");
    let inner = &yaml["protocol"]["protocol"];
    assert_eq!(inner["type"], "vless");
    for field in ["encryption", "decryption", "vision"] {
        assert!(inner.get(field).is_none(), "{field}");
    }
    assert!(server.transport.is_none());
    assert!(!profile.h2mux_eligible());
    ensure_servers_match_state(&[server], std::slice::from_ref(&profile)).unwrap();
    let link = client::stored_share_uri(&profile, None).unwrap();
    assert!(link.contains("fm=%7B%22"));
    let parsed = url::Url::parse(&link).unwrap();
    let query: BTreeMap<_, _> = parsed.query_pairs().into_owned().collect();
    for (key, value) in [
        ("encryption", "none"),
        ("security", "none"),
        ("type", "tcp"),
    ] {
        assert_eq!(query[key], value);
    }
    assert_eq!(query.len(), 4);
    let fm: serde_json::Value = serde_json::from_str(&query["fm"]).unwrap();
    assert_eq!(query["fm"], serde_json::to_string(&fm).unwrap());
    assert_eq!(fm["tcp"][0]["settings"]["password"], " test +&?/密码% ");
    assert_eq!(fm["tcp"][0]["settings"]["ascii"], "ascii");
    assert_eq!(fm["tcp"][0]["settings"]["paddingMax"], 10);
    for format in [
        ClientFormat::ClashMeta,
        ClientFormat::SingBox,
        ClientFormat::Nekobox,
    ] {
        assert_eq!(
            client::render(&profile, format, "203.0.113.10")
                .unwrap_err()
                .to_string(),
            crate::sudoku::UNSUPPORTED
        );
    }
    let info = crate::cli::profile_details_text(&profile, Some(&link));
    assert!(!info.contains("加密:无"));
    assert!(info.contains("UUID"));
    assert!(info.contains("外观:Sudoku(ascii、padding 0–10%)"));
    for required in [
        "没有任何加密和认证",
        "目标地址",
        "非 HTTPS",
        "VLESS-ENC + Sudoku",
        "VLESS-REALITY",
    ] {
        assert!(!info.contains(required), "{required}");
    }
}

#[test]
fn vless_sudoku_cli_needs_no_switch_and_rejects_other_protocol_options() {
    for extra in [
        vec![],
        vec![
            "--sudoku-password",
            " password ",
            "--sudoku-ascii",
            "ascii",
            "--sudoku-padding-max",
            "10",
        ],
    ] {
        let cli =
            Cli::try_parse_from(["prs", "add", "vless-sudoku"].into_iter().chain(extra)).unwrap();
        let Some(Command::Add(args)) = cli.command else {
            panic!()
        };
        args.vless_enc.sudoku.validate_for(args.protocol).unwrap();
        let mask = args
            .vless_enc
            .sudoku
            .config_for(args.protocol)
            .unwrap()
            .unwrap();
        mask.validate().unwrap();
        if args.vless_enc.sudoku.password.is_some() {
            assert_eq!(mask.password, " password ");
            assert_eq!(mask.ascii, SudokuAscii::Ascii);
            assert_eq!((mask.padding_min, mask.padding_max), (0, 10));
        } else {
            assert_eq!(mask.password.len(), 24);
            assert_eq!(mask.ascii, SudokuAscii::PreferEntropy);
            assert_eq!((mask.padding_min, mask.padding_max), (0, 0));
        }
    }
}

#[test]
fn vless_sudoku_changes_preserve_plain_vless_and_require_mask() {
    let (mut server, mut profile) = sample();
    let inner = crate::yaml::to_value(&server).unwrap()["protocol"]["protocol"].clone();
    let before = client::stored_share_uri(&profile, None).unwrap();
    apply_profile_change(&mut server, &mut profile, ProfileChange::Port(24445)).unwrap();
    apply_profile_change(
        &mut server,
        &mut profile,
        ProfileChange::Sudoku(Some(SudokuConfig {
            password: "test-password".into(),
            ascii: SudokuAscii::PreferEntropy,
            padding_min: 5,
            padding_max: 20,
        })),
    )
    .unwrap();
    apply_profile_change(
        &mut server,
        &mut profile,
        ProfileChange::RegenerateSudokuPassword,
    )
    .unwrap();
    assert_ne!(before, client::stored_share_uri(&profile, None).unwrap());
    assert_eq!(
        crate::yaml::to_value(&server).unwrap()["protocol"]["protocol"],
        inner
    );
    ensure_servers_match_state(&[server.clone()], std::slice::from_ref(&profile)).unwrap();
    let original = serde_json::to_vec(&server).unwrap();
    assert!(apply_profile_change(&mut server, &mut profile, ProfileChange::Sudoku(None)).is_err());
    assert_eq!(serde_json::to_vec(&server).unwrap(), original);
    let before_regenerate = crate::yaml::to_value(&server).unwrap();
    apply_profile_change(
        &mut server,
        &mut profile,
        ProfileChange::RegenerateCredentials,
    )
    .unwrap();
    let regenerated = crate::yaml::to_value(&server).unwrap();
    assert_ne!(
        regenerated["protocol"]["password"],
        before_regenerate["protocol"]["password"]
    );
    assert_ne!(
        regenerated["protocol"]["protocol"]["user_id"],
        inner["user_id"]
    );
    assert!(regenerated["protocol"]["protocol"]
        .get("decryption")
        .is_none());
    ensure_servers_match_state(
        std::slice::from_ref(&server),
        std::slice::from_ref(&profile),
    )
    .unwrap();
    server.protocol = vless_enc_inner_mut(&mut server.protocol).clone();
    assert!(ensure_servers_match_state(&[server], &[profile]).is_err());
}

#[tokio::test]
async fn vless_sudoku_generated_yaml_passes_shoes_dry_run() {
    let Some(binary) = crate::shoes_e2e::shoes_binary(
        "config::vless_sudoku_tests::vless_sudoku_generated_yaml_passes_shoes_dry_run",
        &[
            crate::shoes_e2e::TEST_SHOES,
            crate::shoes_e2e::SHOES_E2E_BIN,
        ],
    ) else {
        return;
    };
    let (server, _) = sample();
    let dir = tempfile::tempdir().unwrap();
    let path = dir.path().join("sudoku.yaml");
    utils::atomic_write(
        &path,
        crate::yaml::to_string(&vec![server]).unwrap().as_bytes(),
        0o600,
    )
    .unwrap();
    validate_with_binary(&binary, &path).await.unwrap();
}

#[test]
fn vless_sudoku_state_fixture_roundtrips_and_keeps_legacy_bytes() {
    let fixture = include_str!("../../tests/fixtures/yaml/vless-sudoku/state.json");
    let state: ManagedState = serde_json::from_str(fixture).unwrap();
    let servers = load_servers(Path::new("tests/fixtures/yaml/vless-sudoku/config.yaml")).unwrap();
    ensure_servers_match_state(&servers, &state.profiles).unwrap();
    let dir = tempfile::tempdir().unwrap();
    let path = dir.path().join("state.json");
    save_state_to(&path, &state).unwrap();
    let written = fs::read_to_string(&path).unwrap();
    assert_eq!(written, fixture.trim_end());
    assert_eq!(
        serde_json::to_vec(&load_state_from(&path).unwrap()).unwrap(),
        serde_json::to_vec(&state).unwrap()
    );
    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;
        assert_eq!(
            fs::metadata(&path).unwrap().permissions().mode() & 0o777,
            0o600
        );
    }
    for old in [
        include_str!("../../tests/fixtures/yaml/compat/state.json"),
        include_str!("../../tests/fixtures/yaml/chain-v2/state.json"),
        include_str!("../../tests/fixtures/yaml/vless-xhttp-reality/compatible-state.json"),
    ] {
        let state: ManagedState = serde_json::from_str(old).unwrap();
        assert_eq!(serde_json::to_string_pretty(&state).unwrap() + "\n", old);
    }
    // Both extensions use absolute positions; interleaving must retain order.
    let xhttp: ManagedState = serde_json::from_str(include_str!(
        "../../tests/fixtures/yaml/vless-xhttp-reality/compatible-state.json"
    ))
    .unwrap();
    let (_, legacy) = tests::reality_server_and_profile(24443);
    let profiles = vec![
        state.profiles[0].clone(),
        xhttp.profiles[0].clone(),
        legacy.clone(),
        state.profiles[0].clone(),
        legacy,
        xhttp.profiles[0].clone(),
    ];
    let mixed = ManagedState {
        profiles,
        ..Default::default()
    };
    let value = serde_json::to_value(&mixed).unwrap();
    assert_eq!(value["profiles"].as_array().unwrap().len(), 2);
    let decoded: ManagedState = serde_json::from_value(value.clone()).unwrap();
    assert_eq!(
        serde_json::to_vec(&mixed.profiles).unwrap(),
        serde_json::to_vec(&decoded.profiles).unwrap()
    );
    for position in [0, 99] {
        let mut invalid = value.clone();
        invalid["sudoku_profiles"][1]["position"] = position.into();
        assert!(serde_json::from_value::<ManagedState>(invalid).is_err());
    }
    let mut invalid = value.clone();
    invalid["sudoku_profiles"][0]["profile"] = value["profiles"][0].clone();
    assert!(serde_json::from_value::<ManagedState>(invalid).is_err());
    let mut invalid = value;
    invalid["sudoku_profiles"][0]["position"] = 1.into();
    assert!(
        serde_json::from_value::<ManagedState>(invalid).is_err(),
        "cross-extension duplicate"
    );
}

#[test]
fn vless_sudoku_rejects_encryption_invalid_padding_and_mismatched_runtime() {
    let (server, profile) = sample();
    for field in ["decryption", "vision", "user_id"] {
        let mut value = serde_json::to_value(&server).unwrap();
        value["protocol"]["protocol"][field] = match field {
            "vision" => true.into(),
            "user_id" => Uuid::nil().to_string().into(),
            _ => "must-not-encrypt".into(),
        };
        let invalid = serde_json::from_value(value).unwrap();
        assert!(ensure_servers_match_state(&[invalid], std::slice::from_ref(&profile)).is_err());
    }
    let mut request = tests::request(profile.protocol(), "unused.yaml".into());
    for options in [
        GenerationOptions {
            vless_enc_vision: true,
            ..Default::default()
        },
        GenerationOptions {
            vless_enc_mode: VlessEncMode::Random,
            ..Default::default()
        },
        GenerationOptions {
            vless_enc_auth: VlessEncAuth::Mlkem768,
            ..Default::default()
        },
        GenerationOptions {
            sudoku: Some(SudokuConfig {
                padding_min: 20,
                padding_max: 10,
                ..SudokuConfig::generated()
            }),
            ..Default::default()
        },
    ] {
        request.options = options;
        assert!(validate_request(&request).is_err());
    }
    request.options = Default::default();
    let generated = presets::generate(&request, Path::new("."), Uuid::nil()).unwrap();
    let Credentials::VlessSudoku { sudoku, .. } = generated.credentials else {
        panic!()
    };
    assert_eq!(sudoku.password.len(), 24);
    assert_eq!(sudoku.ascii, SudokuAscii::PreferEntropy);
    assert_eq!((sudoku.padding_min, sudoku.padding_max), (0, 0));
    for protocol in ["vless-enc", "reality", "socks5"] {
        for extra in [
            vec!["--sudoku-password", "test"],
            vec!["--sudoku-ascii", "prefer-entropy"],
            vec!["--sudoku-padding-min", "0"],
            vec!["--sudoku-padding-max", "0"],
        ] {
            let cli =
                Cli::try_parse_from(["prs", "add", protocol].into_iter().chain(extra)).unwrap();
            let Some(Command::Add(args)) = cli.command else {
                panic!()
            };
            assert!(args.vless_enc.sudoku.validate_for(args.protocol).is_err());
        }
    }
}