Évaluer les expressions de manière dynamique – Real Python

Le premier argument: expression

Le premier argument pour eval () est appelé expression. C’est un argument obligatoire qui basé sur une chaîne ou basé sur le code compilé entrée à la fonction. Quand vous appelez eval (), le contenu de expression est évalué comme une expression Python. Consultez les exemples suivants qui utilisent une entrée basée sur des chaînes:

>>> eval("2 ** 8")
256
>>> eval("1024 + 1024")
2048
>>> eval("somme([8, 16, 32]) ")
56
>>> X = 100
>>> eval("x * 2")
200

Quand vous appelez eval () avec une chaîne en argument, la fonction renvoie la valeur résultant de l'évaluation de la chaîne d'entrée. Par défaut, eval () a accès à des noms globaux comme X dans l'exemple ci-dessus.

Pour évaluer une chaîne expression, Python eval () exécute les étapes suivantes:

1. Analyser expression
2. Compiler le bytecode
3. Évaluer comme une expression Python
4. Revenir le résultat de l'évaluation

Le nom expression pour le premier argument eval () souligne que la fonction ne fonctionne qu'avec des expressions et non avec des instructions composées. La documentation Python définit expression comme suit:

expression

Un morceau de syntaxe qui peut être évalué à une certaine valeur. En d'autres termes, une expression est une accumulation d'éléments d'expression comme des littéraux, des noms, des accès aux attributs, des opérateurs ou des appels de fonction qui renvoient tous une valeur. Contrairement à de nombreux autres langages, toutes les constructions de langage ne sont pas des expressions. Il existe également des instructions qui ne peuvent pas être utilisées comme expressions, telles que tandis que. Les affectations sont également des instructions et non des expressions. (La source)

D'un autre côté, un Python déclaration a la définition suivante:

déclaration

Une instruction fait partie d'une suite (un «bloc» de code). Une instruction est soit une expression, soit l'une de plusieurs constructions avec un mot-clé, comme si, tandis que ou pour. (La source)

Si vous essayez de passer une instruction composée à eval (), vous obtiendrez un Erreur de syntaxe. Jetez un œil à l'exemple suivant dans lequel vous essayez d'exécuter un si instruction utilisant eval ():

>>> X = 100
>>> eval("si x: print (x)")
  Fichier "", ligne 1
    si X: impression(X)
    ^
Erreur de syntaxe: Syntaxe invalide

Si vous essayez d'évaluer une instruction composée à l'aide de Python eval (), vous obtiendrez un Erreur de syntaxe comme dans le traceback ci-dessus. C'est parce que eval () accepte uniquement les expressions. Toute autre déclaration, telle que si, pour, tandis que, importation, def, ou classe, générera une erreur.

Les opérations d'affectation ne sont pas autorisées avec eval () Soit:

>>> eval("pi = 3,1416")
  Fichier "", ligne 1
    pi = 3.1416
       ^
Erreur de syntaxe: Syntaxe invalide

Si vous essayez de passer une opération d'affectation en tant qu'argument à Python eval (), vous obtiendrez un Erreur de syntaxe. Les opérations d'affectation sont des instructions plutôt que des expressions, et les instructions ne sont pas autorisées avec eval ().

Vous obtiendrez également un Erreur de syntaxe chaque fois que l'analyseur ne comprend pas l'expression d'entrée. Jetez un œil à l'exemple suivant dans lequel vous essayez d'évaluer une expression qui viole la syntaxe Python:

>>> # Expression incomplète
>>> eval("5 + 7 *")
  Fichier "", ligne 1
    5 + 7 *
          ^
Erreur de syntaxe: EOF inattendu lors de l'analyse

Vous ne pouvez pas transmettre une expression à eval () qui viole la syntaxe Python. Dans l'exemple ci-dessus, vous essayez d'évaluer une expression incomplète ("5 + 7 *") et obtenez un Erreur de syntaxe car l'analyseur ne comprend pas la syntaxe de l'expression.

Vous pouvez également transmettre des objets de code compilés à Python eval (). Pour compiler le code que vous allez transmettre eval (), vous pouvez utiliser compiler(). Il s'agit d'une fonction intégrée qui peut compiler une chaîne d'entrée dans un objet de code ou un objet AST afin que vous puissiez l'évaluer avec eval ().

