Stellen Sie sicher, dass unsicherer Code nicht versehentlich verwendet wird

Eine Funktion f()verwendet eval()(oder etwas so Gefährliches) Daten, die ich local_fileauf dem Computer erstellt und gespeichert habe, auf dem mein Programm ausgeführt wird:

import local_file

def f(str_to_eval):
    # code....
    # .... 
    eval(str_to_eval)    
    # ....
    # ....    
    return None


a = f(local_file.some_str)

f() ist sicher zu laufen, da die Zeichenfolgen, die ich ihm zur Verfügung stelle, meine eigenen sind.

Wenn ich mich jedoch jemals dazu entscheide, es für etwas Unsicheres (z. B. Benutzereingaben) zu verwenden, können furchtbare Fehler auftreten . Wenn das nicht local_filemehr lokal ist, entsteht eine Sicherheitsanfälligkeit, da ich dem Computer vertrauen muss, der auch diese Datei bereitstellt.

Wie soll ich sicherstellen, dass ich nie "vergesse", dass die Verwendung dieser Funktion unsicher ist (es sei denn, bestimmte Kriterien sind erfüllt)?

_{Hinweis: eval()ist gefährlich und kann normalerweise durch etwas Sicheres ersetzt werden.}

Definieren Sie einen Typ, um „sichere“ Eingaben zu dekorieren. Stellen Sie in Ihrer Funktion f()sicher, dass das Argument diesen Typ hat, oder geben Sie einen Fehler aus. Seien Sie schlau genug, um niemals eine Verknüpfung zu definieren def g(x): return f(SafeInput(x)).

Beispiel:

class SafeInput(object):
  def __init__(self, value):
    self._value = value

  def value(self):
    return self._value

def f(safe_string_to_eval):
  assert type(safe_string_to_eval) is SafeInput, "safe_string_to_eval must have type SafeInput, but was {}".format(type(safe_string_to_eval))
  ...
  eval(safe_string_to_eval.value())
  ...

a = f(SafeInput(local_file.some_str))

Dies kann zwar leicht umgangen werden, erschwert dies jedoch aus Versehen. Die Leute könnten eine solche drakonische Typprüfung kritisieren, aber sie würden den Punkt verfehlen. Da der SafeInputTyp nur ein Datentyp und keine objektorientierte Klasse ist, die in Unterklassen unterteilt werden könnte, ist die Überprüfung der Typidentität mit type(x) is SafeInputsicherer als die Überprüfung der Typkompatibilität mit isinstance(x, SafeInput). Da wir einen bestimmten Typ erzwingen möchten, ist es auch hier nicht zufriedenstellend, den expliziten Typ zu ignorieren und nur implizite Ententypisierung durchzuführen. Python hat ein Typsystem, also verwenden wir es, um mögliche Fehler zu erkennen!

Wie Joel einmal betont hat, lassen Sie falschen Code falsch aussehen (scrollen Sie nach unten zum Abschnitt "The Real Solution" oder lesen Sie ihn besser noch vollständig; es lohnt sich, auch wenn er Variablen anstelle von Funktionsnamen anspricht). Daher schlage ich demütig vor, Ihre Funktion in so etwas wie umzubenennen f_unsafe_for_external_use()- Sie werden höchstwahrscheinlich selbst ein Abkürzungsschema entwickeln.

Edit: Ich denke, Amons Vorschlag ist eine sehr gute, OO-basierte Variation des gleichen Themas :-)

Ergänzend zum Vorschlag von @amon können Sie hier auch das Strategiemuster sowie das Methodenobjektmuster kombinieren.

class AbstractFoobarizer(object):
    def handle_cond(self, foo, bar):
        """
        Handle the event or something.
        """
        raise NotImplementedError

    def run(self):
        # do some magic
        pass

Und dann eine "normale" Implementierung

class PrintingFoobarizer(AbstractFoobarizer):
    def handle_cond(self, foo, bar):
        print("Something went very well regarding {} and {}".format(foo, bar))

Und eine Admin-Input-Eval-Implementierung

class AdminControllableFoobarizer(AbstractFoobarizer):
    def handle_cond(self, foo, bar):
        # Look up code in database/config file/...
        code = get_code_from_settings()
        eval(code)

(Hinweis: Mit einem realen Beispiel kann ich möglicherweise ein besseres Beispiel geben.)