影响: 直连 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]>
558 lines
17 KiB
Rust
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());
|
|
} |