Les détails de l'utilisation compiler() dépassent le cadre de ce didacticiel, mais voici un aperçu de ses trois premiers arguments requis:

1. la source contient le code source que vous souhaitez compiler. Cet argument accepte les chaînes normales, les chaînes d'octets et les objets AST.
2. nom de fichier donne le fichier à partir duquel le code a été lu. Si vous allez utiliser une entrée basée sur une chaîne, la valeur de cet argument doit être "".
3. mode spécifie le type de code compilé que vous souhaitez obtenir. Si vous souhaitez traiter le code compilé avec eval (), cet argument doit être défini sur "eval".

Vous pouvez utiliser compiler() pour fournir des objets de code à eval () au lieu de chaînes normales. Découvrez les exemples suivants:

>>> # Opérations arithmétiques
>>> code = compiler("5 + 4", "", "eval")
>>> eval(code)
9
>>> code = compiler("(5 + 7) * 2", "", "eval")
>>> eval(code)
24
>>> importation math
>>> # Volume d'une sphère
>>> code = compiler("4/3 * math.pi * math.pow (25, 3)", "", "eval")
>>> eval(code)
65449.84694978735

Si tu utilises compiler() pour compiler les expressions que vous allez transmettre à eval (), puis eval () passe par les étapes suivantes:

1. Évaluer le code compilé
2. Revenir le résultat de l'évaluation

Si vous appelez Python eval () à l'aide d'une entrée basée sur le code compilé, la fonction effectue ensuite l'étape d'évaluation et renvoie immédiatement le résultat. Cela peut être utile lorsque vous devez évaluer plusieurs fois la même expression. Dans ce cas, il est préférable de précompiler l'expression et de réutiliser le bytecode résultant lors des appels suivants à eval ().

Si vous compilez au préalable l'expression d'entrée, les appels successifs à eval () s'exécutera plus rapidement car vous ne répéterez pas analyse et compilation pas. Les répétitions inutiles peuvent entraîner des temps CPU élevés et une consommation de mémoire excessive si vous évaluez des expressions complexes.

Le deuxième argument: globals

Le deuxième argument de eval () est appelé globals. Il est facultatif et contient un dictionnaire qui fournit un espace de noms global pour eval (). Avec globals, tu peux dire eval () quels noms globaux utiliser lors de l'évaluation expression.

Les noms globaux sont tous les noms disponibles dans votre portée ou espace de noms global actuel. Vous pouvez y accéder de n'importe où dans votre code.

Tous les noms passés à globals dans un dictionnaire sera disponible pour eval () au moment de l'exécution. Consultez l'exemple suivant, qui montre comment utiliser un dictionnaire personnalisé pour fournir un espace de noms global à eval ():

>>> X = 100  # Une variable globale
>>> eval("x + 100", "X": X)
200
>>> y = 200  # Une autre variable globale
>>> eval("x + y", "X": X)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
  
  
  
  Fichier "", ligne 1, dans 
NameError: le nom «y» n'est pas défini

Si vous fournissez un dictionnaire personnalisé au globals argument de eval (), puis eval () prendra uniquement ces noms comme globaux. Les noms globaux définis en dehors de ce dictionnaire personnalisé ne seront pas accessibles de l'intérieur eval (). C’est pourquoi Python soulève un NameError lorsque vous essayez d'accéder y dans le code ci-dessus: Le dictionnaire est passé à globals n'inclut pas y.

Vous pouvez insérer des noms dans globals en les répertoriant dans votre dictionnaire, puis ces noms seront disponibles pendant le processus d'évaluation. Par exemple, si vous insérez y dans globals, puis l'évaluation de "x + y" dans l'exemple ci-dessus fonctionnera comme prévu:

>>> eval("x + y", "X": X, "y": y)
300

Depuis que vous ajoutez y à votre convenance globals dictionnaire, l’évaluation des "x + y" réussit et vous obtenez la valeur de retour attendue de 300.

