Zusammenfassung

PEP 750 führte Template-Strings (T-Strings) als Verallgemeinerung von f-Strings ein und bot eine Möglichkeit, String-Interpolation in verschiedenen Kontexten sicher zu handhaben. Diese PEP schlägt vor, die Module subprocess und shlex zu erweitern, um T-Strings nativ zu unterstützen, was eine sicherere und ergonomischere Ausführung von Shell-Befehlen mit interpolierten Werten ermöglicht und als Referenzimplementierung für die T-String-Funktion zur Verbesserung der API-Ergonomie dient.

PEP Verschiebung

Während der Diskussionen über den ersten Entwurf der PEP wurde deutlich, dass T-Strings eine potenzielle Gelegenheit bieten, synthetische Bequemlichkeit auf dem Niveau von shell=True für komplexe Subprozessaufrufe zu bieten, ohne all die Sicherheits- und plattformübergreifenden Kompatibilitätsprobleme, die entstehen, wenn benutzergesteuerten Text der Zugriff auf eine vollständige System-Shell gewährt wird.

Zu diesem Zweck planen die PEP-Autoren nun, während der Beta-Phase von Python 3.14 (und darüber hinaus) an einer experimentellen T-String-basierten Bibliothek für Subprozessaufrufe zu arbeiten, bevor ein überarbeiteter Entwurf des Vorschlags für Python 3.15 vorbereitet wird.

Motivation

Trotz der Sicherheitsvorteile und der Flexibilität, die Template-Strings in PEP 750 bieten, fehlt ihnen eine konkrete Konsumentenimplementierung in der Standardbibliothek, die ihre praktische Anwendung demonstriert. Einer der überzeugendsten Anwendungsfälle für T-Strings ist die sicherere Ausführung von Shell-Befehlen, wie im zurückgezogenen PEP 501 vermerkt.

# Unsafe with f-strings:
os.system(f"echo {message_from_user}")

# Also unsafe with f-strings
subprocess.run(f"echo {message_from_user}", shell=True)

# Fails with f-strings
subprocess.run(f"echo {message_from_user}")

# Safe with t-strings and POSIX-compliant shell quoting:
subprocess.run(t"echo {message_from_user}", shell=True)

# Safe on all platforms with t-strings:
subprocess.run(t"echo {message_from_user}")

# Safe on all platforms without t-strings:
subprocess.run(["echo", str(message_from_user)])

Derzeit müssen Entwickler zwischen Bequemlichkeit (Verwendung von f-Strings mit potenziellen Sicherheitsrisiken) und Sicherheit (Verwendung von ausführlicheren, listenbasierten APIs) wählen. Durch die native Unterstützung von T-Strings für das Modul subprocess bieten wir eine Konsumentenreferenzimplementierung, die den Wert von T-Strings demonstriert und gleichzeitig ein häufiges Sicherheitsproblem angeht.

Begründung

Das Subprocess-Modul ist aus mehreren Gründen ein idealer Kandidat für die Unterstützung von T-Strings

• Befehlsinjektionsschwachstellen in Shell-Befehlen sind ein bekanntes Sicherheitsrisiko.
• Das Modul subprocess unterstützt bereits Befehlspezifikationen sowohl als Zeichenkette als auch als Liste.
• Es gibt eine natürliche Entsprechung zwischen T-Strings und korrekter Shell-Escaping, die sowohl Bequemlichkeit als auch Sicherheit bietet.
• Es dient als praktische Demonstration für T-Strings, die Entwickler sofort verstehen und schätzen können.

Durch die Erweiterung von `subprocess` zur nativen Verarbeitung von T-Strings erleichtern wir das Schreiben von sicherem Code, ohne die Bequemlichkeit zu opfern, die viele Entwickler zur Verwendung potenziell unsicherer f-Strings veranlasste.

Spezifikation

Diese PEP schlägt zwei Hauptzusätze zur Standardbibliothek vor

1. Eine neue Renderer-Funktion sh() im Modul shlex zur sicheren Konstruktion von Shell-Befehlen

2. Hinzufügen der T-String-Unterstützung zu den Kernfunktionen des Moduls subprocess,

   insbesondere subprocess.Popen, subprocess.run() und andere verwandte Funktionen, die ein Befehlsargument akzeptieren

os.system(shlex.sh(t"cat {myfile}"))

os.system("cat " + shlex.quote(myfile)))

from string.templatelib import Template, Interpolation

