Python eval:如果我禁用内置和属性访问,它仍然很危险吗？

Question

我们都知道这eval很危险,即使你隐藏了危险的函数,因为你可以使用Python的内省功能深入挖掘并重新提取它们.例如,即使您删除__builtins__,也可以使用它来检索它们

[c for c in ().__class__.__base__.__subclasses__()  
 if c.__name__ == 'catch_warnings'][0]()._module.__builtins__

但是,我见过的每个例子都使用属性访问.如果我禁用所有内置函数并禁用属性访问(通过使用Python令牌化程序对输入进行标记,并在具有属性访问令牌时拒绝它),该怎么办？

在你问之前,不,对于我的用例,我不需要其中任何一个,所以它不会太瘫痪.

我想要做的是让SymPy的同情功能更安全.目前,它对输入进行了标记,对其进行了一些转换,并在命名空间中对其进行了演绎.但它不安全,因为它允许属性访问(即使它真的不需要它).

Answer 1

我将提到Python 3.6的一个新功能 - f-strings.

他们可以评估表达,

>>> eval('f"{().__class__.__base__}"', {'__builtins__': None}, {})
"<class 'object'>"

但是Python的tokenizer不会检测到属性访问:

0,0-0,0:            ENCODING       'utf-8'        
1,0-1,1:            ERRORTOKEN     "'"            
1,1-1,27:           STRING         'f"{().__class__.__base__}"'
2,0-2,0:            ENDMARKER      '' 

Answer 2

它可以构建从一个返回值eval,将抛出一个异常 外 eval,如果你想print,log,repr,任何事情:

eval('''((lambda f: (lambda x: x(x))(lambda y: f(lambda *args: y(y)(*args))))
        (lambda f: lambda n: (1,(1,(1,(1,f(n-1))))) if n else 1)(300))''')

