Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
Herramientas/GitHubGitHub/musergi/cve-2021-3156
Escalada de PrivilegiosAnálisis de VulnerabilidadesExplotaciónPapers e InvestigaciónAprendizaje y EducaciónExplotación de Binarios
GitHubmusergi/cve-2021-3156

CVE-2021-3156

Implementación educativa y análisis de CVE-2021-3156, un desbordamiento de búfer en el montón en la función set_cmnd() de sudo, que permite la escalada de privilegios a root mediante argumentos de línea de comandos manipulados.

Ver Repositorio
223hace 4 añosAún no revisado
Compartir

CVE-2021-3156

En este documento incluimos todo el conocimiento necesario para entender el código de este repositorio y por qué funciona. Toda la explicación se basa en el informe creado por QUALYS. Allí se explican otras formas de explotación.

Requisitos

Las versiones vulnerables de sudo son las versiones heredadas de 1.8.2 a 1.8.31p2 y todas las versiones estables de 1.9.0 a 1.9.5p1, en su configuración por defecto.

Este repositorio está probado en Ubuntu 20.04 (sudo 1.8.31). En él abrimos una terminal con privilegios de root.

Análisis

Si Sudo se ejecuta para correr un comando en modo shell:

  • Mediante la opción -s, que establece la bandera MODE_SHELL de sudo.
  • Mediante la opción -i, que establece las banderas MODE_SHELL y MODE_LOGIN_SHELL de sudo.

Entonces, al inicio de main() de sudo, parse_args() reescribe argv, concatenando todos los argumentos de la línea de comandos y escapando todos los metacaracteres con barras invertidas.

    if (ISSET(mode, MODE_RUN) && ISSET(flags, MODE_SHELL)) {
        char **av, *cmnd = NULL;
        int ac = 1;

            cmnd = dst = reallocarray(NULL, cmnd_size, 2);

            for (av = argv; *av != NULL; av++) {
                for (src = *av; *src != '\0'; src++) {
                    /* quote potential meta characters */
                    if (!isalnum((unsigned char)*src) && *src != '_' && *src != '-' && *src != '$')
                        *dst++ = '\\';
                    *dst++ = *src;
                }
                *dst++ = ' ';
            }
...
            ac += 2; /* -c cmnd */
...
        av = reallocarray(NULL, ac + 1, sizeof(char *));
...
        av[0] = (char *)user_details.shell; /* plugin may override shell */
        if (cmnd != NULL) {
            av[1] = "-c";
            av[2] = cmnd;
        }
        av[ac] = NULL;

        argv = av;
        argc = ac;
    }

Más tarde, en sudoers_policy_main(), set_cmnd() concatena los argumentos de la línea de comandos en un buffer user_args basado en el montón (heap) y desescapa los metacaracteres, "para fines de coincidencia y registro de sudoers":

    if (sudo_mode & (MODE_RUN | MODE_EDIT | MODE_CHECK)) {
...
             for (size = 0, av = NewArgv + 1; *av; av++)
                 size += strlen(*av) + 1;
             if (size == 0 || (user_args = malloc(size)) == NULL) {
...
             }
             if (ISSET(sudo_mode, MODE_SHELL|MODE_LOGIN_SHELL)) {
...
                 for (to = user_args, av = NewArgv + 1; (from = *av); av++) {
                     while (*from) {
                         if (from[0] == '\\' && !isspace((unsigned char)from[1]))
                             from++;
                         *to++ = *from++;
                     }
                     *to++ = ' ';
                 }
...
             }
...
     }

Si un argumento de la línea de comandos termina con un solo carácter de barra invertida, entonces:

  • from[0] es el carácter de barra invertida y from[1] el terminador nulo
  • from se incrementa y apunta al terminador nulo
  • El terminador nulo se copia al buffer user_args y from se incrementa de nuevo y apunta fuera de los límites
  • El bucle while lee y copia caracteres fuera de los límites al buffer user_args.

En otras palabras, set_cmnd() es vulnerable a un desbordamiento del buffer basado en el montón, porque los caracteres fuera de los límites que se copian al buffer user_args no fueron incluidos en su tamaño.

En teoría, sin embargo, ningún argumento de línea de comandos puede terminar con un solo carácter de barra invertida: si MODE_SHELL o MODE_LOGIN_SHELL está establecido (una condición necesaria para llegar al código vulnerable), entonces MODE_SHELL está establecido y parse_args() ya escapó todos los metacaracteres, incluyendo las barras invertidas (es decir, escapó cada barra invertida individual con una segunda barra invertida).