def sh(template: Template) -> str:
    parts: list[str] = []
    for item in template:
        if isinstance(item, Interpolation):
            # shlex.sh implementation, so shlex.quote can be used directly
            parts.append(quote(str(item.value)))
        else:
            parts.append(item)

    # shlex.sh implementation, so `join` references shlex.join
    return join(parts)

import shlex
# Safe POSIX-compliant shell command construction
command = shlex.sh(t"cat {filename}")
os.system(command)

subprocess.run(t"cat {myfile}", shell=True)

subprocess.run(shlex.sh(t"cat {myfile}"), shell=True)

subprocess.run(t"cat {myfile} --flag {value}")

subprocess.run(["cat", myfile, "--flag", value])

subprocess.run(shlex.split(f"cat {shlex.quote(myfile)} --flag {shlex.quote(value)}"))

from string.templatelib import Template

if isinstance(args, Template):
    import shlex
    if shell:
        args = shlex.sh(args)
    else:
        args = shlex.split(shlex.sh(args))

Abwärtskompatibilität

Diese Änderung ist vollständig abwärtskompatibel, da sie nur neue Funktionalitäten hinzufügt, ohne das bestehende Verhalten zu ändern. Das `subprocess`-Modul wird Zeichenketten und Listen weiterhin auf die gleiche Weise verarbeiten wie bisher.

Sicherheitsimplikationen

Diese PEP ist ausdrücklich darauf ausgelegt, die Sicherheit zu verbessern, indem sie eine sicherere Alternative zur Verwendung von f-Strings mit Shell-Befehlen bietet. Durch die automatische Anwendung einer geeigneten Escaping basierend auf dem Kontext (Shell oder Nicht-Shell) hilft sie, Befehlsinjektionsschwachstellen zu verhindern.

Es ist jedoch erwähnenswert, dass bei Verwendung von shell=True die Sicherheit auf POSIX-konforme Shells beschränkt ist. Auf Windows-Systemen, auf denen cmd.exe oder PowerShell als Shell verwendet werden können, reicht der von shlex.quote() bereitgestellte Escaping-Mechanismus nicht aus, um alle Formen der Befehlsinjektion zu verhindern.

Wie man das lehrt

Diese Funktion kann als natürliche Erweiterung von T-Strings vermittelt werden, die ihren praktischen Wert demonstriert

1. Das Problem der Befehlsinjektion einführen und warum f-Strings mit Shell-Befehlen gefährlich sind
2. Traditionelle Lösungen zeigen (listenbasierte Befehle, manuelles Escaping)
3. Den shlex.sh-Renderer für explizites Shell-Escaping vorstellen

   # Unsafe:
   os.system(f"cat {filename}")  # Potential command injection!
   
   # Safe using shlex.sh:
   os.system(shlex.sh(t"cat {filename}"))  # Explicitly escaping for shell
   

4. Die native T-String-Unterstützung des `subprocess`-Moduls einführen

   # Unsafe:
   subprocess.run(f"cat {filename}", shell=True)  # Potential command injection!
   
   # Safe but verbose:
   subprocess.run(["cat", filename])
   
   # Safe and readable with t-strings:
   subprocess.run(t"cat {filename}", shell=True)  # Automatically escapes filename
   subprocess.run(t"cat {filename}")  # Automatically converts to list form
   

Die Implementierung sollte sowohl der Dokumentation des `shlex`- als auch des `subprocess`-Moduls mit klaren Beispielen und Sicherheitshinweisen hinzugefügt werden.

$ cat > run_quoted.py
import sys, shlex, subprocess
subprocess.run(f"echo {shlex.quote(sys.argv[1])}", shell=True)
$ python3 run_quoted.py pwd
pwd
$ python3 run_quoted.py '; pwd'
; pwd
$ python3 run_quoted.py "'pwd'"
'pwd'

S:\> echo import sys, shlex, subprocess > run_quoted.py
S:\> echo subprocess.run(f"echo {shlex.quote(sys.argv[1])}", shell=True) >> run_quoted.py
S:\> type run_quoted.py
import sys, shlex, subprocess
subprocess.run(f"echo {shlex.quote(sys.argv[1])}", shell=True)
S:\> python3 run_quoted.py "echo OK"
'echo OK'
S:\> python3 run_quoted.py "'& echo Oh no!"
''"'"'
Oh no!'

Urheberrecht

Dieses Dokument wird in die Public Domain oder unter die CC0-1.0-Universal-Lizenz gestellt, je nachdem, welche Lizenz permissiver ist.