Vous pouvez également fournir des noms qui n'existent pas dans votre portée globale actuelle. Pour que cela fonctionne, vous devez fournir une valeur concrète pour chaque nom. eval () interprétera ces noms comme des noms globaux lors de l'exécution:

>>> eval("x + y + z", "X": X, "y": y, "z": 300)
600
>>> z
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
NameError: le nom 'z' n'est pas défini

Même si z n'est pas défini dans votre portée globale actuelle, la variable est présente dans globals avec une valeur de 300. Dans ce cas, eval () a accès à z comme s'il s'agissait d'une variable globale.

Le mécanisme derrière globals est assez flexible. Vous pouvez transmettre n'importe quelle variable visible (globale, locale ou non locale) à globals. Vous pouvez également transmettre des paires clé-valeur personnalisées comme "z": 300 dans l'exemple ci-dessus. eval () les traitera tous comme des variables globales.

Un point important concernant globals est que si vous lui fournissez un dictionnaire personnalisé qui ne contient pas de valeur pour la clé "__builtins__", puis une référence au dictionnaire de intégrés sera automatiquement inséré sous "__builtins__" avant expression obtient analysé. Cela garantit que eval () aura un accès complet à tous les noms intégrés de Python lors de l'évaluation expression.

Les exemples suivants montrent que même si vous fournissez un dictionnaire vide à globals, l'appel à eval () aura toujours accès aux noms intégrés de Python:

>>> eval("somme([2, 2, 2]) ", )
6
>>> eval("min ([1, 2, 3]) ", )
1
>>> eval("pow (10, 2)", )
100

Dans le code ci-dessus, vous fournissez un dictionnaire vide () à globals. Étant donné que ce dictionnaire ne contient pas de clé appelée "__builtins__", Python en insère automatiquement un avec une référence aux noms intégrés. Par ici, eval () a un accès complet à tous les noms intégrés de Python lors de son analyse expression.

Si vous appelez eval () sans passer un dictionnaire personnalisé à globals, l'argument sera par défaut le dictionnaire renvoyé par globaux () dans l'environnement où eval () est appelé:

>>> X = 100  # Une variable globale
>>> y = 200  # Une autre variable globale
>>> eval("x + y")  # Accéder aux deux variables globales
300

Quand vous appelez eval () sans fournir un globals , la fonction évalue expression en utilisant le dictionnaire renvoyé par globaux () comme son espace de noms global. Ainsi, dans l'exemple ci-dessus, vous pouvez accéder librement X et y car ce sont des variables globales incluses dans votre étendue globale actuelle.

Le troisième argument: des locaux

Python eval () prend un troisième argument appelé des locaux. Ceci est un autre argument facultatif qui contient un dictionnaire. Dans ce cas, le dictionnaire contient les variables qui eval () utilise comme noms locaux lors de l'évaluation expression.

Les noms locaux sont les noms (variables, fonctions, classes, etc.) que vous définissez dans une fonction donnée. Les noms locaux ne sont visibles que depuis l'intérieur de la fonction englobante. Vous définissez ces types de noms lorsque vous écrivez une fonction.

Depuis eval () est déjà écrit, vous ne pouvez pas ajouter de noms locaux à son code ou à sa portée locale. Cependant, vous pouvez transmettre un dictionnaire à des locaux, et eval () traitera ces noms comme des noms locaux:

>>> eval("x + 100", , "X": 100)
200
>>> eval("x + y", , "X": 100)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
  
  
  
  Fichier "", ligne 1, dans 
NameError: le nom «y» n'est pas défini

Le deuxième dictionnaire du premier appel à eval () détient la variable X. Cette variable est interprétée par eval () comme variable locale. En d'autres termes, il est considéré comme une variable définie dans le corps de eval ().

Vous pouvez utiliser X dans expression, et eval () y aura accès. En revanche, si vous essayez d'utiliser y, vous obtiendrez un NameError parce que y n’est défini ni dans le globals espace de noms ou des locaux espace de noms.

Comme avec globals, vous pouvez transmettre n'importe quelle variable visible (globale, locale ou non locale) à des locaux. Vous pouvez également transmettre des paires clé-valeur personnalisées comme "x": 100 dans l'exemple ci-dessus. eval () les traitera tous comme des variables locales.

