我的 eval 实现是完全安全的吗？

Question

我有一个代码，其中我想，让用户通过标准输入三个值，每种类型的float，Fraction或者int，所以我不能申请ast.literal_eval输入得到结果，我想要的。

我读到Eval 真的很危险，显示

• eval提供意见的人如何利用弱点，以及
• 一些如何使eval调用更安全的方法。

我应用了作者的建议并编写了此代码，替换了默认值eval：

import builtins

class DoubleUnderscoreInEval(ValueError):
    pass

def eval(expression, globals={}, locals=None):
    if '__' in expression:
        raise DoubleUnderscoreInEval('Using __ in eval is not allowed for safety reasons.')
    else:
        if '__builtins__' not in globals:
            globals['__builtins__']={}
        return builtins.eval(expression, globals, locals)

builtins.eval通过我的代码使用是否完全安全？
如果不是，我可以使eval调用完全安全吗？（鼓励绕过我的限制的字符串）
如果是，如何？如果不是，我可以用什么代替？

我是 Python 的初学者，所以鼓励任何告诉我如何改进我的代码的评论。

我在在线编译器中的整个代码

Answer 1

不，您的eval()实施并不安全。其他对象也可以访问__builtins__映射。

有关一些示例，请参阅Ned Batchelder 的eval 是危险的。

例如，以下字符串可能会导致段错误：

s = """
(lambda fc=(
    lambda n: [
        c for c in 
            ().__class__.__bases__[0].__subclasses__() 
            if c.__name__ == n
        ][0]
    ):
    fc("function")(
        fc("code")(
            0,0,0,0,"KABOOM",(),(),(),"","",0,""
        ),{}
    )()
)()
"""

我担心，仅仅禁止双下划线是不够的。一些有进取心的人会找到一种以您没有预料到的创造性方式重新组合双下划线的方法，无论如何您都会发现自己被黑了。

该ast.literal_eval()方法使用 AST 解析和解析树的自定义处理来支持内置类型。您可以通过添加对“安全”可调用对象的支持来执行相同的操作：

import ast

def literal_eval_with_callables(node_or_string, safe_callables=None):
    if safe_callables is None:
        safe_callables = {}
    if isinstance(node_or_string, str):
        node_or_string = ast.parse(node_or_string, mode='eval')
    if isinstance(node_or_string, ast.Expression):
        node_or_string = node_or_string.body
    try:
        # Python 3.4 and up
        ast.NameConstant
        const_test = lambda n: isinstance(n, ast.NameConstant)
        const_extract = lambda n: n.value
    except AttributeError:
        # Everything before
        _const_names = {'None': None, 'True': True, 'False': False}
        const_test = lambda n: isinstance(n, ast.Name) and n.id in _const_names
        const_extract = lambda n: _const_names[n.id]
    def _convert(node):
        if isinstance(node, (ast.Str, ast.Bytes)):
            return node.s
        elif isinstance(node, ast.Num):
            return node.n
        elif isinstance(node, ast.Tuple):
            return tuple(map(_convert, node.elts))
        elif isinstance(node, ast.List):
            return list(map(_convert, node.elts))
        elif isinstance(node, ast.Dict):
            return dict((_convert(k), _convert(v)) for k, v
                        in zip(node.keys, node.values))
        elif const_test(node):
            return const_extract(node)
        elif isinstance(node, ast.UnaryOp) and \
             isinstance(node.op, (ast.UAdd, ast.USub)) and \
             isinstance(node.operand, (ast.Num, ast.UnaryOp, ast.BinOp)):
            operand = _convert(node.operand)
            if isinstance(node.op, ast.UAdd):
                return + operand
            else:
                return - operand
        elif isinstance(node, ast.BinOp) and \
             isinstance(node.op, (ast.Add, ast.Sub)) and \
             isinstance(node.right, (ast.Num, ast.UnaryOp, ast.BinOp)) and \
             isinstance(node.right.n, complex) and \
             isinstance(node.left, (ast.Num, ast.UnaryOp, astBinOp)):
            left = _convert(node.left)
            right = _convert(node.right)
            if isinstance(node.op, ast.Add):
                return left + right
            else:
                return left - right
        elif isinstance(node, ast.Call) and \
             isinstance(node.func, ast.Name) and \
             node.func.id in safe_callables:
            return safe_callables[node.func.id](
                *[_convert(n) for n in node.args],
                **{kw.arg: _convert(kw.value) for kw in node.keywords})
        raise ValueError('malformed string')
    return _convert(node_or_string)

上述函数适应了 的实现ast.literal_eval()以添加对特定注册可调用项的支持。传入一个字典命名Fraction：

>>> import fractions
>>> safe_callables = {'Fraction': fractions.Fraction}
>>> literal_eval_with_callables('Fraction(1, denominator=2)', safe_callables)
Fraction(1, 2)

上述方法将要处理的内容列入白名单而不是黑名单。例如Fraction，允许调用，并直接控制将调用什么对象。

演示：

>>> samples = '''\
... 2, -9, -35
... 4, -13, 3
... -6, 13, 5
... 5, -6, 6
... -2, 5, -3
... 4, 12, 9
... 0.5, 1, 1
... 1, -0.5, -0.5
... 0.25, Fraction(-1, 3), Fraction(1, 9)'''.splitlines()
>>> safe_callables = {'Fraction': fractions.Fraction}
>>> for line in samples:
...     print(literal_eval_with_callables(line, safe_callables))
... 
(2, -9, -35)
(4, -13, 3)
(-6, 13, 5)
(5, -6, 6)
(-2, 5, -3)
(4, 12, 9)
(0.5, 1, 1)
(1, -0.5, -0.5)
(0.25, Fraction(-1, 3), Fraction(1, 9))

以上应该至少适用于 Python 3.3 及更高版本，可能更早。Python 2 需要做更多的工作来支持unicode字符串而不是中断ast.Bytes.