这会创建一个嵌套的表单元组(1,(1,(1,(1...; 该值无法print编辑(在Python 3上),stred或repred; 所有调试它的尝试都会导致

RuntimeError: maximum recursion depth exceeded while getting the repr of a tuple

pprint也saferepr失败了:

...
  File "/usr/lib/python3.4/pprint.py", line 390, in _safe_repr
    orepr, oreadable, orecur = _safe_repr(o, context, maxlevels, level)
  File "/usr/lib/python3.4/pprint.py", line 340, in _safe_repr
    if issubclass(typ, dict) and r is dict.__repr__:
RuntimeError: maximum recursion depth exceeded while calling a Python object

因此没有安全的内置函数来对此进行字符串化:可以使用以下帮助程序:

def excsafe_repr(obj):
    try:
        return repr(obj)
    except:
        return object.__repr__(obj).replace('>', ' [exception raised]>')

然后有一个问题,print在Python 2中实际上并没有使用str/ repr,因此由于缺少递归检查而没有任何安全性.也就是说,取上面的lambda怪物的返回值,你不能str,repr它,但普通print(不print_function!)打印得很好.但是,如果您知道将使用以下print语句打印它,您可以利用它在Python 2上生成SIGSEGV :

print eval('(lambda i: [i for i in ((i, 1) for j in range(1000000))][-1])(1)')

使用SIGSEGV崩溃Python 2.这是bug跟踪器中的WONTFIX.因此,print如果您想要安全,请不要使用-the-statement.from __future__ import print_function!

这不是崩溃,而是

eval('(1,' * 100 + ')' * 100)

运行时,输出

s_push: parser stack overflow
Traceback (most recent call last):
  File "yyy.py", line 1, in <module>
    eval('(1,' * 100 + ')' * 100)
MemoryError

在MemoryError可以被捕获,是的子类Exception.解析器有一些非常保守的限制,以避免来自stackoverflow的崩溃(双关语意图).但是,由C代码s_push: parser stack overflow输出stderr,不能被抑制.

就在昨天,我问为什么Python 3.4不能修复崩溃,

% python3  
Python 3.4.3 (default, Mar 26 2015, 22:03:40) 
[GCC 4.9.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> class A:
...     def f(self):
...         nonlocal __x
... 
[4]    19173 segmentation fault (core dumped)  python3

和Serhiy Storchaka的回答证实,Python核心开发人员并不认为SIGSEGV在看似格式良好的代码上存在安全问题:

3.4仅接受安全修复程序.

因此可以得出结论,在Python中执行来自第三方的任何代码,无论是否已经消毒,都不能被认为是安全的.

而尼克·科格伦然后加入:

而且,作为Python代码引发的分段错误原因的一些额外背景目前不被视为安全漏洞:由于CPython不包含安全沙箱,我们已经完全依赖操作系统来提供进程隔离.该操作系统级安全边界不受代码是"正常"运行的影响,也不受故意触发的分段故障后的修改状态的影响.

Answer 3

用户仍然可以通过输入一个计算结果很大的表达式来帮助你,这会填满你的内存并使Python进程崩溃,例如

'10**10**100'

如果更复杂的攻击,如恢复内置或创建段错误,我肯定仍然很好奇.

编辑:

事实证明,即使是Python的解析器也存在这个问题.

lambda: 10**10**100

将挂起,因为它试图预先计算常量.

Answer 4

我不相信Python的设计可以抵御不受信任的代码.这是在官方Python 2解释器中通过堆栈溢出(在C堆栈上)引发段错误的简单方法:

eval('()' * 98765)

从我回答 "返回SIGSEGV的最短代码"代码高尔夫问题.

Answer 5

这是一个 safe_eval 示例，它将确保评估的表达式不包含不安全的标记。它不会尝试采用literal_eval 方法来解释AST，而是将令牌类型列入白名单并使用真正的eval if 表达式通过测试。

# license: MIT (C) tardyp
import ast


def safe_eval(expr, variables):
    """
    Safely evaluate a a string containing a Python
    expression.  The string or node provided may only consist of the following
    Python literal structures: strings, numbers, tuples, lists, dicts, booleans,
    and None. safe operators are allowed (and, or, ==, !=, not, +, -, ^, %, in, is)
    """
    _safe_names = {'None': None, 'True': True, 'False': False}
    _safe_nodes = [
        'Add', 'And', 'BinOp', 'BitAnd', 'BitOr', 'BitXor', 'BoolOp',
        'Compare', 'Dict', 'Eq', 'Expr', 'Expression', 'For',
        'Gt', 'GtE', 'Is', 'In', 'IsNot', 'LShift', 'List',
        'Load', 'Lt', 'LtE', 'Mod', 'Name', 'Not', 'NotEq', 'NotIn',
        'Num', 'Or', 'RShift', 'Set', 'Slice', 'Str', 'Sub',
        'Tuple', 'UAdd', 'USub', 'UnaryOp', 'boolop', 'cmpop',
        'expr', 'expr_context', 'operator', 'slice', 'unaryop']
    node = ast.parse(expr, mode='eval')
    for subnode in ast.walk(node):
        subnode_name = type(subnode).__name__
        if isinstance(subnode, ast.Name):
            if subnode.id not in _safe_names and subnode.id not in variables:
                raise ValueError("Unsafe expression {}. contains {}".format(expr, subnode.id))
        if subnode_name not in _safe_nodes:
            raise ValueError("Unsafe expression {}. contains {}".format(expr, subnode_name))

    return eval(expr, variables)



class SafeEvalTests(unittest.TestCase):

    def test_basic(self):
        self.assertEqual(safe_eval("1", {}), 1)

    def test_local(self):
        self.assertEqual(safe_eval("a", {'a': 2}), 2)

    def test_local_bool(self):
        self.assertEqual(safe_eval("a==2", {'a': 2}), True)

    def test_lambda(self):
        self.assertRaises(ValueError, safe_eval, "lambda : None", {'a': 2})

    def test_bad_name(self):
        self.assertRaises(ValueError, safe_eval, "a == None2", {'a': 2})

    def test_attr(self):
        self.assertRaises(ValueError, safe_eval, "a.__dict__", {'a': 2})

    def test_eval(self):
        self.assertRaises(ValueError, safe_eval, "eval('os.exit()')", {})

    def test_exec(self):
        self.assertRaises(SyntaxError, safe_eval, "exec 'import os'", {})

    def test_multiply(self):
        self.assertRaises(ValueError, safe_eval, "'s' * 3", {})

    def test_power(self):
        self.assertRaises(ValueError, safe_eval, "3 ** 3", {})

    def test_comprehensions(self):
        self.assertRaises(ValueError, safe_eval, "[i for i in [1,2]]", {'i': 1})