Quels sont les dangers de la fonction eval(parse(...))?

Il y a plusieurs questions sur la façon d'éviter d'utiliser eval(parse(...))

Qui déclenche les questions:

  • Pourquoi, en particulier, devrait eval(parse()) - elle être évitée?
  • Et surtout, Quels en sont les dangers?
    • Sont-il dangereux si le code n'est pas utilisé dans la production? (Je suis en train de penser, tout risque de retour des résultats inattendus. En clair, si vous n'êtes pas prudent sur ce que vous analysez, vous aurez des problèmes. Mais est-ce plus dangereux que d'être bâclée avec get()?)
  • Je ne sais pas si je vais avoir le temps de créer un bon exemple/écrire une réponse, mais mes maux de tête dans cette direction ont eu plus à faire avec eval() généralement que avec eval(parse()). Le problème avec eval() est qu'il essaie de suivre une certaine base, mais souvent difficiles à comprendre des règles sur les cadres dans lesquels l'expression est évaluée, et ceux-ci peuvent souvent vous mordre quand vous commencez à utiliser des constructions de code de manière plus complexe que l'auteur à l'origine de la pensée de ... obeautifulcode.com/R/How-R-Searches-And-Finds-Stuff
  • cette question semble être de frapper beaucoup de résultats de recherche. Si vous souhaitez revenir sur votre commentaire ci-dessus, j'aimerais entendre plus de vos pensées, je suis sûr que d'autres seraient ainsi
  • Saporta, vous semblent profiter de l'aide de data.table. Fait intéressant, je suis tombé sur la poste où est expliqué que eval peut être plus rapide que get, dans certains cas, avec data.table