Notez que pour fournir un dictionnaire à des locaux, vous devez d'abord fournir un dictionnaire à globals. Il n'est pas possible d'utiliser des arguments de mots clés avec eval ():

>>> eval("x + 100", des locaux="X": 100)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
Erreur-type: eval () ne prend aucun argument de mot clé

Si vous essayez d'utiliser des arguments de mots clés lors de l'appel eval (), vous obtiendrez un Erreur-type expliquant que eval () ne prend aucun argument de mot clé. Donc, vous devez fournir un globals dictionnaire avant de pouvoir fournir un des locaux dictionnaire.

Si vous ne transmettez pas de dictionnaire à des locaux, puis par défaut, le dictionnaire est passé à globals. Voici un exemple dans lequel vous passez un dictionnaire vide à globals et rien à des locaux:

>>> X = 100
>>> eval("x + 100", )
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
  
  
  
  Fichier "", ligne 1, dans 
NameError: le nom 'x' n'est pas défini

Étant donné que vous ne fournissez pas de dictionnaire personnalisé à des locaux, l'argument par défaut est le dictionnaire passé à globals. Dans ce cas, eval () n'a pas accès à X parce que globals contient un dictionnaire vide.

La principale différence pratique entre globals et des locaux est que Python insérera automatiquement un "__builtins__" clé en globals si cette clé n'existe pas déjà. Cela se produit, que vous fournissiez ou non un dictionnaire personnalisé à globals. En revanche, si vous fournissez un dictionnaire personnalisé à des locaux, ce dictionnaire restera inchangé pendant l'exécution de eval ().

Expressions booléennes

Expressions booléennes sont des expressions Python qui renvoient une valeur de vérité (Vrai ou Faux) lorsque l'interprète les évalue. Ils sont couramment utilisés dans si pour vérifier si une condition est vraie ou fausse. Étant donné que les expressions booléennes ne sont pas des instructions composées, vous pouvez utiliser eval () pour les évaluer:

>>> X = 100
>>> y = 100
>>> eval("x! = y")
Faux
>>> eval("X < 200 and y > 100 ")
Faux
>>> eval("x est y")
Vrai
>>> eval("x in 50, 100, 150, 200")
Vrai

Vous pouvez utiliser eval () avec des expressions booléennes qui utilisent l'un des opérateurs Python suivants:

Dans tous les cas, la fonction renvoie la valeur de vérité de l'expression que vous évaluez.

Maintenant, vous pensez peut-être, pourquoi devrais-je utiliser eval () au lieu d'utiliser l'expression booléenne directement? Supposons que vous ayez besoin d'implémenter une instruction conditionnelle, mais que vous souhaitez modifier la condition à la volée:

>>> def func(une, b, état):
...     si eval(état):
...         revenir une + b
...     revenir une - b
...
>>> func(2, 4, "a> b")
-2
>>> func(2, 4, "a <b")
6
>>> func(2, 2, "a is b")
4

À l'intérieur func (), tu utilises eval () pour évaluer le état et retourner soit a + b ou un B selon le résultat de l'évaluation. Vous utilisez seulement quelques conditions différentes dans l'exemple ci-dessus, mais vous pouvez utiliser n'importe quel nombre d'autres à condition que vous respectiez les noms une et b que vous avez défini dans func ().

Imaginez maintenant comment vous implémenteriez quelque chose comme ça sans utiliser Python. eval (). Cela prendrait-il moins de code et de temps? En aucune façon!

Expressions mathématiques

Un cas d'utilisation courant de Python eval () est d'évaluer les expressions mathématiques à partir d'une entrée basée sur une chaîne. Par exemple, si vous souhaitez créer une calculatrice Python, vous pouvez utiliser eval () pour évaluer l'entrée de l'utilisateur et renvoyer le résultat des calculs.

Les exemples suivants montrent comment vous pouvez utiliser eval () de même que math pour effectuer des opérations mathématiques:

>>> # Opérations arithmétiques
>>> eval("5 + 7")
12
>>> eval("5 * 7")
35
>>> eval("5 ** 7")
78125
>>> eval("(5 + 7) / 2")
6.0
>>> importation math
>>> # Aire d'un cercle
>>> eval("math.pi * pow (25, 2)")
1963.4954084936207
>>> # Volume d'une sphère
>>> eval("4/3 * math.pi * math.pow (25, 3)")
65449.84694978735
>>> # Hypoténuse d'un triangle rectangle
>>> eval("math.sqrt (math.pow (10, 2) + math.pow (15, 2))")
18.027756377319946

Lorsque vous utilisez eval () pour évaluer les expressions mathématiques, vous pouvez passer des expressions de tout type ou de toute complexité. eval () les analysera, les évaluera et, si tout va bien, vous donnera le résultat attendu.

Expressions à usage général

Jusqu'à présent, vous avez appris à utiliser eval () avec des expressions booléennes et mathématiques. Cependant, vous pouvez utiliser eval () avec des expressions Python plus complexes qui intègrent des appels de fonction, la création d'objets, l'accès aux attributs, les compréhensions, etc.

Par exemple, vous pouvez appeler une fonction intégrée ou une fonction que vous avez importée avec un module standard ou tiers:

>>> # Exécutez la commande echo
>>> importation sous-processus
>>> eval("subprocess.getoutput ('echo Hello, World')")
'Bonjour le monde'
>>> # Lancez Firefox (si disponible)
>>> eval("subprocess.getoutput ('firefox')")
''

Dans cet exemple, vous utilisez Python eval () pour exécuter quelques commandes système. Comme vous pouvez l’imaginer, vous pouvez tonne de choses utiles avec cette fonctionnalité. cependant, eval () peut également vous exposer à de sérieux risques de sécurité, comme autoriser un utilisateur malveillant à exécuter des commandes système ou tout morceau de code arbitraire sur votre machine.

Dans la section suivante, vous examinerez les moyens de résoudre certains des risques de sécurité associés à eval ().

Restreindre globals et des locaux

Vous pouvez restreindre l'environnement d'exécution de eval () en passant des dictionnaires personnalisés au globals et des locaux arguments. Par exemple, vous pouvez transmettre des dictionnaires vides aux deux arguments pour empêcher eval () d'accéder aux noms dans la portée ou l'espace de noms actuel de l'appelant:

>>> # Évitez l'accès aux noms dans la portée actuelle de l'appelant
>>> X = 100
>>> eval("x * 5", , )
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
  
  
  
  Fichier "", ligne 1, dans 
NameError: le nom 'x' n'est pas défini

Si vous passez des dictionnaires vides () à globals et des locaux, puis eval () ne trouvera pas le nom X dans son espace de noms global ou son espace de noms local lors de l'évaluation de la chaîne "x * 5". Par conséquent, eval () jettera un NameError.

Malheureusement, restreindre la globals et des locaux de tels arguments n’éliminent pas tous les risques de sécurité associés à l’utilisation de Python eval (), car vous pouvez toujours accéder à tous les noms intégrés de Python.

Restriction de l'utilisation des noms intégrés

Comme vous l’avez vu précédemment, Python eval () insère automatiquement une référence au dictionnaire de intégrés dans globals avant d'analyser expression. Un utilisateur malveillant pourrait exploiter ce comportement en utilisant la fonction intégrée __importation__() pour accéder à la bibliothèque standard et à tout module tiers que vous avez installé sur votre système.

Les exemples suivants montrent que vous pouvez utiliser n'importe quelle fonction intégrée et n'importe quel module standard comme math ou sous-processus même après avoir restreint globals et des locaux:

>>> eval("somme([5, 5, 5]) ", , )
15
>>> eval("__import __ ('math'). sqrt (25)", , )
5,0
>>> eval("__import __ ('sous-processus'). getoutput ('echo Hello, World')", , )
'Bonjour le monde'

Même si vous limitez globals et des locaux en utilisant des dictionnaires vides, vous pouvez toujours utiliser n'importe quelle fonction intégrée comme vous l'avez fait avec somme() et __importation__() dans le code ci-dessus.