En la práctica, sin embargo, el código vulnerable en set_cmnd() y el código de escape en parse_args() están rodeados por condiciones ligeramente diferentes:

    if (sudo_mode & (MODE_RUN | MODE_EDIT | MODE_CHECK)) {
...
            if (ISSET(sudo_mode, MODE_SHELL|MODE_LOGIN_SHELL)) {`

versus:

    if (sudo_mode & (MODE_RUN | MODE_EDIT | MODE_CHECK)) {

La pregunta, entonces, es: ¿podemos establecer MODE_SHELL y ya sea MODE_EDIT o MODE_CHECK (para llegar al código vulnerable) pero no el MODE_RUN por defecto (para evitar el código de escape)?

La respuesta, al parecer, es no: si establecemos MODE_EDIT (opción -e) o MODE_CHECK (opción -l), entonces parse_args() elimina MODE_SHELL de valid_flags y sale con un error si especificamos una bandera inválida como MODE_SHELL):

                case 'e':
...
                    mode = MODE_EDIT;
                    sudo_settings[ARG_SUDOEDIT].value = "true";
                    valid_flags = MODE_NONINTERACTIVE;
                    break;
...
                case 'l':
...
                    mode = MODE_LIST;
                    valid_flags = MODE_NONINTERACTIVE|MODE_LONG_LIST;
                    break;
...
    if (argc > 0 && mode == MODE_LIST)
        mode = MODE_CHECK;
...
    if ((flags & valid_flags) != flags)
        usage(1);

Pero encontramos una escapatoria: si ejecutamos Sudo como sudoedit en lugar de sudo, entonces parse_args() establece automáticamente MODE_EDIT pero no reinicia valid_flags, y las valid_flags incluyen MODE_SHELL por defecto:

#define DEFAULT_VALID_FLAGS     (MODE_BACKGROUND|MODE_PRESERVE_ENV|MODE_RESET_HOME|MODE_LOGIN_SHELL|MODE_NONINTERACTIVE|MODE_SHELL)
...
    int valid_flags = DEFAULT_VALID_FLAGS;
...
    proglen = strlen(progname);
    if (proglen > 4 && strcmp(progname + proglen - 4, "edit") == 0) {
        progname = "sudoedit";
        mode = MODE_EDIT;
        sudo_settings[ARG_SUDOEDIT].value = "true";
    }

En consecuencia, si ejecutamos "sudoedit -s", entonces establecemos tanto MODE_EDIT como MODE_SHELL (pero no MODE_RUN), evitamos el código de escape, llegamos al código vulnerable y desbordamos el buffer user_args basado en el montón mediante un argumento de línea de comandos que termina con un solo carácter de barra invertida:

sudoedit -s '\' `perl -e 'print "A" x 65536'`
malloc(): corrupted top size
Aborted (core dumped)

Desde el punto de vista de un atacante, este desbordamiento de buffer es ideal:

  • Controlamos el tamaño del buffer user_args que desbordamos (el tamaño de nuestros argumentos de línea de comandos concatenados);
  • Controlamos de forma independiente el tamaño y el contenido del propio desbordamiento (nuestro último argumento de línea de comandos está convenientemente seguido por nuestras primeras variables de entorno, que no están incluidas en el cálculo del tamaño);
  • Incluso podemos escribir bytes nulos en el buffer que desbordamos (cada argumento de línea de comandos o variable de entorno que termina con una sola barra invertida escribe un byte nulo en user_args).

Por ejemplo, en un Linux amd64, el siguiente comando asigna un buffer user_args de 24 bytes (un fragmento de montón de 32 bytes) y sobrescribe el campo size del siguiente fragmento con "A=a\0B=b\0" (0x00623d4200613d41), su campo fd con "C=c\0D=d\0" (0x00643d4400633d43) y su campo bk con "E=e\0F=f\0" (0x00663d4600653d45):

env -i 'AA=a\' 'B=b\' 'C=c\' 'D=d\' 'E=e\' 'F=f' sudoedit -s '1234567890123456789012\'
--|--------+--------+--------+--------|--------+--------+--------+--------+--
  |        |        |12345678|90123456|789012.A|A=a.B=b.|C=c.D=d.|E=e.F=f.|
--|--------+--------+--------+--------|--------+--------+--------+--------+--
              size  <---- buffer user_args ---->  size      fd       bk

Explotación

Program received signal SIGSEGV, Segmentation fault.
Descargar herramienta

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 El kit de herramientas OSINT definitivo: grafo de investigación, puntuación de confianza, familias de alias, mapa, línea de tiempo e informes. 49 módulos, más de 400 sitios, sin necesidad de claves API.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicación de Ejecución con un Solo Toque GhostLock (CVE-2026-43499)

    594
  • 3

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingiere informes de Shadowserver en MongoDB y los reproduce como mapas interactivos, análisis, hallazgos, avisos y paneles ejecutivos.

    376
  • 4

    redforge

    cybersecurity91/redforge

    Kit de herramientas de red team del lado del navegador con 102 herramientas offline para reconocimiento, generación de payloads, ataques de credenciales, criptografía, codificación y elaboración de informes de compromiso.

    326
  • 5

    ARTEX

    baarai/artex

    Plataforma de pruebas de penetración autónoma multiagente basada en LLM con agentes planificadores/trabajadores, grafos de activos y de exploración, registro de tráfico MITM y reevaluación de vulnerabilidades.

    323
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    El sistema de acción para la ciberseguridad nativa de IA—donde la intención se convierte en ejecución gobernada, la evidencia se convierte en memoria operativa y cada operación mejora la siguiente.

    321

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →