Le funzioni popen (e simili) di Python sono influenzate da Shellshock?

Qualsiasi programma che, ad un certo punto, chiama bash è interessato. In particolare la funzione os.system è vulnerabile se il sistema ha bash come /bin/sh , quindi anche qualsiasi programma che lo chiama (o qualche equivalente) è vulnerabile.

Le funzioni popen possono essere vulnerabili, a seconda degli argomenti passati. Citando dalla documentazione:

Also, for each of these variants, on Unix, cmd may be a sequence, in which case arguments will be passed directly to the program without shell intervention (as with os.spawnv()). If cmd is a string it will be passed to the shell (as with os.system()).

a mio avviso questo significa che chiamate come:

os.popenx(['executable', 'some', 'arguments'])

sono sicuri perché nessuna shell è invocata, mentre i comandi del modulo:

os.popenx('executable some argument')

sono vulnerabili perché verrà usata una shell per interpretare la stringa come una linea di comando.

Si noti inoltre che le funzioni di tutte popen sono deprecate da python2.6 e avrebbero dovuto essere evitate da allora. Il modulo subprocess fornisce un'interfaccia molto migliore per l'avvio di sottoprocessi, che per impostazione predefinita è shellshock sicuro. Se non passi l'argomento shell=True il tuo programma non avvierà le subshell e quindi non sarà influenzato da shellshock.

Per utilizzare in modo sicuro subprocess dovresti evitare di usare l'argomento shell=True il più possibile (questo era vero anche prima della scoperta di shellshock ed è già ben documentato come un pericolo per la sicurezza comunque).

In particolare, se vuoi semplicemente lanciare un eseguibile usa subprocess.call :

subprocess.call(['executable name', 'arg1', '--opt1', 'opt-arg', ...])

se non vuoi scrivere manualmente l'elenco di stringhe puoi fare affidamento sul modulo shlex :

subprocess.call(shlex.split('executable-name arg1 "quoted arguments are correctly handled" etc'))

Se vuoi recuperare l'output del comando usa invece check_output di call .

Se vuoi eseguire una pipeline di comandi come cmd1 | cmd2 | cmd3 puoi comunque evitare di avviare una shell:

cmd1 = subprocess.Popen(cmd1_command_line, stdout=subprocess.PIPE)
cmd2 = subprocess.Popen(cmd2_command_line, stdin=cmd1.stdout, stdout=subprocess.PIPE)
cmd3 = subprocess.Popen(cmd3_command_line, stdin=cmd2.stdout, stdout=subprocess.PIPE)

Usa shell=True solo se strettamente necessario, e in tal caso considera di passare esplicitamente l'ambiente alla shell usando l'argomento env .

Sì, il popen è influenzato da ShellShock. Tuttavia, non ho un elenco completo da fornire - qualsiasi cosa che sia supportata da una chiamata a / bin / bash (come una chiamata a / bin / sh che collega a / bin / bash - che è assunto nella citazione seguente ) è vulnerabile.

A range of web apps written in PHP, Python, C++ or Java could be vulnerable if they use calls to functions such as popen() or system(), as these are backed by calls to /bin/sh -c in turn, Zalewski notes.

link

Spero che questo ti fornisca una risposta intermedia sufficiente alla tua domanda.