Files
xop/tests/integration.rs
T
xop-botandClaude Code f7cff869b7 v0.4: SSH_ASKPASS injection + macOS test path portability
影响: 直连 ssh 现在能用 xop run --askpass=NAME -- ssh user@host,
密码经 mkdtemp 0700 临时目录的 0600 data + 0700 getpass.sh 注入,
既不进 argv 也不进 env, ps 干净。68 unit + 24 integration 全绿 (含
macOS /var/folders/.../T temp dir 兼容)。

改动:
- 新增 src/askpass.rs: mkdtemp(0700) + 0600 data + 0700 getpass.sh
  (cat "$XOP_ASKPASS_DATA"); AskpassHandle::Drop 跑 srm -m
  (fallback rm -rf); env_vars() 输出 SSH_ASKPASS +
  SSH_ASKPASS_REQUIRE=force + DISPLAY=:0 + XOP_ASKPASS_DATA
- 新增 --askpass=NAME flag (Args + Run subcommand)
- SecretRef::askpass: bool 标志 + askpass() ctor; ResolvedValue 镜像
- run_exec Phase 3.5: askpass refs 从 envp_resolved 切出来单独
  setup, 放在 audit spawn_event 之前 (setup 失败不留孤儿事件); stdout
  guard 看完整 resolved 集做兜底
- injector::plan() 移除 SSH_* 自动检测; InjectStrategy::Askpass/Fd
  变体删掉; askpass 改显式 opt-in (--askpass=NAME)
- Error::Io(String, String) 退出码 73, askpass setup/chmod/write 失败
- tests/integration.rs run_askpass_sets_ssh_env_vars: SSH_ASKPASS
  路径改 substring 匹配 (SSH_ASKPASS= + /xop-askpass- + /getpass.sh),
  兼容 Linux /tmp 与 macOS /var/folders/.../T (per-user, world-unreadable)
- AGENTS.md: v0.4 状态加 e2e 实测标注, 踩坑 #22 (vault key 名 ≠ 字面值)
- HANDOFF.md: 测试数 62→68 / 15→24, status line 加 e2e 实测标注,
  smoke 命令加 askpass 用法

设计: 沿用 v0.3 argv_placeholder 模式 (SecretRef 标志位 + run_exec
单 vault open); ssh 本身不读 env, 强制 SSH_ASKPASS_REQUIRE=force 让
ssh 必走 askpass 脚本; 不沿用 sshpass -e 的 env hack (那个不解决
ps 泄漏)。temp_dir 走 std::env::temp_dir() 不写死 /tmp, 因为 macOS
/var/folders/.../T 是 per-user + world-unreadable, 比 /tmp 更合适。

Co-Authored-By: Claude Code <[email protected]>
2026-10-07 14:05:11 +08:00

558 lines
17 KiB
Rust