InformationsquelleAutor Ricardo Saporta | 2012-11-30
  1. 39

    La plupart des arguments contre la eval(parse(...)) surviennent pas en raison de problèmes de sécurité, après tout, aucune réclamation n'est faite à propos de R un approvisionnement sûr de l'interface d'exposer à l'Internet, mais plutôt parce que ce code est généralement de faire des choses qui peut être accompli en utilisant moins obscur méthodes, c'est à dire des méthodes qui sont à la fois plus rapide et plus humain analyser-mesure. Le langage R est censé être de haut niveau, de sorte que la préférence des connaisseurs (et je ne me considère pas dans le groupe) est de voir le code qui est à la fois compact et expressive.

    Ainsi, le danger est que eval(parse(..)) est une porte dérobée méthode de contourner le manque de connaissances et de l'espoir dans la levée de cet obstacle est que les gens vont améliorer leur utilisation de la R de la langue. La porte reste ouverte, mais l'espoir est de plus expressive utilisez d'autres fonctionnalités. Carl Witthoft la question plus tôt aujourd'hui illustré en ne sachant pas que le get fonction était disponible, et la la question qu'il a lié pour révélé un manque de compréhension de la façon la [[ fonction comportés (et comment $ a été plus limité que [[). Dans les deux cas, une eval(parse(..)) solution pourrait être construit, mais il était moins agiles et moins claire que l'autre.

    InformationsquelleAutor 42-
  2. 34

    Les préoccupations en matière de sécurité seulement vraiment se poser si vous commencez à appeler eval sur les cordes qu'un autre utilisateur est passé pour vous. C'est une grosse affaire si vous créez une application qui s'exécute R dans le fond, mais pour l'analyse de données lorsque vous écrivez du code à exécuter par vous-même, alors vous ne devriez pas avoir à vous soucier de l'effet de eval sur la sécurité.

    Certains autres problèmes avec eval(parse( bien.

    Tout d'abord, le code utilisant eval-analyser est généralement beaucoup plus difficile à déboguer que les non-analysée code, ce qui est problématique parce que le débogage des logiciels est deux fois plus difficile que la rédaction en premier lieu.

    Voici une fonction avec une erreur en elle.

    std <- function()
{
  mean(1to10)
}

    Je suis bête, j'ai oublié l'opérateur deux points et créé mon vecteur tort. Si j'essaie et la source de cette fonction, puis R avis le problème et renvoie une erreur, de me pointer à mon erreur.

    Voici le eval-analyser version.

    ep <- function()
{
  eval(parse(text = "mean(1to10)"))
}

    Ce sera source, parce que l'erreur est à l'intérieur d'une chaîne valide. C'est seulement plus tard, quand nous venons à exécuter le code de l'erreur est levée. Ainsi, en utilisant eval-analyser, nous avons perdu la source de l'erreur au moment de la vérification de la capacité.

    Je pense aussi que cette deuxième version de la fonction est beaucoup plus difficile à lire.

    L'autre problème avec eval-analyser, c'est qu'il est beaucoup plus lent que le code exécuté. Comparer

    system.time(for(i in seq_len(1e4)) mean(1:10))
   user  system elapsed 
   0.08    0.00    0.07

    et

    system.time(for(i in seq_len(1e4)) eval(parse(text = "mean(1:10)")))
   user  system elapsed 
   1.54    0.14    1.69
    InformationsquelleAutor Richie Cotton
  3. 17

    Habituellement, il y a une meilleure façon de l'informatique sur la langue " que de travailler avec un code-strings; evalparse lourds-code a besoin de beaucoup de protection pour garantir un bon de sortie, dans mon expérience.

    La même tâche peut généralement être résolu par un travail sur la R du code dans un langage objet directement; Hadley Wickham a un guide utile sur la méta-programmation en R ici:

    La defmacro() fonction dans le gtools bibliothèque est mon préféré remplacer (pas de demi-assed R pun intended) pour la evalparse construire

    require(gtools)

# both action_to_take & predicate will be subbed with code

F <- defmacro(predicate, action_to_take, expr = 
    if(predicate) action_to_take)

F(1 != 1, action_to_take = print('arithmetic doesnt work!'))

F(pi > 3, action_to_take = return('good!'))
[1] 'good!'

# the raw code for F
print(F)

function (predicate = stop("predicate not supplied"), action_to_take = stop("action_to_take not supplied")) 
{
    tmp <- substitute(if (predicate) action_to_take)
    eval(tmp, parent.frame())
}
<environment: 0x05ad5d3c>

    L'avantage de cette méthode est que vous avez la garantie de récupérer un point de vue syntaxique-juridique R code. En savoir plus sur cette fonction utile peut être trouvé ici:

    Espère que ça aide!

    • Incroyable! Merci de remarquer gtools & defmacro
    InformationsquelleAutor RyanGrannell
  4. 8

    Dans certains langages de programmation, eval() est une fonction qui évalue
    une chaîne de caractères comme s'il s'agissait d'une expression et renvoie un résultat; dans
    d'autres, il exécute plusieurs lignes de code, comme s'ils avaient été
    inclus au lieu de la ligne, y compris la fonction eval. L'entrée à la fonction eval est
    pas nécessairement une chaîne; dans les langues syntaxique
    les abstractions (comme Lisp), eval entrée sera composé de résumé
    formes syntaxiques.
    http://en.wikipedia.org/wiki/Eval

    Il y a toutes sortes d'exploits que l'on peut prendre avantage de si eval est utilisé de manière inappropriée.

    Un attaquant pourrait fournir un programme de la chaîne
    "la session.mise à jour(authentifié=True)" en tant que données, ce qui permettrait de mettre à jour le
    session dictionnaire pour définir une clé authentifiée pour être Vrai. Pour remédier à
    ce, de toutes les données qui sera utilisé avec la fonction eval doit être échappé, ou il
    doit être exécuté sans l'accès à potentiellement dangereux fonctions.
    http://en.wikipedia.org/wiki/Eval

    En d'autres termes, le plus grand danger de eval() est le potentiel de l'injection de code dans votre application. L'utilisation de eval() peut également provoquer des problèmes de performances dans certaines langues, selon ce qui est utilisé pour.

    Spécifiquement dans R, c'est probablement parce que vous pouvez utiliser get() en place de eval(parse()) et vos résultats seront les mêmes, sans avoir à recourir à eval()

    • des exemples concrets de chaînes un smart de l'utilisateur ou un pirate peut utiliser: T <- FALSE; F <- TRUE, rm(list=ls()), system("rm -rf your_directories"), source("http://.../virus.R").
    • Il y a une version sécurisée de eval (eval.secure) dans le RAppArmor package qui s'exécute dans un bac à sable, et ne peut pas exercer les droits de super-utilisateur, à moins que le processus parent a eux.
    • merci pour aborder les failles de sécurité! et +1 pour @mplourde pour eval.secure
    • Je ne pense pas que la première citation est correcte. Qui décrivent les mesures que je crois être effectuée par parse(). L' (valide) entrée de eval est presque jamais une "chaîne".
    InformationsquelleAutor ORION