Vous pouvez utiliser __importation__() d'importer n'importe quel module standard ou tiers comme vous l'avez fait ci-dessus avec math et sous-processus. Avec cette technique, vous pouvez accéder à n'importe quelle fonction ou classe définie dans math, sous-processusou tout autre module. Imaginez maintenant ce qu'un utilisateur malveillant pourrait faire à votre système en utilisant sous-processus ou tout autre module puissant de la bibliothèque standard.

Pour minimiser ce risque, vous pouvez restreindre l'accès aux fonctions intégrées de Python en remplaçant le "__builtins__" entrer globals. Les bonnes pratiques recommandent d'utiliser un dictionnaire personnalisé contenant la paire clé-valeur "__builtins__": . Découvrez l'exemple suivant:

>>> eval("__import __ ('math'). sqrt (25)", "__builtins__": , )
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
  
  
  
  Fichier "", ligne 1, dans 
NameError: le nom '__import__' n'est pas défini

Si vous passez un dictionnaire contenant la paire clé-valeur "__builtins__": à globals, puis eval () n'aura pas d'accès direct aux fonctions intégrées de Python comme __importation__(). Cependant, comme vous le verrez dans la section suivante, cette approche ne fait toujours pas eval () complètement sécurisé.

Restriction des noms dans l'entrée

Même si vous pouvez restreindre l'environnement d'exécution de Python eval () en utilisant la coutume globals et des locaux dictionnaires, la fonction sera toujours vulnérable à quelques astuces fantaisistes. Par exemple, vous pouvez accéder à la classe objet utilisant un type littéral comme "", [], , ou () avec quelques attributs spéciaux:

>>> "".__classe__.__base__

>>> [].__classe__.__base__

>>> .__classe__.__base__

>>> ().__classe__.__base__

Une fois que vous avez accès à objet, vous pouvez utiliser la méthode spéciale .__ sous-classes __ () pour accéder à toutes les classes qui héritent de objet. Voici comment ça fonctionne:

>>> pour sous_classe dans ().__classe__.__base__.__sous-classes__():
...     impression(sous_classe.__Nom__)
...
type
faiblesse
proxy faible appelable
faible proxy
int
...

Ce code imprimera une grande liste de classes sur votre écran. Certaines de ces classes sont assez puissantes et peuvent être extrêmement dangereuses entre de mauvaises mains. Cela ouvre un autre trou de sécurité important que vous ne pouvez pas fermer en restreignant simplement l'environnement d'exécution de eval ():

