Test Case: rust-instruct-1400

  1use std::process::Command;  2​  3fn split_command_line(s: &str) -> (String, Vec<String>) {  4    let mut program = String::new();  5    let mut args = Vec::new();  6    let mut current = String::new();  7    let mut in_quote = false;  8    let mut first = true;  9​ 10    for ch in s.chars() { 11        if ch == '"' { 12            in_quote = !in_quote; 13            continue; 14        } 15        if ch == ' ' && !in_quote { 16            if !current.is_empty() { 17                if first { 18                    program = current; 19                    first = false; 20                } else { 21                    args.push(current); 22                } 23                current = String::new(); 24            } 25            continue; 26        } 27        current.push(ch); 28    } 29    if !current.is_empty() { 30        if first { 31            program = current; 32        } else { 33            args.push(current); 34        } 35    } 36    (program, args) 37} 38​ 39pub fn parse_command(cmd_line: &str, flavor: Option<&str>) -> Command { 40    let (program, args) = split_command_line(cmd_line); 41​ 42    match flavor { 43        Some("wasm") => { 44            let mut cmd = Command::new("wasmtime"); 45            cmd.arg(&program); 46            for a in &args { 47                cmd.arg(a); 48            } 49            cmd 50        } 51        _ => { 52            let lower = program.to_lowercase(); 53            if (lower.ends_with(".bat") || lower.ends_with(".cmd")) && cfg!(target_os = "windows") { 54                let mut cmd = Command::new("cmd"); 55                cmd.arg("/c").arg(&program); 56                for a in &args { 57                    cmd.arg(a); 58                } 59                cmd 60            } else { 61                let mut cmd = Command::new(&program); 62                for a in &args { 63                    cmd.arg(a); 64                } 65                cmd 66            } 67        } 68    } 69}

1. warningLine 61

   Potential for command injection if input is not sanitized.

  1use std::process::Command;  2​  3#[derive(Debug, Clone, PartialEq, Eq)]  4pub enum CommandFlavor {  5    Normal,  6    Cmd,  7    Wasm,  8}  9​ 10/// Create a `Command` from a command line string and optional flavor. 11/// 12/// This function parses the command line into the program name and arguments 13/// using shell-like quoting rules via `shlex`. It then constructs a `Command` 14/// based on the given flavor: 15/// 16/// - `Normal`: Executes the parsed program directly. 17/// - `Cmd`: Executes via `cmd /C "<command line>"`. This is intended for batch 18///   scripts or Windows-specific commands that rely on `cmd`’s built-in 19///   commands (e.g., `dir`, `copy`). The original command line string is 20///   passed as a single argument to avoid shell escaping issues. 21/// - `Wasm`: (Example) could execute via some WebAssembly runtime; here we 22///   just direct-execute the program, but you could add a prefix (e.g., 23///   `wasmtime run program`). For now, we treat it like `Normal`. 24/// 25/// # Panics 26/// 27/// Panics if the command line is empty after trimming, or if no program can be 28/// parsed (e.g., all tokens are options). In production code, you would return 29/// a `Result` instead. 30pub fn command_from_str(command_line: &str, flavor: Option<CommandFlavor>) -> Command { 31    let command_line = command_line.trim(); 32    assert!(!command_line.is_empty(), "command line must not be empty"); 33​ 34    let flavor = flavor.unwrap_or(CommandFlavor::Normal); 35​ 36    match flavor { 37        CommandFlavor::Normal | CommandFlavor::Wasm => { 38            // Parse the command line into tokens (shell-like splitting). 39            // shlex::split returns None if there's a quoting error. 40            let tokens = shlex::split(command_line) 41                .expect("invalid quoting in command line"); 42            // There must be at least a program name. 43            let program = tokens.first().expect("no program found in command line"); 44            let args = &tokens[1..]; 45            let mut cmd = Command::new(program); 46            cmd.args(args); 47            cmd 48        } 49        CommandFlavor::Cmd => { 50            // For cmd execution, we pass the full command line as a single 51            // argument to cmd /C. This avoids reinterpretation by the shell 52            // while still allowing cmd’s command parsing (which handles 53            // its own quoting). Note: This does not protect against all 54            // injection vectors — consider using an allowlist or avoiding 55            // cmd altogether if security is critical. 56            let mut cmd = Command::new("cmd"); 57            cmd.arg("/C"); 58            cmd.arg(command_line); // single argument: the whole command line 59            cmd 60        } 61    } 62}

1. warningLine 45

   Potential for command injection if input is not sanitized.