Assurez-vous que le code dangereux n'est pas utilisé accidentellement

Une fonction f()utilise eval()(ou quelque chose de dangereux) avec des données que j'ai créées et stockées local_filesur la machine exécutant mon programme:

import local_file

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


a = f(local_file.some_str)

f() est sûr à exécuter car les chaînes que je lui fournis sont les miennes.

Cependant, si jamais je décidais de l'utiliser pour quelque chose de dangereux (par exemple, une entrée utilisateur), les choses pourraient mal tourner . De plus, si l' local_filearrêt cesse d'être local, cela créerait une vulnérabilité, car je devrais également faire confiance à la machine qui fournit ce fichier.

Comment dois-je m'assurer de ne jamais "oublier" que cette fonction n'est pas sûre à utiliser (sauf si des critères spécifiques sont remplis)?

_{Remarque: eval()est dangereux et peut généralement être remplacé par quelque chose de sûr.}

Définissez un type pour décorer les entrées «sûres». Dans votre fonction f(), assurez-vous que l'argument a ce type ou renvoyez une erreur. Soyez assez intelligent pour ne jamais définir de raccourci def g(x): return f(SafeInput(x)).

Exemple:

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))

Bien que cela puisse être facilement contourné, il est plus difficile de le faire par accident. Les gens pourraient critiquer un contrôle de type aussi draconien, mais ils manqueraient le point. Étant donné que le SafeInputtype n'est qu'un type de données et non une classe orientée objet pouvant être sous-classée, la vérification de l'identité du type avec type(x) is SafeInputest plus sûre que la vérification de la compatibilité du type avec isinstance(x, SafeInput). Étant donné que nous voulons appliquer un type spécifique, ignorer le type explicite et simplement effectuer un typage de canard implicite n'est pas non plus satisfaisant ici. Python a un système de type, alors utilisons-le pour détecter d'éventuelles erreurs!

Comme Joel l'a souligné une fois, faites en sorte que le mauvais code semble incorrect ( faites défiler jusqu'à la section "La vraie solution", ou mieux encore lisez-le complètement; cela en vaut la peine, même s'il s'adresse à des variables au lieu de noms de fonctions). Je suggère donc humblement de renommer votre fonction en quelque chose comme f_unsafe_for_external_use()- vous trouverez très probablement un schéma d'abréviation vous-même.

Edit: Je pense que la suggestion d'Amon est une très bonne variation basée sur OO sur le même thème :-)

En complément de la suggestion de @amon, vous pouvez également penser à combiner le modèle de stratégie ici, ainsi que le modèle d'objet de méthode.

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

    def run(self):
        # do some magic
        pass

Et puis une implémentation «normale»

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

Et une implémentation admin-input-eval

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

(Remarque: avec un exemple réel, je pourrais peut-être donner un meilleur exemple).