>>> chaîne_entrée = "" "[[[[
...                 c pour c dans () .__ classe __.__ base __.__ sous-classes __ ()
...                 si c .__ nom__ == "plage"
... ][0](dix)"""
>>> liste(eval(chaîne_entrée, "__builtins__": , ))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

La compréhension de la liste dans le code ci-dessus filtre les classes qui héritent de objet retourner un liste contenant la classe gamme. Le premier indice ([0]) renvoie la classe gamme. Une fois que vous avez accès à gamme, vous l'appelez pour générer un gamme objet. Ensuite, vous appelez liste() sur le gamme pour générer une liste de dix entiers.

Dans cet exemple, vous utilisez gamme pour illustrer une faille de sécurité eval (). Imaginez maintenant ce qu'un utilisateur malveillant pourrait faire si votre système exposait des classes comme subprocess.Popen.

Une solution possible à cette vulnérabilité consiste à restreindre l'utilisation de noms dans l'entrée, soit à un groupe de sûr noms ou à non noms du tout. Pour implémenter cette technique, vous devez suivre les étapes suivantes:

1. Créer un dictionnaire contenant les noms que vous souhaitez utiliser avec eval ().
2. Compiler la chaîne d'entrée à bytecode en utilisant compiler() en mode "eval".
3. Vérifier .co_names sur l'objet bytecode pour vous assurer qu'il ne contient que des noms autorisés.
4. Élever une NameError si l'utilisateur essaie d'entrer un nom qui n'est pas autorisé.

Jetez un œil à la fonction suivante dans laquelle vous implémentez toutes ces étapes:

>>> def eval_expression(chaîne_entrée):
...     # Étape 1
...     noms_autorisés = "somme": somme
...     # Étape 2
...     code = compiler(chaîne_entrée, "", "eval")
...     # Étape 3
...     pour Nom dans code.co_names:
...         si Nom ne pas dans noms_autorisés:
...             # Étape 4
...             élever NameError(F"Utilisation de Nom    interdit")
...     revenir eval(code, "__builtins__": , noms_autorisés)

Dans eval_expression (), vous implémentez toutes les étapes que vous avez vues précédemment. Cette fonction restreint les noms que vous pouvez utiliser avec eval () à seulement ces noms dans le dictionnaire noms_autorisés. Pour ce faire, la fonction utilise .co_names, qui est un attribut d'un objet de code qui renvoie un tuple contenant les noms dans l'objet de code.

Les exemples suivants montrent comment eval_expression () travaille en pratique:

>>> eval_expression("3 + 4 * 5 + 25/2")
35,5
>>> eval_expression("somme([1, 2, 3]) ")
6
>>> eval_expression("len ([1, 2, 3]) ")
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
  
  
  
  Fichier "", ligne dix, dans eval_expression
NameError: Utilisation de len non autorisée
>>> eval_expression("pow (10, 2)")
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
  
  
  
  Fichier "", ligne dix, dans eval_expression
NameError: Utilisation de pow non autorisée

Si vous appelez eval_expression () pour évaluer les opérations arithmétiques, ou si vous utilisez des expressions qui incluent des noms autorisés, vous obtiendrez le résultat attendu. Sinon, vous obtiendrez un NameError. Dans les exemples ci-dessus, le seul nom que vous avez autorisé est somme(). D'autres noms comme len () et pow () ne sont pas autorisés, donc la fonction soulève un NameError lorsque vous essayez de les utiliser.

Si vous souhaitez interdire complètement l'utilisation des noms, vous pouvez réécrire eval_expression () comme suit:

>>> def eval_expression(chaîne_entrée):
...     code = compiler(chaîne_entrée, "", "eval")
...     si code.co_names:
...         élever NameError(F"Utilisation de noms non autorisée")
...     revenir eval(code, "__builtins__": , )
...
>>> eval_expression("3 + 4 * 5 + 25/2")
35,5
>>> eval_expression("somme([1, 2, 3]) ")
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
  
  
  
  Fichier "", ligne 4, dans eval_expression
NameError: Utilisation de noms non autorisée

Maintenant, votre fonction ne permet pas tout noms dans la chaîne d'entrée. Pour ce faire, vous vérifiez les noms dans .co_names et élever un NameError si on en trouve. Sinon, vous évaluez chaîne_entrée et retourner le résultat de l'évaluation. Dans ce cas, vous utilisez un dictionnaire vide pour restreindre des locaux ainsi que.

Vous pouvez utiliser cette technique pour minimiser les problèmes de sécurité de eval () et renforcez votre armure contre les attaques malveillantes.

Restreindre l'entrée aux seuls littéraux

Un cas d'utilisation courant pour Python eval () est d'évaluer les chaînes qui contiennent des littéraux Python standard et de les transformer en objets concrets.

La bibliothèque standard fournit une fonction appelée literal_eval () qui peuvent aider à atteindre cet objectif. La fonction ne prend pas en charge les opérateurs, mais elle prend en charge les listes, les tuples, les nombres, les chaînes, etc.:

>>> de ast importation literal_eval
>>> # Évaluation des littéraux
>>> literal_eval("15.02")
15.02
>>> literal_eval("[1, 15]")
[1, 15]
>>> literal_eval("(1, 15)")
(1, 15)
>>> literal_eval("'un': 1, 'deux': 2")
'un': 1, 'deux': 2
>>> # Essayer d'évaluer une expression
>>> literal_eval("somme([1, 15]) + 5 + 8 * 2 ")
Traceback (dernier appel le plus récent):
  ...
ValueError: nœud ou chaîne mal formé: <_ast.BinOp object at 0x7faedecd7668>

Remarquerez que literal_eval () ne fonctionne qu'avec des littéraux de type standard. Il ne prend pas en charge l'utilisation d'opérateurs ou de noms. Si vous essayez d'alimenter une expression literal_eval (), vous obtiendrez un ValueError. Cette fonction peut également vous aider à minimiser les risques de sécurité associés à l’utilisation de Python eval ().