Implement regression test for the state of the signal handlers

[mrmonopoly-cyber]

As already discussed in the issue #1263 there is the need for a regression test for the SignalState feature.

[mrmonopoly-cyber]

I'm already looking at the test. If nobody is working on this i would like to take it.

[mrmonopoly-cyber]

I have a question to ask, if it's not a problem. To make my test i need to make a program which takes data from two different sources stdin and /dev/tty. I look into the API for the tests, in particular create::sudo_test::Command and i see the option use_tty which refers to --tty of docker. The problem is that by using this option the data source for stdin and tty is the same for both and this may create false negative in the future.

I wanted to ask if you have already encountered this problem and if you have already managed it. I looked in your tests but i found nothing related.

I have a solution which consists in moving all the problem inside of the container by creating quine. Right now i have a little code as POC:

Details

#[test]
fn signal_handlers_should_be_restored_before_execve() {
    let temp_bug_prog_path = "./bug_checker.rs";
    let prog = "
        use std::{fs, io};
    use std::io::{stdin, Read};
    fn main() -> io::Result<std::process::ExitCode> {
        let mut tty = fs::OpenOptions::new().read(true).open(\"/dev/tty\")?;
        let mut input = [0;10];
        let _ = stdin().read(&mut input)?;
        if input[0] as char != 'Y' {return Ok(std::process::ExitCode::FAILURE)}
        let _ = tty.read(&mut input)?;
        if input[0] as char != 'E' {return Ok(std::process::ExitCode::FAILURE)}
        Ok(std::process::ExitCode::SUCCESS)
    }";
    let bug_checker_bin = "bug_checker";
    let env = Env("ALL ALL=(ALL:ALL) NOPASSWD: ALL")
        .file(temp_bug_prog_path,TextFile(prog).chmod("644"))
        .build();

    let out = Command::new("rustc")
        .args([temp_bug_prog_path, "-o", bug_checker_bin])
        .output(&env);
    assert_eq!(out.status().success(), true);

    let child = Command::new("sudo")
        .args(["sudo", bug_checker_bin])
        .tty(true)
        .stdin("Y")
        .spawn(&env);

    //TODO: add tty input

    assert_eq!(child.wait().status().success(),true);
}

This program call rustc in compiling a program created on the fly and then uses it's ExitStatus to check if test passed. As wrote by the TODO the program misses the tty input which should be given by a pty. My idea is to expand the compiled program so that this program will fed the data to sudo through stdin and tty by being inside the container. I hope what i said is clear.

Anyway i didn't do it yet since it's a bit of work and a bit hacky. So i'm open for suggestion. If there are no better ideas i will do the quine.

[bjorn3]

Would it be possible to implement that using a shell script instead? You can use sh -c "some command && other command" to run that. Rustc is not available inside the container on FreeBSD.

[mrmonopoly-cyber]

the best solution i found with bash is to use except which is not present in the container. here an example:

Details

bug_sudo:main.rs:

use std::{fs, io};
use std::io::{stdin, Read};

fn main() -> io::Result<std::process::ExitCode> {
    let mut tty = fs::OpenOptions::new().read(true).open("/dev/tty")?;
    let mut input = [0;10];
    let _ = stdin().read(&mut input)?;
    println!("stdin: {}", input[0] as char);
    if input[0] as char != 'Y' {return Ok(std::process::ExitCode::FAILURE)}
    let r = tty.read(&mut input);
    println!("tty: {}", input[0] as char);
    match r{
        Ok(_) => if input[0] as char != 'E' {
            println!("failed: invalid char: {}", input[0] as char);
            return Ok(std::process::ExitCode::FAILURE)
        },
        Err(e) => {
            println!("failed err: {}", e);
            return Ok(std::process::ExitCode::FAILURE)
        },
    };
    println!("success");
    Ok(std::process::ExitCode::SUCCESS)
}

expect -c '
spawn bash -c "echo 'Y' | ./bug_sudo"
send "E\r"
expect eof
'

spawn bash -c echo Y | ./bug_sudo
E
stdin: Y
tty: E
success

Regarding Rust, the program could be written in C, there is no need to use Rust for this.

[squell]

#1263 (comment)