//! Integration tests for the xop CLI (v0.2).
//!
//! Run with: `cargo test --test integration -- --test-threads=1`
//! (the --test-threads=1 is because some tests share HOME or env state)
//!
//! Tests that touch the OS auth gate (Touch ID / PAM) set
//! `XOP_AUTH_BYPASS=1` to skip it. Tests that need a real vault set
//! `XOP_VAULT_DIR` to a tempdir.
use assert_cmd::Command;
use predicates::prelude::*;
fn xop() -> Command {
Command::cargo_bin("xop").expect("binary built")
}
fn xop_bypass_auth() -> Command {
let mut c = xop();
c.env("XOP_AUTH_BYPASS", "1");
c
}
fn make_vault() -> tempfile::TempDir {
let tmp = tempfile::tempdir().unwrap();
// Set HOME so xop finds ~/.xop/key.db under our tempdir.
std::env::set_var("HOME", tmp.path());
// Pre-create the vault file by piping a non-interactive init via env var.
tmp
}
#[test]
fn help_shows_subcommands() {
xop()
.arg("--help")
.assert()
.success()
.stdout(predicate::str::contains("init"))
.stdout(predicate::str::contains("set"))
.stdout(predicate::str::contains("list"))
.stdout(predicate::str::contains("get"))
.stdout(predicate::str::contains("rm"))
.stdout(predicate::str::contains("Touch ID"));
}
#[test]
fn no_args_shows_banner() {
xop()
.assert()
.success()
.stdout(predicate::str::contains("xop"))
.stdout(predicate::str::contains("Quick start"));
}
#[test]
fn dry_run_prints_effective_policy() {
xop()
.args([
"--dry-run",
"--secret", "DB_PASS=db_pass",
"--allow-net=db.local:5432",
"--deny-net=*",
"--",
"echo", "hello",
])
.assert()
.success()
.stdout(predicate::str::contains("# xop dry-run"))
.stdout(predicate::str::contains("db_pass"))
.stdout(predicate::str::contains("db.local:5432"))
.stdout(predicate::str::contains("(dry-run: not executing)"));
}
#[test]
fn missing_command_exits_64() {
xop()
.args(["--dry-run"])
.assert()
.failure()
.code(64)
.stderr(predicate::str::contains("no command given"));
}
#[test]
fn bad_ref_format_exits_64() {
xop()
.args([
"--dry-run",
"--secret", "not_a_ref",
"--",
"true",
])
.assert()
.failure()
.code(64)
.stderr(predicate::str::contains("invalid ref"));
}
#[test]
fn unknown_scheme_rejected() {
// Old v0.1 op:// scheme must be rejected (we migrated to bare keys).
xop()
.args([
"--dry-run",
"--secret", "X=op://v/i/f",
"--",
"true",
])
.assert()
.failure()
.code(64)
.stderr(predicate::str::contains("invalid ref"));
}
#[test]
fn secrets_file_parses() {
let tmp = tempfile::NamedTempFile::new().unwrap();
std::fs::write(
tmp.path(),
r#"
# comment
DB_PASS="db_pass"
API_KEY='api_key'
"#,
)
.unwrap();
xop()
.args([
"--dry-run",
"--secrets-file", tmp.path().to_str().unwrap(),
"--",
"true",
])
.assert()
.success()
.stdout(predicate::str::contains("db_pass"))
.stdout(predicate::str::contains("api_key"));
}
#[test]
fn env_var_picks_up_xop_log_level() {
xop()
.env("RUST_LOG", "xop=debug")
.args(["--dry-run", "--", "true"])
.assert()
.success();
}
#[test]
fn init_creates_vault() {
// With `--features test-bypass`, `XOP_VAULT_PASSWORD` feeds the passphrase
// prompt via stdin (non-tty fallback), so init runs end-to-end.
let _vault = make_vault();
xop_bypass_auth()
.env("XOP_INIT_NONINTERACTIVE", "1")
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["init"])
.assert()
.success();
}
#[test]
fn run_masks_secret_in_child_stdout() {
// Full flow: init → set → `xop run` whose child ECHOES the injected
// secret. The stdout guard must replace the value with the partial mask
// `va****【xop禁止将密钥泄漏】` and never let the raw value through.
let vault_dir = make_vault();
// init
xop_bypass_auth()
.env("XOP_INIT_NONINTERACTIVE", "1")
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["init"])
.assert()
.success();
// set a known secret (value piped on stdin, non-TTY)
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["set", "LEAKY"])
.write_stdin("value12345\n")
.assert()
.success();
// run: child prints $LEAKY — must be masked
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args([
"run",
"--secret", "LEAKY=LEAKY",
"--",
"sh", "-c", "echo leaked: $LEAKY",
])
.assert()
.success()
.stdout(predicate::str::contains("va****【xop禁止将密钥泄漏】"))
.stdout(predicate::str::contains("value12345").not());
let _ = vault_dir;
}
#[test]
fn run_masks_argv_placeholder_value() {
// `%XOP_NAME%` argv substitution puts the value into the child's argv;
// when the child echoes it, the guard must still catch it.
make_vault();
xop_bypass_auth()
.env("XOP_INIT_NONINTERACTIVE", "1")
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["init"])
.assert()
.success();
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["set", "-f", "PH"])
.write_stdin("secretvalue\n")
.assert()
.success();
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["run", "--", "echo", "token=%XOP_PH%"])
.assert()
.success()
.stdout(predicate::str::contains("se****【xop禁止将密钥泄漏】"))
.stdout(predicate::str::contains("secretvalue").not());
}
#[test]
fn run_rejects_v0_xop_key_placeholder_with_migration_message() {
// v0.3 hard-cut: the v0.2 `xop://KEY` syntax is rejected with a clear
// migration message in `expand_xop_placeholders` BEFORE the vault opens,
// so this test doesn't even need a vault. We init one anyway for symmetry
// with the run_masks_* tests (HOME is already set by make_vault).
let _home = make_vault();
xop_bypass_auth()
.env("XOP_INIT_NONINTERACTIVE", "1")
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["init"])
.assert()
.success();
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["run", "--", "echo", "token=xop://PH"])
.assert()
.failure()
.code(64)
.stderr(predicate::str::contains("xop://KEY 占位符在 v0.3 移除"))
.stderr(predicate::str::contains("请改用 %XOP_KEY%"));
}
#[test]
fn keyring_enables_passphrase_free_unlock() {
// Issue #3: after `xop init` writes the 0600 keyring, later ops unlock
// with NO passphrase — even with XOP_VAULT_PASSWORD absent and stdin
// empty. (OS gate bypassed via XOP_AUTH_BYPASS as in all vault tests.)
let _home = make_vault();
xop_bypass_auth()
.env("XOP_INIT_NONINTERACTIVE", "1")
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["init"])
.assert()
.success();
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["set", "K"])
.write_stdin("val123\n")
.assert()
.success();
// Crucially: env_remove — no passphrase channel exists at all now.
xop_bypass_auth()
.env_remove("XOP_VAULT_PASSWORD")
.args(["run", "--secret", "V=K", "--", "sh", "-c", "echo got $V"])
.assert()
.success()
.stdout(predicate::str::contains("va****【xop禁止将密钥泄漏】"))
.stdout(predicate::str::contains("val123").not());
// And `xop key` status reports it active.
xop_bypass_auth()
.args(["key"])
.assert()
.success()
.stdout(predicate::str::contains("auto-unlock ACTIVE"));
}
#[test]
fn ssh_env_headless_still_unlocks_via_keyring() {
// Regression guard for the SSH redesign: SSH_* env vars set + NO pty
// (scp/ansible/agent-style `ssh host cmd`) → headless automation path →
// keyring silent unlock, no passphrase, no osascript call.
// XOP_AUTH_BYPASS deliberately NOT set — this exercises the real gate.
let _home = make_vault();
xop_bypass_auth()
.env("XOP_INIT_NONINTERACTIVE", "1")
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["init"])
.assert()
.success();
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["set", "K"])
.write_stdin("val123\n")
.assert()
.success();
xop()
.env_remove("XOP_AUTH_BYPASS")
.env("SSH_CONNECTION", "10.0.0.5 51234 10.0.0.1 22")
.env("SSH_TTY", "/dev/ttys003")
.env_remove("XOP_VAULT_PASSWORD")
.args(["list"])
.assert()
.success()
.stdout(predicate::str::contains("K"));
}
#[test]
fn get_unknown_key_exits_77() {
let _vault = make_vault();
// Vault doesn't exist → init first via direct file write below.
xop_bypass_auth()
.args(["get", "MISSING"])
.assert()
.failure()
.code(78); // VaultNotInitialized → 78 EX_CONFIG
}
#[test]
fn get_masks_value_by_default() {
// `xop get` is routinely driven by AI agents — the value must NEVER
// reach stdout in the clear. Default output is the partial mask;
// plaintext only via explicit -v (see get_dash_v_prints_plaintext).
let _home = make_vault();
xop_bypass_auth()
.env("XOP_INIT_NONINTERACTIVE", "1")
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["init"])
.assert()
.success();
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["set", "SHOW"])
.write_stdin("sup3rsecret\n")
.assert()
.success();
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["get", "SHOW"])
.assert()
.success()
.stdout(predicate::str::contains("su****【xop禁止将密钥泄漏】"))
.stdout(predicate::str::contains("sup3rsecret").not())
.stderr(predicate::str::contains("-v"));
}
#[test]
fn get_dash_v_prints_plaintext() {
// -v is the human visual-inspection escape hatch: plaintext on stdout,
// loud warning on stderr. Agents must not use this path.
let _home = make_vault();
xop_bypass_auth()
.env("XOP_INIT_NONINTERACTIVE", "1")
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["init"])
.assert()
.success();
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["set", "SHOW"])
.write_stdin("sup3rsecret\n")
.assert()
.success();
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["get", "SHOW", "-v"])
.assert()
.success()
.stdout(predicate::str::contains("sup3rsecret"))
.stdout(predicate::str::contains("【xop禁止将密钥泄漏】").not())
.stderr(predicate::str::contains("AI agent"));
}
#[test]
fn list_on_empty_vault() {
let _vault = make_vault();
xop_bypass_auth()
.args(["list"])
.assert()
.failure()
.code(78); // vault not initialized
}
// ─── v0.4 askpass tests ─────────────────────────────────────────────────────
// Init a vault with one secret. The returned TempDir MUST be bound (not
// dropped) by the caller so the vault directory survives past init — see
// `make_vault`'s pattern.
fn init_vault_with_secret(name: &str, value: &str) -> tempfile::TempDir {
let home = make_vault();
xop_bypass_auth()
.env("XOP_INIT_NONINTERACTIVE", "1")
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["init"])
.assert()
.success();
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["set", "-f", name])
.write_stdin(format!("{value}\n"))
.assert()
.success();
home
}
#[test]
fn run_askpass_sets_ssh_env_vars() {
let _home = init_vault_with_secret("PH", "askpasstest");
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args([
"run",
"--askpass=PH",
"--",
"sh", "-c",
"echo SSH_ASKPASS=$SSH_ASKPASS; echo REQ=$SSH_ASKPASS_REQUIRE; \
echo DISPLAY=$DISPLAY; echo DATA=$XOP_ASKPASS_DATA",
])
.assert()
.success()
// SSH_ASKPASS lands under std::env::temp_dir(): /tmp on Linux,
// /var/folders/.../T (per-user, world-unreadable) on macOS via $TMPDIR.
// Match the dynamic components rather than the full absolute prefix
// (trailing slash conventions on std::env::temp_dir() differ by OS).
.stdout(predicate::str::contains("SSH_ASKPASS="))
.stdout(predicate::str::contains("/xop-askpass-"))
.stdout(predicate::str::contains("/getpass.sh"))
.stdout(predicate::str::contains("REQ=force"))
.stdout(predicate::str::contains("DISPLAY=:0"))
.stdout(predicate::str::contains("DATA="))
.stdout(predicate::str::contains("/xop-askpass-"))
.stdout(predicate::str::contains("/data"))
.stdout(predicate::str::contains("askpasstest").not());
}
#[test]
fn run_askpass_script_outputs_value() {
// The helper script at $SSH_ASKPASS should output the vault value when
// invoked. To verify without triggering stdout-mask (which would redact
// the value), we capture the script's stdout into a shell variable and
// print only its length — the mask guard can't fire on a number.
let _home = init_vault_with_secret("PH", "askpasstest"); // 11 chars
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args([
"run",
"--askpass=PH",
"--",
"sh", "-c",
"out=$($SSH_ASKPASS); echo ${#out}",
])
.assert()
.success()
.stdout(predicate::str::contains("11"))
.stdout(predicate::str::contains("askpasstest").not());
}
#[test]
fn run_askpass_cleans_temp_dir_on_exit() {
let _home = init_vault_with_secret("PH", "cleanupvalue");
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args([
"run",
"--askpass=PH",
"--",
"sh", "-c", "true",
])
.assert()
.success();
// After xop run exits, /tmp/xop-askpass-* dirs created during the run
// must be gone (Drop impl runs `srm -m` or fallback `rm -rf`).
let remaining: Vec<_> = std::fs::read_dir(std::env::temp_dir())
.unwrap()
.filter_map(|e| e.ok())
.filter(|e| {
e.file_name().to_string_lossy().starts_with("xop-askpass-")
})
.collect();
assert!(
remaining.is_empty(),
"askpass temp dir should be cleaned up after exit; found: {:?}",
remaining.iter().map(|e| e.path()).collect::<Vec<_>>(),
);
}
#[test]
fn run_askpass_does_not_inject_value_as_env_var() {
// --askpass=PH must NOT also set $PH in the child's env — the value is
// reachable only via $SSH_ASKPASS. Verify by checking $PH is empty.
let _home = init_vault_with_secret("PH", "secretvalue");
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args([
"run",
"--askpass=PH",
"--",
"sh", "-c",
"if [ -n \"$PH\" ]; then echo LEAK; else echo OK; fi",
])
.assert()
.success()
.stdout(predicate::str::contains("OK"))
.stdout(predicate::str::contains("LEAK").not())
.stdout(predicate::str::contains("secretvalue").not());
}
#[test]
fn run_askpass_unknown_key_fails() {
let _home = init_vault_with_secret("PH", "x");
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args([
"run",
"--askpass=MISSING",
"--",
"sh", "-c", "true",
])
.assert()
.failure()
.code(77) // KeyNotFound
.stderr(predicate::str::contains("MISSING"));
}
#[test]
fn run_askpass_combined_with_secret_env_injection() {
// --askpass=SSH_PASS routes the password through SSH_ASKPASS; a separate
// --secret DB_PASS=db_pass still goes via env injection. Verify both
// paths work side by side.
let _home = init_vault_with_secret("SSH_PASS", "s3cret");
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args(["set", "-f", "DB_PASS"])
.write_stdin("dbpass123\n")
.assert()
.success();
xop_bypass_auth()
.env("XOP_VAULT_PASSWORD", "testpass")
.args([
"run",
"--askpass=SSH_PASS",
"--secret", "DB_PASS=DB_PASS",
"--",
"sh", "-c",
"echo DB=$DB_PASS; out=$($SSH_ASKPASS); echo AP_LEN=${#out}",
])
.assert()
.success()
// DB_PASS went via env injection → its value is in stdout, gets masked.
.stdout(predicate::str::contains("db****【xop禁止将密钥泄漏】"))
.stdout(predicate::str::contains("dbpass123").not())
// SSH_PASS via askpass → only length printed.
.stdout(predicate::str::contains("AP_LEN=6"))
.stdout(predicate::str::contains("s3cret").not());
}