In this lesson, you will learn how to leverage Python’s subprocess module to orchestrate external system commands while strictly isolating them from shell injection vulnerabilities.
The Pitfall of Shell Execution
When automating tasks, it is tempting to use os.system() or subprocess.run(..., shell=True). These methods pass your string directly to the system shell (like /bin/sh or cmd.exe). If that string contains unsanitized user input, an attacker can manipulate the command, potentially leading to unauthorized filesystem access or arbitrary code execution. To maintain security, you must treat external commands as lists of arguments rather than executable strings.
Safe Execution with subprocess.run
The subprocess module allows you to bypass the shell entirely. By providing the command and its arguments as a list of strings (["cmd", "arg1", "arg2"]), the OS executes the binary directly. This prevents the shell from interpreting special characters like ;, |, or & that could be used for malicious purposes.
To manage I/O streams securely, we use the capture_output=True parameter. This prevents output from leaking to the console unexpectedly and allows your application to handle or log the results programmatically.
import subprocess
def run_backup(target_dir: str):
# Pass arguments as a list, never a single interpolated string
command = ["tar", "-czf", "backup.tar.gz", target_dir]
try:
result = subprocess.run(
command,
capture_output=True,
text=True,
check=True
)
print("Backup successful:", result.stdout)
except subprocess.CalledProcessError as e:
print(f"Error during backup: {e.stderr}")
Best Practices for Robustness
- Never use
shell=True: It creates an unnecessary security boundary vulnerability. - Use absolute paths: If possible, define the full path to the executable (e.g.,
/usr/bin/tar) to prevent "path hijacking," where a malicious user modifies thePATHenvironment variable to point to a fake binary. - Explicitly handle errors: Always use
check=Trueto raise aCalledProcessErrorif the command fails, allowing your established logging strategies to capture the specific exit code and standard error output.
Key Takeaway: Always execute external commands using a list of arguments to bypass the shell, ensuring that user-provided data remains treated as literal input rather than executable logic.